- Internet fundamentals
- Planning, content strategy, and information architecture
- HTML and CSS
25% of all author proceeds from this book will be donated to The Open Web Education Alliance (http://www.w3.org/2005/Incubator/owea/) to help advance web education around the world.
This second edition of a Manning bestseller has been revised and re-titled to fit the 'In Action' Series by Steve Loughran, an Ant project committer. Ant in Action introduces Ant and how to use it for test-driven Java application development. Ant itself is moving to v1.7, a major revision, at the end of 2006 so the timing for the book is right. A single application of increasing complexity, followed throughout the book, shows how an application evolves and how to handle the problems of building and testing. Reviewers have praised the book's coverage of large-projects, Ant's advanced features, and the details and depth of the discussion-all unavailable elsewhere.
This is a major revision with the second half of the book completely new, including:
- How to Manage Big projects
- Library management
- Enterprise Java
- Continuous integration
- Writing new Ant tasks and datatypes
Purchase of the print book comes with an offer of a free PDF, ePub, and Kindle eBook from Manning. Also available is all code from the book.
Many Java developers are now looking at Ruby, and the Ruby on Rails web framework. If you are one of them, this book is your guide. Written by experienced developers who love both Java and Ruby, this book will show you, via detailed comparisons and commentary, how to translate your hard-earned Java knowledge and skills into the world of Ruby and Rails.
If you are a Java programmer, you shouldn't have to start at the very beginning! You already have deep experience with the design issues that inspired Rails, and can use this background to quickly learn Ruby and Rails. But Ruby looks a lot different from Java, and some of those differences support powerful abstractions that Java lacks. We'll be your guides to this new, but not strange, territory.
In each chapter, we build a series of parallel examples to demonstrate some facet of web development. Because the Rails examples sit next to Java examples, you can start this book in the middle, or anywhere else you want. You can use the Java version of the code, plus the analysis, to quickly grok what the Rails version is doing. We have carefully cross-referenced and indexed the book to facilitate jumping around as you need to.
Thanks to your background in Java, this one short book can cover a half-dozen books' worth of ideas:Programming Ruby Building MVC (Model/View/Controller) Applications Unit and Functional Testing Security Project Automation Configuration Web Services
The Definitive Guide to JavaServer Faces 2.0
Fully revised and updated for all of the changes in JavaServer Faces (JSF) 2.0, this comprehensive volume covers every aspect of the official standard Web development architecture for JavaEE. Inside this authoritative resource, the co-spec lead for JSF at Sun Microsystems shows you how to create dynamic, cross-browser Web applications that deliver a world-class user experience while preserving a high level of code quality and maintainability.
JavaServer Faces 2.0: The Complete Reference features an integrated sample application to use as a model for your own JSF applications, with code available online. The book explains all JSF features, including the request processing lifecycle, managed beans, page navigation, component development, Ajax, validation, internationalization, and security. Expert Group Insights throughout the book offer insider information on the design of JSF.
- Set up a development environment and build a JSF application
- Understand the JSF request processing lifecycle
- Use the Facelets View Declaration Language, managed beans, and the JSF expression language (EL)
- Define page flow with the JSF Navigation Model, including the new "Implicit Navigation" feature
- Work with the user interface component model and the JSF event model, including support for bookmarkable pages and the POST, REDIRECT, GET pattern
- Use the new JSR-303 Bean Validation standard for model data validation
- Build Ajax-enabled custom UI components
Extend JSF with custom non-UI components
- Manage security, accessibility, internationalization, and localization
- Learn how to work with JSF and Portlets from the JSF Team Leader at Liferay, the leading Java Portal vendor
Ed Burns is a senior staff engineer at Sun Microsystems and is the co-specification lead for JavaServer Faces. He is the co-author of JavaServer Faces: The Complete Reference and author of Secrets of the Rock Star Programmers.
Chris Schalk is a developer advocate and works to promote Google's APIs and technologies. He is currently engaging the international Web development community with the new Google App Engine and OpenSocial APIs.
Neil Griffin is committer and JSF Team Lead for Liferay Portal and the co-founder of The PortletFaces Project.
Ready-to-use code at www.mhprofessonal.com/computingdownload
As the Web evolves to incorporate new standards and the latest browsers offer new possibilities for creative design, the art of creating Web sites is also changing. Few Web designers are experiences programmers, and as a result, working with semantic markup and CSS can create roadblocks to achieving truly beautiful designs using all the resources available. Add to this the pressures of presenting exceptional design to clients and employers, without compromising efficient workflow, and the challenge deepens for those working in a fast-paced environment. As someone who understands these complexities firsthand, author and designer Andy Clarke offers visual designers a progressive approach to creating artistic, usable, and accessible sites using transcendent CSS.
In this groundbreaking book, you’ll discover how to implement highly original designs through visual demonstrations of the creative possibilities using markup and CSS. You’ll learn to use a new design workflow, build prototypes that work well for designers and all team members, use grids effectively, visualize markup, and discover every phase of the transcendent design process, from working with the latest browsers to incorporating CSS3 to collaborating with team members effectively.
Transcending CSS: The Fine Art of Web Design:
Uses a visual approach to help you learn coding techniques
Includes numerous examples of world-class Web sites, photography, and other inspirations that give designers ideas for visualizing their codeOffers early previews of technical advances in new Web browsers and of the emerging CSS3 specification
JBoss Seam is an exciting new application framework based on the Java EE platform that is used to build rich, web-based business applications. Seam is rapidly capturing the interest of Java enterprise developers because of its focus on simplicity, ease of use, transparent integration, and scalability.
Seam in Action offers a practical and in-depth look at JBoss Seam. The book puts Seam head-to-head with the complexities in the Java EE architecture. The author presents an unbiased view of Seam from outside the walls of RedHat/JBoss, focusing on such topics as Spring integration and deployment to alternative application servers to steer clear of vendor lock-in. By the end of the book, you should expect to not only gain a deep understanding of Seam, but also come away with the confidence to teach the material to others.
To start off, you will see a working Java EE-compliant application come together by the end of the second chapter. As you progress through the book, you will discover how Seam eliminates unnecessary layers and configurations, solves the most common JSF pain points, and establishes the missing link between JSF, EJB 3 and JavaBean components. The author also shows you how Seam opens doors for you to incorporate technologies you previously have not had time to learn, such as business processes and stateful page flows (jBPM), Ajax remoting, PDF generation, asynchronous tasks, and more.
All too often, developers spend a majority of their time integrating disparate technologies, manually tracking state, struggling to understand JSF, wrestling with Hibernate exceptions, and constantly redeploying applications, rather than on the logic pertaining to the business at hand. Seam in Action dives deep into thorough explanations of how Seam eliminates these non-core tasks by leveraging configuration by exception, Java 5 annotations, and aspect-oriented programming.
Purchase of the print book comes with an offer of a free PDF, ePub, and Kindle eBook from Manning. Also available is all code from the book.
Once a basic understanding of the various request types is discussed, the book moves on to provide in-depth examples of how and when to use Ajax in a web site or web application. Different data transmission formats, including plain text, HTML, XML, and JSON are discussed for their advantages and disadvantages. Also included is a discussion on web services and how they may be used to perform Ajax techniques. Next, more complex topics are covered. A chapter introducing a request management framework explores how to manage all of the requests inside of an Ajax application. Ajax debugging techniques are also discussed.
Professional Ajax 2nd edition adds nearly 200 pages of new and expanded coverage compared to the first edition.
Clojure is a dynamic language for the Java Virtual Machine, with a compelling combination of features:
Clojure is elegant. Clojure's clean, careful design lets you write programs that get right to the essence of a problem, without a lot of clutter and ceremony.
Clojure is Lisp reloaded. Clojure has the power inherent in Lisp, but is not constrained by the history of Lisp.
Clojure is a functional language. Data structures are immutable, and functions tend to be side-effect free. This makes it easier to write correct programs, and to compose large programs from smaller ones.
Clojure is concurrent. Rather than error-prone locking, Clojure provides software transactional memory.
Clojure embraces Java. Calling from Clojure to Java is direct, and goes through no translation layer.
Clojure is fast. Wherever you need it, you can get the exact same performance that you could get from hand-written Java code.
Many other languages offer some of these features, but the combination of them all makes Clojure sparkle. Programming Clojure shows you why these features are so important, and how you can use Clojure to build powerful programs quickly.
To allow the creation of truly modular software, OOP has evolved into aspect-oriented programming. AspectJ is a mature AOP implementation for Java, now integrated with Spring.
AspectJ in Action, Second Edition is a fully updated, major revision of Ramnivas Laddad's best-selling first edition. It's a hands-on guide for Java developers. After introducing the core principles of AOP, it shows you how to create reusable solutions using AspectJ 6 and Spring 3. You'll master key features including annotation-based syntax, load-time weaver, annotation-based crosscutting, and Spring-AspectJ integration. Building on familiar technologies such as JDBC, Hibernate, JPA, Spring Security, Spring MVC, and Swing, you'll apply AOP to common problems encountered in enterprise applications.
This book requires no previous experience in AOP and AspectJ, but it assumes you're familiar with OOP, Java, and the basics of Spring.
"Clear, concisely worded, well-organized ... a pleasure to read."
-From the Foreword by Rod Johnson, Creator of the Spring Framework
"This book teaches you how to think in aspects. It is essential reading for both beginners who know nothing about AOP and experts who think they know it all."
-Andrew Eisenberg, AspectJ Development Tools Project Committer
"Ramnivas showcases how to get the best out of AspectJ and Spring."
-Andy Clement, AspectJ Project Lead
"One of the best Java books in years."
-Andrew Rhine, Software Engineer, eSecLending
"By far the best reference for Spring AOP and AspectJ."
-Paul Benedict, Software Engineer, Argus Health Systems
"Ramnivas expertly demystifies the awesome power of aspect-oriented programming."
-Craig Walls, author of Spring in Action
The rise of Ruby on Rails has signified a huge shift in how we build web applications today; it is a fantastic framework with a growing community. There is, however, space for another such framework that integrates seamlessly with Java. Thousands of companies have invested in Java, and these same companies are losing out on the benefits of a Rails–like framework. Enter Grails.
Grails is not just a Rails clone. It aims to provide a Rails–like environment that is more familiar to Java developers and employs idioms that Java developers are comfortable using, making the adjustment in mentality to a dynamic framework less of a jump. The concepts within Grails, like interceptors, tag libs, and Groovy Server Pages (GSP), make those in the Java community feel right at home.
Grails’ foundation is on solid open source technologies such as Spring, Hibernate, and SiteMesh, which gives it even more potential in the Java space: Spring provides powerful inversion of control and MVC, Hibernate brings a stable, mature object relational mapping technology with the ability to integrate with legacy systems, and SiteMesh handles flexible layout control and page decoration.
Grails complements these with additional features that take advantage of the coding–by–convention paradigm such as dynamic tag libraries, Grails object relational mapping, Groovy Server Pages, and scaffolding.
Graeme Rocher, Grails lead and founder, and Jeff Brown bring you completely up–to–date with their authoritative and fully comprehensive guide to the Grails framework. You’ll get to know all the core features, services, and Grails extensions via plug–ins, and understand the roles that Groovy and Grails are playing in the changing Web.
What you’ll learn
- Discover how the Web is changing and the role the Groovy language and its Rails framework play
- Get to know the Grails Project and its domains, services, filters, controllers, views, testing, and plug–ins
- Experience the availability of plug–ins for Rich Client and Ajax, web services, performance/utilities, scheduling, security, functionality, and even Persistence
- See how Grails works with other frameworks like Spring, Wicket, Hibernate, and more
- Create custom plug–ins in Grails
Who this book is for
This book is for everyone who is looking for a more agile approach to web development with a dynamic scripting language such as Groovy. This includes a large number of Java developers who have been enticed by the productivity gains seen with frameworks such as Ruby on Rails, JRuby on Rails, etc. The Web and its environment is a perfect fit for easily adaptable and concise languages such as Groovy and Ruby, and there is huge interest from the developer community in general to embrace these languages.
All true craftsmen need the best tools to do their finest work, and programmers are no different. Java Power Tools delivers 30 open source tools designed to improve the development practices of Java developers in any size team or organization. Each chapter includes a series of short articles about one particular tool -- whether it's for build systems, version control, or other aspects of the development process -- giving you the equivalent of 30 short reference books in one package.
No matter which development method your team chooses, whether it's Agile, RUP, XP, SCRUM, or one of many others available, Java Power Tools provides practical techniques and tools to help you optimize the process. The book discusses key Java development problem areas and best practices, and focuses on open source tools that can help increase productivity in each area of the development cycle, including:
- Build tools including Ant and Maven 2
- Version control tools such as CVS and Subversion, the two most prominent open source tools
- Quality metrics tools that measure different aspects of code quality, including CheckStyle, PMD, FindBugs and Jupiter
- Technical documentation tools that can help you generate good technical documentation without spending too much effort writing and maintaining it
- Unit Testing tools including JUnit 4, TestNG, and the open source coverage tool Cobertura
- Integration, Load and Performance Testing to integrate performance tests into unit tests, load-test your application, and automatically test web services, Swing interfaces and web interfaces
- Issue management tools including Bugzilla and Trac
- Continuous Integration tools such as Continuum, Cruise Control, LuntBuild and Hudson
Drive Even More Value from Virtualization: Write VMware® Applications that Automate Virtual Infrastructure Management
Companies running VMware have already achieved enormous gains through virtualization. The next wave of benefits will come when they reduce the time and effort required to run and manage VMware platforms. The VMware Infrastructure Software Development Kit (VI SDK) includes application programming interfaces (APIs) that allow developers and administrators to do just that. Until now, there has been little documentation for the APIs. In VMware VI and vSphere SDK, software architect Steve Jin demystifies the entire VMware VI and new vSphere SDK and offers detailed, task-based coverage of using the APIs to manage VMware more efficiently and cost-effectively.
Jin walks you through using the VI SDK and cloud-computing vSphere SDK to manage ESX servers, ESX clusters, and VirtualCenter servers in any environment–no matter how complex. Drawing on his extensive expertise working with VMware strategic partners and enterprise customers, he places the VI SDK in practical context, presenting realistic samples and proven best practices for building robust, effective solutions. Jin demonstrates how to manage every facet of a VMware environment, including inventory, host systems, virtual machines (VMs), snapshots, VMotion, clusters, resource pools, networking, storage, data stores, events, alarms, users, security, licenses, and scheduled tasks. Coverage includes
- Understanding how the VI SDK fits into your VMware VI and Cloud Ready vSphere Environment
- Discovering the VI and vSphere SDK from the bottom up
- Using the author’s new VI Java API to write shorter, faster, and more maintainable code
- Managing VI and vSphere inventory and configurations
- Moving running VMs and storages across different physical platforms without disruption
- Optimizing system resources, hardening system securities, backing up VMs and other resources
- Leveraging events, alarms, and scheduled tasks to automate the system management
- Developing powerful applications that integrate multiple API features and run on top of or alongside VMware platforms
- Using the VI SDK to monitor performance
- Scripting with the VI SDK: building solutions with VI Perl, PowerShell, and Jython
- Avoiding the pitfalls that trip up VMware VI developers
- Integrating with and extending VMware platforms using VI SDK
This book is an indispensable resource for all VMware developers and administrators who want to get more done in less time; for hardware vendors who want to integrate their products with VMware; for ISV developers building new VMware applications; and for every professional and student seeking a deeper mastery of virtualization.
Your co-workers' resistance to new technologies can be baffling. Logical arguments can fail. If you don't do politics, you will fail. With Driving Technical Change, by Terrence Ryan, you'll learn to read users' "patterns of resistance"-and then dismantle their objections. Every developer must master the art of evangelizing. With these techniques and strategies, you'll help your organization adopt your solutions-without selling your soul to organizational politics.
Finding cool languages, tools, or development techniques is easy-new ones are popping up every day. Convincing co-workers to adopt them is the hard part. The problem is political, and in political fights, logic doesn't win for logic's sake. Hard evidence of a superior solution is not enough. But that reality can be tough for programmers to overcome.
In Driving Technical Change: Why People On Your Team Don't Act on Good Ideas, and How to Convince Them They Should, Adobe software evangelist Terrence Ryan breaks down the patterns and types of resistance technologists face in many organizations.
You'll get a rich understanding of what blocks users from accepting your solutions. From that, you'll get techniques for dismantling their objections-without becoming some kind of technocratic Machiavelli.
In Part I, Ryan clearly defines the problem. Then in Part II, he presents "resistance patterns"-there's a pattern for each type of person resisting your technology, from The Uninformed to The Herd, The Cynic, The Burned, The Time Crunched, The Boss, and The Irrational. In Part III, Ryan shares his battle-tested techniques for overcoming users' objections. These build on expertise, communication, compromise, trust, publicity, and similar factors. In Part IV, Ryan reveals strategies that put it all together-the patterns of resistance and the techniques for winning buy-in. This is the art of organizational politics.
In the end, change is a two-way street: In order to get your co-workers to stretch their technical skills, you'll have to stretch your soft skills. This book will help you make that stretch without compromising your resistance to playing politics. You can overcome resistance-however illogical-in a logical way.
This book is aimed at three groups of readers:
- Web application developers attempting to enhance the usability of their web sites and web applications
In addition, familiarity with the following related technologies is a strong indicator that this book is for you:
This book covers:
- The Browser Object Model—Introduces the Browser Object Model (BOM), which is responsible for objects allowing interaction with the browser itself. Each of the BOM objects is covered, including window, document, location, navigator, and screen.
- Client Detection—Explains various approaches to detecting the client machine and its capabilities. Different techniques include capability detection and user-agent string detection. Each approach is discussed for pros and cons as well as situational appropriateness.
- DOM Levels 2 and 3 Explains how DOM Levels 2 and 3 augmented the DOM with additional properties, methods, and objects. Compatibility issues between Internet Explorer and other browsers are discussed.
- Ajax and JSON—Looks at common Ajax techniques, including the use of the XMLHttpRequest object and Internet Explorer's XDomainRequest object for cross-domain Ajax. Explains the differences in browser implementations and support as well as recommendations for usage.
- Client-Side Storage—Discusses the various techniques for storing data on the client machine. Begins with a discussion of the most commonly supported feature, cookies, and then discusses newer functionality such as DOM storage.
If you're up on the latest Java technologies, then you know that Enterprise JavaBeans (EJB) 3.0 is the hottest news in Java this year. In fact, EJB 3.0 is being hailed as the new standard of server-side business logic programming. And O'Reilly's award-winning book on EJB has been refreshed just in time to capitalize on the technology's latest rise in popularity.
This fifth edition, written by Bill Burke and Richard Monson-Haefel, has been updated to capture the very latest need-to-know Java technologies in the same award-winning fashion that drove the success of the previous four strong-selling editions. Bill Burke, Chief Architect at JBoss, Inc., represents the company on the EJB 3.0 and Java EE 5 specification committees. Richard Monson-Haefel is one of the world's leading experts on Enterprise Java.
Enterprise JavaBeans 3.0, 5th Edition is organized into two parts: the technical manuscript followed by the JBoss workbook. The technical manuscript explains what EJB is, how it works, and when to use it. The JBoss workbook provides step-by-step instructions for installing, configuring, and running the examples from the manuscript on the JBoss 4.0 Application Server.
Although EJB makes application development much simpler, it's still a complex and ambitious technology that requires a great deal of time to study and master. But now, thanks to Enterprise JavaBeans 3.0, 5th Edition, you can overcome the complexities of EJBs and learn from hundreds of practical examples that are large enough to test key concepts but small enough to be taken apart and explained in the detail that you need. Now you can harness the complexity of EJB with just a single resource by your side.
Like most complex tasks, .NET programming is fraught with potential costly, and time-consuming hazards. The millions of Microsoft developers worldwide who create applications for the .NET platform can attest to that. Thankfully there's now a book that shows you how to avoid such costly and time-consuming mistakes. It's called .NET Gotchas.
The ultimate guide for efficient, pain-free coding, .NET Gotchas from O'Reilly contains 75 common .NET programming pitfalls--and advice on how to work around them. It will help you steer away from those mistakes that cause application performance problems, or so taint code that it just doesn't work right.
The book is organized into nine chapters, each focusing on those features and constructs of the .NET platform that consistently baffle developers. Within each chapter are several "gotchas," with detailed examples, discussions, and guidelines for avoiding them. No doubt about it, when applied, these concise presentations of best practices will help you lead a more productive, stress-free existence.
What's more, because code examples are written in both VB.NET and C#, .NET Gotchas is of interest to more than 75 percent of the growing numbers of .NET programmers. So if you're a .NET developer who's mired in the trenches and yearning for a better way, this book is most definitely for you.
On the surface of things, that is an intuitively obvious statement, given the title of this book. However, despite the apparent redundancy in saying it aloud, the sentence above elegantly describes what this book is about: The authors are not attempting to teach developers how to accomplish tasks from other languages in this one, nor are they attempting to evangelize the language or its feature set or its use "over" other languages. They assume that you are considering this book because you have an interest in learning the F# language: its syntax, its semantics, its pros and cons, and its use in concert with other parts of the .NET ecosystem.
The intended reader is a .NET developer, familiar with at least one of the programming languages in the .NET ecosystem. That language might be C# or Visual Basic, or perhaps C++/CLI, IronPython or IronRuby.
- Write the test before you write the code
- Manage the lifecycle of your objects fastidiously
- Build only what you need now, not what you might need later
- Apply ancient philosophies to software development
- Question authority, rather than blindly adhere to standards
- Make hard things easier and impossible things possible through meta-programming
- Be sure all code within a method is at the same level of abstraction
- Pick the right editor and assemble the best tools for the job
This isn't theory, but the fruits of Ford's real-world experience as an Application Architect at the global IT consultancy ThoughtWorks. Whether you're a beginner or a pro with years of experience, you'll improve your work and your career with the simple and straightforward principles in The Productive Programmer.
Solutions covered include
• Building custom GWT widgets, including both high-level composites and low-level components
• Implementing a viewport class that includes iPhone-style automated scrolling
• Integrating web services with GWT applications
• Combining Hibernate and GWT to implement database-backed web applications
• Extending the GWT PopupPanel class to implement a draggable and resizable window
• Creating a drag-and-drop module, complete with drag sources and drop targets
• Deploying GWT applications to an external server
• Dynamically resizing flex tables
• Using GWT widgets in legacy applications developed with other frameworks, such as Struts and JavaServer Faces
Complete Sample Code Available at www.coolandusefulgwt.com
All of the code used in this book has been tested, both in hosted and web modes, and in an external version of Tomcat (version 5.5.17), under Windows, Linux, and Mac OS X. For Windows and Linux, we used 1.4.60, and for the Mac we used 1.4.61. NOTE: There are three separate versions of the code. Please download the correct JAR file for the operating system you are using.
About the Authors xix
Solution 1: GWT Fundamentals and Beyond 1
Solution 3: Custom Widget Implementation 71
Solution 4: Viewports and Maps 103
Solution 5: Access to Online Web Services 133
Solution 6: Drag and Drop 167
Solution 7: Simple Windows 199
Solution 8: Flex Tables 237
Solution 9: File Uploads 283
Solution 10: Hibernate Integration 303
Solution 11: Deployment to an External Server 325
Solution 12: GWT and Legacy Code 343Index 371
In many ways, Graphic Java 2 is a cookbook. You search the table of contents or index for a reference to the kind of problem you want to solve, then examine the author's examples for the solution (or at least some clues to it). This is the book to turn to if you're wondering how to implement the JComboBox.KeySelectionManager interface (which enables users to select items in a combo box) or compare the various ways of making the JTree component into a file browser. Those are just two of hundreds of examples in David Geary's book.
While most examples don't serve any practical purpose by themselves, they do clearly illustrate how a specific aspect of Swing works. It's easy to adapt the details presented here into your own programs. Geary shows consideration for the reader by presenting all his examples as programs that can be compiled and including them on the enclosed CD-ROM. --David Wall
Lucene powers search in surprising placesWhat's Inside
- How to integrate Lucene into your applications
- Ready-to-use framework for rich document handling
- Case studies including Nutch, TheServerSide, jGuru, etc.
- Lucene ports to Perl, Python, C#/.Net, and C++
- Sorting, filtering, term vectors, multiple, and remote index searching
- The new SpanQuery family, extending query parser, hit collecting
- Performance testing and tuning
- Lucene add-ons (hit highlighting, synonym lookup, and others)
Enterprise and web applications require full-featured, "Google-quality" search capabilities, but such features are notoriously difficult to implement and maintain. Hibernate Search builds on the Lucene feature set and offers an easyto- implement interface that integrates seamlessly with Hibernate-the leading data persistence solution for Java applications.
Hibernate Search in Action introduces both the principles of enterprise search and the implementation details a Java developer will need to use Hibernate Search effectively. This book blends the insights of the Hibernate Search lead developer with the practical techniques required to index and manipulate data, assemble and execute search queries, and create smart filters for better search results. Along the way, the reader masters performance-boosting concepts like using Hibernate Search in a clustered environment and integrating with the features already in your applications.
This book assumes you're a competent Java developer with some experience using Hibernate and Lucene.
Purchase of the print book comes with an offer of a free PDF, ePub, and Kindle eBook from Manning. Also available is all code from the book.
This is the first comprehensive guide to cover JSP 2 and 2.1. It supplies you with the tools and techniques to develop web applications with JSP and Java servlets. You’ll learn to choose and implement the best persistence option for your web applications, and how to secure web sites against malicious attack and accidental misuse. You will improve the performance and scalability of JSP pages, as well as architect reliable, stable applications.
The authors describe all of the rich JSP 2 features, and explain JSF integration with JSP. Completing the thorough package, this book examines how integration with open source projects like Ant, Struts, XDoclet, JUnit, and Cactus can make web development even easier.
Step-by-step guide reveals best practices for enhancing Web sites with Ajax
- A step-by-step guide to enhancing Web sites with Ajax.
- Uses progressive enhancement techniques to ensure graceful degradation (which makes sites usable in all browsers).
- Shows readers how to write their own Ajax scripts instead of relying on third-party libraries.
Web site designers love the idea of Ajax--of creating Web pages in which information can be updated without refreshing the entire page. But for those who aren't hard-core programmers, enhancing pages using Ajax can be a challenge. Even more of a challenge is making sure those pages work for all users. In Bulletproof Ajax, author Jeremy Keith demonstrates how developers comfortable with CSS and (X)HTML can build Ajax functionality without frameworks, using the ideas of graceful degradation and progressive enhancement to ensure that the pages work for all users. Throughout this step-by-step guide, his emphasis is on best practices with an approach to building Ajax pages called Hijax, which improves flexibility and avoids worst-case scenarios.
Besides a useful guide to APIs, the book looks at a variety of techniques for saving session state, as well as showing how Servlets can work together to power Web sites. You will learn performance tips and ways to get Servlets to work together (like forwarding and redirection), plus the basics of database programming with JDBC, to build content with "live" data. A later chapter examines what's next for Servlets with the emerging Servlet 2.3 API standard. Importantly, the authors go over deploying and configuring Web applications by editing XML files, a must-have for successfully running Servlets in real applications.
Since the first edition of this title, the choices for Java Web developers have grown much richer. Many of the new chapters in this edition look at options beyond Servlets. Short sections on application frameworks such as Tea, WebMacro, the Element Construction Set (ECS), XMLC, and JavaServer Pages (JSP) let you explore what's out there for Java developers today with a survey of some current tools that can speed up creating new Web applications.
The text closes with reference sections on Servlet APIs (and other material) that will be useful for any working developer. Although Servlets are not the only game in town, they are still important tools for successful Web development. This updated edition shows you just how to do it with plenty of basic and advanced tips for taking full advantage of this powerful Java standard. --Richard Dragan
- Overview and history of Java Servlets
- Fundamentals of HTTP
- Web applications (including deployment and configuration using XML files)
- The Servlet lifecycle (initializing, processing requests, cleanup, and caching)
- Multimedia content (images and compressed content)
- WAP and WML for wireless content
- Servlet session tracking techniques (hidden form fields, cookies, and URL rewriting)
- Security issues with Servlets (including certificates and SSL)
- Tutorial for JDBC and Java database programming
- Using applets and Servlets together
- Servlet collaboration
- Quick introduction to Java 2 Enterprise Edition (J2EE)
- Internationalization issues
- Survey of third-party Servlet application frameworks and tools: Tea, WebMacro, the Element Contruction Set (ECS), XMLC, and JavaServer Pages (JSP)
- Miscellaneous tips for Servlets (including sending e-mail and using regular expressions)
- Description of the new Servlet 2.3 API spec
- Servlet API quick reference
After introducing the basics of the AWT library, the author looks at simple painting and 2-D graphics. Standout sections here look at displaying images--a staple of Internet programming--as well as transforming images with "filters" (such as dimming and rescaling an image). Graphic Java 1.2 shows you a variety of advanced techniques for getting control of your bit-mapped content. The tour of Java graphics capabilities moves on with coverage of layout managers and basic AWT components such as buttons, text fields, lists, and choices. For those who want to create stand-alone Java applications, there's much material on using Java menus.
The book's advanced material highlights new features of JDK 1.2, such as its support for lightweight controls, built-in double-buffering support, and advanced "native-style" operations (such as clipboard support and "rubber-banding" classes). The author also shows off his custom classes for 2-D sprite animation. --Richard Dragan
If the projects you manage don't go as smoothly as you'd like, 97 Things Every Project Manager Should Know offers knowledge that's priceless, gained through years of trial and error. This illuminating book contains 97 short and extremely practical tips -- whether you're dealing with software or non-IT projects -- from some of the world's most experienced project managers and software developers. You'll learn how these professionals have dealt with everything from managing teams to handling project stakeholders to runaway meetings and more.
While this book highlights software projects, its wise axioms contain project management principles applicable to projects of all types in any industry. You can read the book end to end or browse to find topics that are of particular relevance to you. 97 Things Every Project Manager Should Know is both a useful reference and a source of inspiration.
Among the 97 practical tips:
- "Clever Code Is Hard to Maintain...and Maintenance Is Everything" -- David Wood, Partner, Zepheira
- "Every Project Manager Is a Contract Administrator" -- Fabio Teixeira de Melo, Planning Manager, Construtora Norberto Odebrecht
- "Can Earned Value and Velocity Coexist on Reports?" -- Barbee Davis, President, Davis Consulting
- "How Do You Define 'Finished'"? -- Brian Sam-Bodden, author, software architect
- "The Best People to Create the Estimates Are the Ones Who Do the Work" -- Joe Zenevitch, Senior Project Manager, ThoughtWorks
- "How to Spot a Good IT Developer" -- James Graham, independent management consultant
- "One Deliverable, One Person" -- Alan Greenblatt, CEO, Sciova
The Definitive Guide to Terracotta: Cluster the JVM for Spring, Hibernate and POJO Scalability (Expert's Voice in Open Source)
Get the definitive guide on all the fundamentals of Terracotta as well as user secrets, recipes, and prepackaged frameworks.
Written by Terracotta's chief technology officer Ari Zilka and his team, The Definitive Guide to Terracotta: Cluster the JVM for Spring, Hibernate and POJO Scalability covers the following:
- High Availability (HA) nth degree scaling and clustering for traditional J2EE and Java EE 5 applications (using Seam or other application) as well as Spring–based enterprise applications
- Everyday Terracotta using its prepackaged frameworks and integration recipes, including configuration and customization for your application tuning, no matter the scale
- Power user secrets available, including config modules, customized advanced performance tuning, SDLC, Maven, and more
What you’ll learn
- See how Terracotta works fundamentally, and the user pieces and parts necessary for using Terracotta and its open source options
- Learn and apply case studies involving distributed cache, Hibernate, Master/Worker, and HTTP Session
- Understand thread coordination and advanced performance tuning
- Use more advanced case studies involving Spring, POJOs, FOO, and more
- Configure and create your own modules using the software development and deployment life cycle
Who this book is for
This definitive book from the Terracotta team is for both developers and architects who want to learn the “whats, wheres, whens, and whys” of the Terracotta scaling engine.
Table of Contents
- Theory and Foundation: Forming a Common Understanding
- History of Terracotta
- Jumping Into Terracotta
- POJO Clustering
- Hibernate with Terracotta
- Extending HTTP Sessions with Terracotta
- Clustering Spring
- Integration Modules
- Thread Coordination
- Grid Computing Using Terracotta
- Visualizing Applications
Beginning POJOs: Lightweight Java Web Development Using Plain Old Java Objects in Spring, Hibernate, and Tapestry
Beginning POJOs introduces you to open source lightweight web development using Plain Old Java Objects (POJOs) and the tools and frameworks that enable this. Tier by tier, this book guides you through the construction of complex but lightweight enterprise Java-based web applications. Such applications are centered around several major open source lightweight frameworks, including Spring, Hibernate, Tapestry, and JBoss (including the new lightweight JBoss Seam).
Additional support comes from the most successful and prevalent open-source tools: Eclipse and Ant, and the increasingly popular TestNG. This book is ideal if you’re new to open source and lightweight Java. You’ll learn how to build a complete enterprise Java-based web application from scratch, and how to integrate the different open source frameworks to achieve this goal. You’ll also learn techniques for rapidly developing such applications.
NOTE: The source code files to accompany this book are now hosted at https://github.com/bsbodden/techconf.
Microsoft's Shared Source CLI (code-named "Rotor") is the publicly available implementation of the ECMA Common Language Infrastructure (CLI) and the ECMA C# language specification. Loaded with three million lines of source code, it presents a wealth of programming language technology that targets developers interested in the internal workings of the Microsoft .NET Framework, academics working with advanced compiler technology, and people developing their own CLI implementations. The CLI, at its heart, is an approach to building software that enables code from many independent sources to co-exist and interoperate safely.
Shared Source CLI Essentials is a companion guide to Rotor's code. This concise and insightful volume provides a road map for anyone wishing to navigate, understand, or alter the Shared Source CLI code. This book illustrates the design principles used in the CLI standard and discusses the complexities involved when building virtual machines. Included with the book is a CD-ROM that contains all the source code and files.
After introducing the CLI, its core concepts, and the Shared Source CLI implementation, Shared Source CLI Essentials covers these topics:
- The CLI type system
- Component packaging and assemblies
- Type loading and JIT Compilation
- Managed code and the execution engine
- Garbage collection and memory management
- The Platform Adaptation Layer (PAL): a portability layer for Win32®, Mac OS® X, and FreeBSD
You've already lost your job. You may still be drawing a paycheck, but the job you were hired to do no longer exists. Your company has changed, the technology has changed, the economy has changed, and the ways you can add value have changed. Have you adapted to these changes? Or are you at risk?
Architect your careerEconomic downturn. Job cuts. Outsourcing. The ever-changing tech landscape. The threats abound. Chad Fowler is here to offer 52 ways to keep your job, despite the vagaries of the market.
- It's all about making the right choices. Choosing which technologies to focus on and which business domains to master have at least as much impact on your success as your technical knowledge--don't let those choices be accidental. Chad shows you all aspects of the decision-making process so you can ensure that you're investing your time and energy in the right areas.
- It's all about skills. You'll develop a structured plan for keeping your skills up-to-date so that you can compete with both the growing stable of developers in so-called low-cost countries as well as your higher-priced local peers. You'll learn how to shift your skillset up the value chain, from an offshore-ready commodity to one in high demand.
- It's all about marketing. As with any product or service, if nobody knows what you're selling, nobody will buy. Chad shows you how to create a plan for marketing yourself both inside your company and to the industry in general.
About the author Chad Fowler has been a software developer and manager for some of the world's largest corporations. He recently lived and worked in India, setting up and leading an offshore software development center for a large multinational company.
Spring—the open source Java–based framework—allows you to build lighter, better performing applications. Written by Spring insiders Rob Harrop and Jan Machacek, Pro Spring is the only book endorsed by Rod Johnson, founder of the Spring Framework. At over 800 pages, this is by far the most comprehensive book available and thoroughly explores the power of Spring. You’ll learn Spring basics and core topics, as well as share the authors’ insights and real–world experience with remoting, mail integration, hibernate, and EJB.
From the foreword: “Rob's enthusiasm for Spring—and technology in general—is infectious. He has a wide range of industry experience and a refreshingly practical, common sense approach to applying it. All those qualities come out in this book. It’s evident on nearly every page that it reflects in–depth experience with Spring and J2EE as a whole. Rob is not only an author and open source developer—he is an application developer, like his readers. I firmly believe that the best writing on software development comes out of experience in the trenches, so this is my kind of book.
If you’re new to Spring, this book will help you understand its core concepts and the background in areas such as transaction management and O/R mapping that underpins them. If you’re already using Spring, you will learn about features you haven’t yet seen and hopefully, gain a deeper understanding of those features youre already using.”
—Rod Johnson, Founder of the Spring Framework
* First book that demonstrates how to apply both existing and new design patterns to the job of testing Java software
* Explains how applying proven patterns to the testing of software can help ensure that applications function correctly and more efficiently, and are easier to maintain
* Patterns will be extensively reviewed online to ensure community support and endorsement
* Covers detailed patterns for unit, functional, database, and application deployment testing
* Provides complete Java code that applies each pattern to a real-world sample application
* Companion Web site provides code for Java pattern implementations, plus code for the sample applications and test suites
Grails is a full stack web development framework that enables you to build complete web applications in a fraction of the time and with less code than other frameworks.
In Grails: A Quick-Start Guide, you'll see how to use Grails by iteratively building an unique, working application. By the time we're done, you'll have built and deployed a real, functioning website.
Along the way, we'll learn about domain classes, controllers, and GSP views. We'll see how Grails allows us to use powerful frameworks like Spring and Hibernate without even knowing it.
Using this hands-on, pragmatic approach, we'll explore topics such as AJAX in Grails, custom tags, and plugins. We'll dig into Grails' powerful view technology, Groovy Server Pages, and see how we can easily leverage the help given to us by scaffolding to create custom user interfaces faster than you would have thought possible.
With Grails, you can get a lot done with little effort. With this book, you'll get a lot done as well. It's time to bring the fun back into web programming. Get started with Grails today.
The most complete reference available for the Spring 3.x framework, Spring in a Nutshell provides all of the details you need to configure and build lightweight enterprise applications on the Java platform -- ideal whether you're new to Spring or familiar with previous versions of this popular open source framework.
You'll quickly get up to speed on the fundamentals of Spring and how it enables you to write clean and simple applications with code that's portable, reusable, testable, and maintainable. You'll also discover how flexible this framework really is. This book provides techniques that will help you use Spring in a single class within your application, in a single application layer, or throughout your entire application, from the top to the bottom.
- Get everything you need to know to build enterprise Java applications, as well as web-based applications for browsers and RESTful web services
- Discover how Spring handles transactions, remoting, messaging, aspect-oriented programming, testing, and more
- Build web applications with Spring MVC that access data with JDBC, JPA, Hibernate, etc.
- Learn about the Spring Expression Language and the framework's dynamic language support
- Consult quick reference guides to XML schemas and annotations used throughout the Spring Framework
The Definitive Guide to Apache MyFaces and Facelets is an ideal reference if you're looking to develop real–world applications with the open-source lightweight Apache MyFaces and Dojo (the Ajax API). The book focuses less on theory and more on aspects like scalability, design, optimization, and configuration.
This book emphasizes meeting real–world requirements for performance and scalability. It includes lucid code samples that reflect the pattern being described. The “In the Trenches” sections in each chapter give you advice and recommendations based on actual experiences with each pattern. What’s more, the “Extreme Extensions” section at the end of each relevant chapter is dedicated to a “freestyle” expression of taking a particular pattern or set of patterns to the max. (This is a great way for you to learn because of the magnification effect.) This is also the first book to embrace the Dojo framework for Ajax.
Table of Contents
- An Introduction to JavaServer Faces
- The Tomahawk Project
- The Trinidad Project
- Conversations and Scoping with Orchestra
- Layouts and Themes with Tobago
- Anti-patterns and Pitfalls
There is a hidden revolution going on: geography is moving from niche to the mainstream. News reports routinely include maps and satellite images. More and more pieces of equipment cell phones, cars, computers now contain Global Positioning System (GPS) receivers. Many of the major database vendors have made geographic data types standard in their flagship products.
GIS for Web Developers introduces Geographic Information Systems (GIS) in simple terms and demonstrates hands-on uses. With this book, you'll explore popular websites like maps.google.com, see the technologies they use, and learn how to create your own. Written with the usual Pragmatic Bookshelf humor and real-world experience, GIS for Web Developers makes geographic programming concepts accessible to the common developer.
This book will demystify GIS and show you how to make GIS work for you. You'll learn the buzzwords and explore ways to geographically-enable your own applications. GIS is not a fundamentally difficult domain, but there is a barrier to entry because of the industry jargon. This book will show you how to "walk the walk" and "talk the talk" of a geographer.
You'll learn how to find the vast amounts of free geographic data that's out there and how to bring it all together. Although this data is free, it's scattered across the web on a variety of different sites, in a variety of incompatible formats. You'll see how to convert it among several popular formats including plain text, ESRI Shapefiles, and Geography Markup Language (GML).
With this book in hand, you'll become a real geographic programmer using the Java programming language. You'll find plenty of working code examples in Java using some of the many GIS-oriented applications and APIs. You'll be able to:
Much of the early hype surrounding Ajax centered on its use by Internet powerhouses such as Google and Amazon. However, just because the initial forays into Ajax were pioneered by leading software development firms doesn't mean your application wouldn’t also benefit from these techniques. You already know how to develop Web applications, so this book uses specific, focused examples to teach the Ajax tools and techniques you’ll need to bring your applications to life. Armed with this book and your existing development expertise, you too will be able to apply Ajax techniques to your application to enrich the end users experience.
When we first saw the potential of Ajax, we knew we had to start leveraging it for our own applications. Along the way weve learned some hard-earned knowledge that we thought needed to be shared with the rest of the development community. With this book, you’ll be able to easily extend your own applications with Ajax and have fun while doing it. We hope that someday well be reading about your great Ajax-enabled application!
What you’ll learn
- Where CSS, HTML, and the DOM fit into modern scripting, and how to use them together effectively
- How to build effective form validation into your applications using Ajax
- How to create mashups using APIs
- How to build dynamic user interfaces
Who this book is for
Table of Contents
- Object-Oriented Programming
- Ajax and Data Exchange
- Visual Effects
- Case Study: FAQ Facelift
- A Dynamic Help System
Rails is large, powerful, and new. How do you use it effectively? How do you harness the power? And, most important, how do you get high quality, real-world applications written?
From the latest Ajax effects to time-saving automation tips for your development process, Rails Recipes will show you how the experts have already solved the problems you have.
- Use generators to automate repetitive coding tasks.
- Create sophisticated role-based authentication schemes.
- Add live search and live preview to your site.
- Run tests when anyone checks code in.
- How to create tagged data the right way.
- and many, many more...
Owning Rails Recipes is like having the best Rails programmers sitting next to you while you code.
ThoughtWorks is a well-known global consulting firm; ThoughtWorkers are leaders in areas of design, architecture, SOA, testing, and agile methodologies. This collection of essays brings together contributions from well-known ThoughtWorkers such as Martin Fowler, along with other authors you may not know yet. While ThoughtWorks is perhaps best known for their work in the Agile community, this anthology confronts issues throughout the software development life cycle. From technology issues that transcend methodology, to issues of realizing business value from applications, you'll find it here.
The fastest route to true HTML/CSS mastery!
Need to build a web site? Or update one? Or just create some effective new web content? Maybe you just need to update your skills, do the job better.
Welcome. This book's for you. We'll leverage what you already know about the web, so you'll go further, faster than you ever expected. You'll master today's best practices: the real nuts and bolts, not theory or hooey. You'll learn through dozens of focused HTML, XHTML, and CSS examples: crafted for simplicity and easy to adapt for your own projects.
Need specific solutions? This book's modular, visual, high-efficiency format delivers them instantly. Molly E. Holzschlag draws on her unparalleled experience teaching Web design and development. No other HTML/CSS guide covers this much, this well, this quickly. Dig in, get started, get results!
All you need to succeed with HTML, XHTML, and CSS in real-world projects
Learn how to build web pages that'll work in any environment, on virtually any contemporary browser
Construct templates that simplify every page you develop
Structure and tag text so it's easy to work with and manage
Add images, media, and scripts–quickly and reliably
Discover the right ways to use HTML tables
Build easy-to-use forms and validate your users' input
Use CSS to take total control over your site's look and feel
Master core CSS techniques: color, images, text styles, link effects, lists, navigation, and more
Control margins, borders, padding, positioning, floats, even Z-index
Design efficient, compatible, easy-to-manage CSS layouts
Includes concise XHTML and CSS annotated references: quick help for every language element
Spring Into... is a new series of fast-paced tutorials from Addison-Wesley. Each book in the series is designed to bring you up to speed quickly. Complex topics and technologies are reduced to their core components, and each component is treated with remarkable efficiency in one- or two-page spreads. Just the information you need to begin working...now! And because the books are example-rich and easy to navigate, you'll find that they make great on-the-job references after you've mastered the basics.
© Copyright Pearson Education. All rights reserved.
JBoss RichFaces is a rich JavaServer Faces (JSF) component library that helps developers quickly develop next–generation web applications. Practical RichFaces describes how to best take advantage of RichFaces, the integration of the Ajax4jsf and RichFaces libraries, to create a flexible and powerful programs. Assuming some JSF background, it shows you how you can radically reduce programming time and effort to create rich Ajax-based applications.
What you’ll learn
- Quickly learn how to build rich Internet applications with out–of–the–box RichFaces components.
- Discover best strategies for implementing Ajax applications using RichFaces.
- Find out when best to use the two libraries.
- Create new skins for your app in no time.
Who this book is for
Java developers with knowledge of JSF looking to build next–generation web applications using RichFaces, JSF users, Java programmers wishing to add Ajax to their existing programs, and old users of Ajax4jsf.
Table of Contents
- Quick Start with JBoss RichFaces
- RichFaces Basic Concepts
- More a4j: Tags, Concepts, and Features
- Input Components
- Output Components
- Data Iteration Components
- Selection Components
- Menu Components
- Scrollable Data Table and Tree