"With this book, Ted Neward helps you make the leap from being a good Java enterprise developer to a great developer!"
—John Crupi, Sun Distinguished Engineer coauthor, Core J2EE Patterns
If you want to build better Java enterprise applications and work more efficiently, look no further. Inside, you will find an accessible guide to the nuances of Java 2 Platform, Enterprise Edition (J2EE) development. Learn how to:
- Use in-process or local storage to avoid the network, see item 44
- Set lower isolation levels for better transactional throughput, see item 35
- Use Web services for open integration, see item 22
- Consider your lookup carefully, see item 16
- Pre-generate content to minimize processing, see item 55
- Utilize role-based authorization, see item 63
- Be robust in the face of failure, see item 7
- Employ independent JREs for side-by-side versioning, see item 69
Ted Neward provides you with 75 easily digestible tips that will help you master J2EE development on a systemic and architectural level. His panoramic look at the good, the bad, and the ugly aspects of J2EE development will address your most pressing concerns. Learn how to design your enterprise systems so they adapt to future demands. Improve the efficiency of your code without compromising its correctness. Discover how to implement sophisticated functionality that is not directly supported by the language or platform. After reading Effective Enterprise Java , you will know how to design and implement better, more scalable enterprise-scope Java software systems.
You will be guided through all the Spring features and see how they form a coherent whole. In turn, this will help you understand the rationale for Spring's approach, when to use Spring, and how to follow best practices. All this is illustrated with a complete sample application. When you finish the book, you will be well equipped to use Spring effectively in everything from simple Web applications to complex enterprise applications.
What you will learn from this book
* The core Inversion of Control container and the concept of Dependency Injection
* Spring's Aspect Oriented Programming (AOP) framework and why AOP is important in J2EE development
* How to use Spring's programmatic and declarative transaction management services effectively
* Ways to access data using Spring's JDBC functionality, iBATIS SQL Maps, Hibernate, and other O/R mapping frameworks
* Spring services for accessing and implementing EJBs
* Spring's remoting framework
Who this book is for
This book is for Java/J2EE architects and developers who want to gain a deeper knowledge of the Spring Framework and use it effectively.
Wrox Professional guides are planned and written by working programmers to meet the real-world needs of programmers, developers, and IT professionals. Focused and relevant, they address the issues technology professionals face every day. They provide examples, practical solutions, and expert education in new technologies, all designed to help programmers do a better job.
Consisting of a number of well-known open source products, JBoss is more a family of interrelated services than a single monolithic application. But, as with any tool that's as feature-rich as JBoss, there are number of pitfalls and complexities, too.
Most developers struggle with the same issues when deploying J2EE applications on JBoss: they have trouble getting the many J2EE and JBoss deployment descriptors to work together; they have difficulty finding out how to get started; their projects don't have a packaging and deployment strategy that grows with the application; or, they find the Class Loaders confusing and don't know how to use them, which can cause problems.
JBoss at Work: A Practical Guide helps developers overcome these challenges. As you work through the book, you'll build a project using extensive code examples. You'll delve into all the major facets of J2EE application deployment on JBoss, including JSPs, Servlets, EJBs, JMS, JNDI, web services, JavaMail, JDBC, and Hibernate. With the help of this book, you'll:
- Implement a full J2EE application and deploy it on JBoss
- Discover how to use the latest features of JBoss 4 and J2EE 1.4, including J2EE-compliant web services
- Master J2EE application deployment on JBoss with EARs, WARs, and EJB JARs
- Understand the core J2EE deployment descriptors and how they integrate with JBoss-specific descriptors
- Base your security strategy on JAAS
Written for Java developers who want to use JBoss on their projects, the book covers the gamut of deploying J2EE technologies on JBoss, providing a brief survey of each subject aimed at the working professional with limited time.
If you're one of the legions of developers who have decided to give JBoss a try, then JBoss at Work: A Practical Guide is your next logical purchase. It'll show you in plain language how to use the fastest growing open source tool in the industry today. If you've worked with JBoss before, this book will get you up to speed on JBoss 4, JBoss WS (web services), and Hibernate 3.
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.
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.
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
Manage Your Project Portfolio: Increase Your Capacity and Finish More Projects (Pragmatic Programmers)
All of your projects and programs make up your portfolio. But how much time you actually spend on your projects, and how much time do you spend responding to emergencies?
This book will introduce you to different ways of ordering all of the projects you are working on now, and help you figure out how to staff those projects--even when you've run out of project teams to do the work.
Once you learn to manage your portfolio better, you'll avoid emergency "firedrills." The trick is adopting lean and agile approaches to projects, whether they are software projects, projects that include hardware, or projects that depend on chunks of functionality from other suppliers.
You may be accustomed to spending time in meetings where you still don't have the data you need to evaluate your projects. Here, with a few measures, you'll be able to quickly evaluate each project and come to a decision quickly.
You'll learn how to define your team's, group's, or department's mission with none of the buzzwords that normally accompany a mission statement. Armed with the work and the mission, you can make those decisions that define the true leaders in the organization.
jQuery in Action, like jQuery itself, is a concise tool designed to make you a more efficient and effective web developer. In a short 300 pages, this book introduces you to the jQuery programming model and guides you through the major features and techniques you'll need to be productive immediately. The book anchors each new concept in the tasks you'll tackle in day-to-day web development and offers unique lab pages where you immediately put your jQuery knowledge to work.
Web frameworks are playing a major role in the creation of today's most compelling web applications, because they automate many of the tedious tasks, allowing developers to instead focus on providing users with creative and powerful features. Java developers have been particularly fortunate in this area, having been able to take advantage of Grails, an open source framework that supercharges productivity when building Java–driven web sites. Grails is based on Groovy, which is a very popular and growing dynamic scripting language for Java developers and was inspired by Python, Ruby, and Smalltalk.
Beginning Groovy and Grails is the first introductory book on the Groovy language and its primary web framework, Grails.
This book gets you started with Groovy and Grails and culminates in the example and possible application of some real–world projects. You follow along with the development of each project, implementing and running each application while learning new features along the way.
What you’ll learn
- Understand the fundamentals of the open source, dynamic Groovy scripting language and the Grails web framework.
- Capitalize upon Grails’ well–defined framework architecture to build web applications faster than ever before.
- Improve your web application with cutting–edge interface enhancements using Ajax.
- Use Grails’ object–relational mapping solution, GORM, to manage your data store more effectively than ever before.
- Take advantage of Groovy to create reporting services, implement batch processing, and create alternative client interfaces.
- Deploy and upgrade your Grails–driven applications with expertise and ease.
- Discover an alternative client in Groovy as well.
Who this book is for
Java and web developers looking to learn and embrace the power and flexibility offered by the Grails framework and Groovy scripting language.
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
Scala is an exciting, modern, multi-paradigm language for the JVM. You can use it to write traditional, imperative, object-oriented code. But you can also leverage its higher level of abstraction to take full advantage of modern, multicore systems. Programming Scala will show you how to use this powerful functional programming language to create highly scalable, highly concurrent applications on the Java Platform.
The increasing popularity and availability of multicore processors is creating a whole new set of challenges--although you can enjoy true concurrency, you're now faced with higher contention and synchronization issues. Deploying an existing application on a multicore processor may bring out previously hidden concurrency issues. Java's multi-threading facility by itself isn't enough---it's a very low level abstraction. Instead, you need a paradigm that provides a higher level of abstraction to deal with concurrency. It's time to embrace Functional Programming.
Scala is a hybrid Object-Oriented/Functional Programming language on the JVM. Using Scala, you can create traditional imperative programs, intermix them with Java code, and at the same time take advantage of higher levels of abstraction. You can use features that lead to concise, highly expressive code that remove the pain of dealing with concurrency.
Programming Scala will show you the fundamentals of functional programming using Scala. Very quickly, you'll learn how this statically typed language can give you dynamic capabilities to create concise, scalable, highly capable concurrent code.
Pragmatic programmers always use the right tool for the job. For concurrent programming on the Java VM, Scala is the tool, and Programming Scala by award-winning author Venkat Subramaniam is your guide.
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
Ship It! is a collection of tips that show the tools and techniques a successful project team has to use, and how to use them well. You'll get quick, easy-to-follow advice on modern practices: which to use, and when they should be applied. This book avoids current fashion trends and marketing hype; instead, readers find page after page of solid advice, all tried and tested in the real world.
Aimed at beginning to intermediate programmers, Ship It! will show you:
- Which tools help, and which don't
- How to keep a project moving
- Approaches to scheduling that work
- How to build developers as well as product
- What's normal on a project, and what's not
- How to manage managers, end-users and sponsors
- Danger signs and how to fix them
Few of the ideas presented here are controversial or extreme; most experienced programmers will agree that this stuff works. Yet 50 to 70 percent of all project teams in the U.S. aren't able to use even these simple, well-accepted practices effectively. This book will help you get started.
Ship It! begins by introducing the common technical infrastructure that every project needs to get the job done. Readers can choose from a variety of recommended technologies according to their skills and budgets. The next sections outline the necessary steps to get software out the door reliably, using well-accepted, easy-to-adopt, best-of-breed practices that really work.
Finally, and most importantly, Ship It! presents common problems that teams face, then offers real-world advice on how to solve them.
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
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.
EJB 3.0 sets a precedent. It has made huge advances in ease of development, and its drastically simplified programming model has been widely acclaimed.
Mike Keith, EJB 3.0 co-specification lead, and Merrick Schinariol, reviewer of EJB 3.0, offer unparalleled insight and expertise on the EJB 3.0 persistence specification, in this definitive guide to EJB 3.0 persistence technology. Expect full coverage and examination of the EJB 3.0 spec from these expert authors, including:
- The EntityManager API
- The new features of EJB Query Language (EJB QL)
- Basic and advanced object-relational mapping
- Advanced topics like concurrency, locking, inheritance, and polymorphism
Assuming a basic knowledge of Java, SQL, JDBC, and some J2EE experience, Keith and Schinariol will teach you EJB 3.0 persistence from the ground up. After reading it, you will have an in-depth understanding of the EJB 3.0 persistence API and how to use it in your applications.
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.
Hiring The Best Knowledge Workers, Techies & Nerds: The Secrets & Science Of Hiring Technical PeopleGood technical people are the foundation on which successful high technology organizations are built. Establishing a good process for hiring such workers is essential. Unfortunately, the generic methods so often used for hiring skill-based staff, who can apply standardized methods to almost any situation, are of little use to those charged with the task of hiring technical people.
Unlike skill-based workers, technical people typically do not have access to cookie-cutter solutions to their problems. They need to adapt to any situation that arises, using their knowledge in new and creative ways to solve the problem at hand. As a result, one developer, tester, or technical manager is not interchangeable with another. This makes hiring technical people one of the most critical and difficult processes a technical manager can undertake.
Hiring the Best Knowledge Workers, Techies & Nerds: The Secrets & Science of Hiring Technical People takes the guesswork out of hiring and diminishes the risk of costly hiring mistakes. With the aid of step-by-step descriptions and detailed examples, you’ll learn how to
* write a concise, targeted job description
* source candidates
* develop ads for mixed media
* review résumés quickly to determine Yes, No, or Maybe candidates
* develop intelligent, nondiscriminatory, interview techniques
* create fool-proof phone-screens
* check references with a view to reading between the lines
* extend an offer that will attract a win-win acceptance or tender a gentle-but-decisive rejection
* and more
You, your team, and your organization will live with the long-term consequences of your hiring decision. Investing time in developing a hiring strategy will shorten your decision time and the ramp-up time needed for each new hire.
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.
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.
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.
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.
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.
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.
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)
Finally, you’ll have the chance to play detective and find the guilty culprit in:
- The Case of the Devilish Details
- The Case of the Mistaken Identity
- The Case of the Single White Space
- The Case of the Float with a Mind of Its Own
- The Case of the Browser Who Hated Me
- The Case of the LOL Layout
When Object Oriented programming (OO) first appeared, it was a revelation. OO gave developers the ability to create software that was more flexible and robust, but as time went on and applications became more sophisticated, too, certain areas of "traditional" OO architectures were found wanting. Aspect-oriented programming (AOP) addresses those issues by extending the OO approach even further.
Many developers are interested in AOP--especially in AspectJ, the open source extension of the Java programming language that explicitly supports the AOP approach. Yet, although AspectJ is included with Eclipse, the increasingly popular open source IDE for Java, finding a practical and non-theoretical way to learn this language and other AOP tools and techniques has been a real problem.
Until now. The AspectJ Cookbook offers a hands-on solution--in fact, several--with a wide variety of code recipes for solving day-to-day design and coding problems using AOP's unique approach.
AOP allows the global properties of a program to determine how it's compiled into an executable program. Before AOP, important program design decisions were difficult to capture in actual code. Instead, the implementation of those design decisions--known as "aspects"--were scattered throughout, resulting in "tangled" code that was hard to develop and maintain. AOP has been compared to the manufacturing of cloth, in which threads are automatically interwoven. Without AOP, programmers must stitch the threads by hand.
The AspectJ Cookbook shows readers why, and how, common Java development problems can be solved by using AOP techniques. With our popular problem-solution-discussion format, the book presents real world examples to demonstrate that AOP is more than just a concept; it's a development process that will benefit users in an immediate and visible manner.
If you're interested in how AOP is changing the way software is developed, and how you can use AspectJ to make code more modular, easier to develop, maintain, evolve and deploy, this is the book that really delivers.
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.
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
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.
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.
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.
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
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.
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!
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
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
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
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
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
Attack complexity in your Java applications using Modular Java. This pragmatic guide introduces you to OSGi and Spring Dynamic Modules, two of the most compelling frameworks for Java modularization. Driven by real-world examples, this book will equip you with the know-how you need to develop Java applications that are composed of smaller, loosely coupled, highly cohesive modules.
The secret weapon for attacking complexity in any project is to break it down into smaller, cohesive, and more easily digestible pieces. With Modular Java, you can easily develop applications that are more flexible, testable, maintainable, and comprehensible.
Modular Java is a pragmatic guide to developing modular applications using OSGi, the framework for dynamic modularity in Java, and Spring Dynamic Modules, an OSGi extension to the Spring Framework. You'll start with the basics but quickly ramp up, creating loosely coupled modules that publish and consume services, and you'll see how to compose them into larger applications. Along the way, you'll apply what you learn as you build a complete web application that is made up of several OSGi modules, using Spring-DM to wire those modules together.
Modular Java is filled with tips and tricks that will make you a more proficient OSGi and Spring-DM developer. Equipped with the know-how gained from this book, you'll be able to develop applications that are more robust and agile.
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
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.