 | Level: Introductory Bill Higgins, Architect, Collaborative Development Environments, IBM Global Services
15 Dec 2004 from The Rational Edge: This favorable review examines a book focusing on the fundamentals of developing Java-based enterprise IT systems. Through discussions covering seventy-five topics, the book gives developers, architects, and designers a comprehensive overview of the interrelated issues involved in enterprise development.
Ted Neward
Addison-Wesley, 2004
ISBN: 0321130006
Cover price:US$44.99
496 pages
This book is the best compendium to date of proven techniques for developing high-quality enterprise IT systems that are based on the Java programming language and J2EE platform.
As part of the Addison-Wesley "Effective" series, the book follows a standard format. The first chapter explains the book's scope and areas of concern, and the remaining chapters cover seventy-five "items" for achieving higher system quality. In a four-to-six page discussion for each item, Neward typically defines problems or issues and suggests techniques to address them.
Recognizing that enterprise systems are complex and highly variable, Neward is always careful to describe the context in which these techniques will actually work.
He categorizes the items into seven broad areas:
- Architecture
- Communication
- Processing
- State Management
- Presentation
- Security
- System (Java runtime level concerns)
As he states in the Preface and first chapter, this is not a definitive reference for any of these areas, each of which merits its own book. Rather, Neward introduces readers to the fundamental concerns of each area and enumerates a set of concrete principles and techniques for optimizing system quality and avoiding common design mistakes.
In addition, for each area and item, he provides a solid set of references to authoritative sources; an annotated bibliography describes the topics, strengths, and weaknesses of each referenced work. This encouraged me to read two books he noted (on security and transaction processing), and I found that his descriptions were very accurate.
Focuses on fundamentals
Effective Enterprise Java is appropriate for architects, designers, and developers who have at least a year of experience designing enterprise Java systems. Recognizing that the term enterprise system may have different meanings for different readers, Neward defines what he means by the term, avoiding jargon and focusing on fundamental characteristics:
- Shares some or all of the resources used by the system (i.e., concurrency).
- Must work within existing architecture (i.e., must interact with legacy systems).
- Is intended for internal use (as opposed to mass-produced, packaged software intended for external consumers).
- Will be deployed and supported by internal IT staff.
- Requires greater robustness than smaller systems, in terms of both exception handling and scalability.
- Must "fail gracefully."
- Must gracefully handle evolution over time.
He maintains this focus on fundamentals in the item discussions as well. For example, whereas a typical discussion of the issues surrounding Java remote communication begins by serving up an alphabet soup of acronyms, such as HTTP, JAX-RPC, and JAXM, Neward begins his discussion of this topic by classifying communication mechanisms along three fundamental axes of interest: transport, format, and communication patterns. He then thoroughly explains the different patterns for each axis, providing examples from the Java world. When he does finally get to discussing Java communication acronyms, he explains each one in terms of the three fundamental axes. The result is the first comprehensive and comprehensible explanation of Java communication options I've seen.
Neward's discussion of the "ten fallacies of enterprise computing" should be required reading for every programmer who is moving from the friendly confines of simple, non-distributed development to the harsh reality of having to work with unreliable networks, across security domain boundaries, and with high-latency, cross-network method invocations. For example, he explains that many object-oriented software designers think it's a sign of elegant design if their code makes no distinction between accessing objects within the same JVM and accessing an object on a server in Norway. Such code may indeed look elegant to the designer, but as Neward explains in item 17, "Recognize the cost of network access," the resulting system will likely frustrate users with sluggish performance. In addition, using a code example, he demonstrates that a remote method call is more than a thousand times more expensive than a local method call.
Neward also uses real-world analogies effectively to show the simple logic underlying principles he espouses. In discussing the performance cost of accessing remote resources, for example, he asks readers to compare the effort required to get food out of a home refrigerator versus driving to the grocery store. And he likens the two-phase commit protocol for distributed transactions to an American wedding ceremony: "Do you take this man? Yes. Do you take this woman? Yes. Does anyone object? No. Ok, then you're married."
Although some items seemed obvious to me, based on personal experience -- "Remote calls are expensive" and "Always validate user input" -- others, such as "Recognize ClassLoader boundaries" were entirely new to me. Still others, such as "Remember that identity breeds contention" explicitly discussed a topic I had previously understood only intuitively. The point is that each item represents a mistake that happens frequently in the field; items that may seem obvious to you may greatly help another designer. Even if you are an experienced architect, designer, or developer for a Java-based enterprise system, the variety of topics the book covers and the cross-references between them should help you formalize your understanding of proven design heuristics for addressing enterprise computing issues.
About the author | 
| | Bill Higgins, an architect with IBM Global Services, works on IBM's own On Demand transformation. Currently, he is focused on improving collaborative development technologies and methods that teams use to build IBM's internal enterprise systems. His current technical interests include the IBM® Rational Team Unifying Platform,® IBM Lotus Workplace,® IBM WebSphere Portal Server,® mapping business processes to IT, and recording his activities and insights in his developerWorks blog. He holds a BS in computer science from Penn State University. |
Rate this page
| |
