J2EE AntiPatterns

Rating:
Summary: Excellent for J2EE Designers/Developers
Review: Did you ever have the feeling that there was something wrong with your application design but you just couldn't put your finger on the problem? The authors of this book have taken their own experience developing J2EE applications and produced a book that will help you avoid many mistakes in application design. The book is geared toward helping the experienced designer/developer produce robust, maintainable applications and fixing applications that are not robust and not easily maintained.

The book covers most of the J2EE spectrum. There are sections on JSPs, Servlets, Entity and Session Beans, JMS, and Web Services. There are also sections on general J2EE architecture including distribution, scaling, and persistence. Each chapter gives a background on a specific antipattern, discusses the typical symptoms of the antipattern, and then covers various refactorings that can be used to correct the antipattern. Some of the antipatterns discussed may sound familiar ("too much code in JSPs") but the list of refactorings will provide useful information for even these obvious coding errors if you happen to be supporting an application that suffers from that antipattern.

The authors have done a great job of clearly explaining each antipattern, both explaining why it is an antipattern and what you can do to fix the problem. Each refactoring is demonstrated with code samples as well as with UML diagrams where appropriate. Overall, this is an excellent book that should be on the shelf of anyone involved in designing J2EE applications.

Rating:
Summary: Excellent for J2EE Designers/Developers
Review: Did you ever have the feeling that there was something wrong with your application design but you just couldn't put your finger on the problem? The authors of this book have taken their own experience developing J2EE applications and produced a book that will help you avoid many mistakes in application design. The book is geared toward helping the experienced designer/developer produce robust, maintainable applications and fixing applications that are not robust and not easily maintained.

The book covers most of the J2EE spectrum. There are sections on JSPs, Servlets, Entity and Session Beans, JMS, and Web Services. There are also sections on general J2EE architecture including distribution, scaling, and persistence. Each chapter gives a background on a specific antipattern, discusses the typical symptoms of the antipattern, and then covers various refactorings that can be used to correct the antipattern. Some of the antipatterns discussed may sound familiar ("too much code in JSPs") but the list of refactorings will provide useful information for even these obvious coding errors if you happen to be supporting an application that suffers from that antipattern.

The authors have done a great job of clearly explaining each antipattern, both explaining why it is an antipattern and what you can do to fix the problem. Each refactoring is demonstrated with code samples as well as with UML diagrams where appropriate. Overall, this is an excellent book that should be on the shelf of anyone involved in designing J2EE applications.

Rating:
Summary: A Good Read for Project Mangers, too
Review: Often, managers of medium to large scale software projects do not have the time (or inclination) to learn the technical nuances of the development environment they're managing. This lack of understanding can quickly give birth to worry and stress. "If only I knew the right questions to ask..." is a common lament among project managers as they wonder "why is module X so brittle?" and "why can't we ever meet the performance spec for subsystem Y?"

"J2EE AntiPatterns" is a useful guide for helping project managers with technical (but not necessarily J2EE) backgrounds zero-in on the major pitfalls the development team must circumvent. The Background, General Form, Symptoms and Consequences, and Typical Causes sections of most AntiPatterns provide the manager with sufficient information to recognize, understand, and (hopefully) avoid technical problems. (The exceptions are the AntiPatterns for entity, session and message-driven beans - the book assumes a basic understanding of J2EE beans.) Project managers do not need to fully comprehend the code examples (the book has many) to employ the lessons described in "J2EE AntiPatterns" - simply recognizing and understanding the AntiPatterns will be valuable to the team.

If I had read this book before (or during) my last project, I would have been able to recognize some significant problems by simply observing and listening to the engineers discuss their challenges, including the following AntiPatterns:

"Too Much Code" - our LOC metrics would have fleshed this one out quickly;
"Using Strings for Content Generation" - we spent many hours debugging HTML that rendered properly in IE but not Mozilla;
"When In Doubt Make it a Web Service" - it can be expensive mistake to implement something purely for technology's sake.

Coupled with a book or two describing J2EE at a high level, "J2EE AntiPatterns" is essential reading for technical project managers. This book will undoubtedly increase the project manager's effectiveness and help him/her better communicate with the team. A little knowledge for project managers is NOT always dangerous!

Rating:
Summary: A Good Read for Project Mangers, too
Review: Often, managers of medium to large scale software projects do not have the time (or inclination) to learn the technical nuances of the development environment they're managing. This lack of understanding can quickly give birth to worry and stress. "If only I knew the right questions to ask..." is a common lament among project managers as they wonder "why is module X so brittle?" and "why can't we ever meet the performance spec for subsystem Y?"

"J2EE AntiPatterns" is a useful guide for helping project managers with technical (but not necessarily J2EE) backgrounds zero-in on the major pitfalls the development team must circumvent. The Background, General Form, Symptoms and Consequences, and Typical Causes sections of most AntiPatterns provide the manager with sufficient information to recognize, understand, and (hopefully) avoid technical problems. (The exceptions are the AntiPatterns for entity, session and message-driven beans - the book assumes a basic understanding of J2EE beans.) Project managers do not need to fully comprehend the code examples (the book has many) to employ the lessons described in "J2EE AntiPatterns" - simply recognizing and understanding the AntiPatterns will be valuable to the team.

If I had read this book before (or during) my last project, I would have been able to recognize some significant problems by simply observing and listening to the engineers discuss their challenges, including the following AntiPatterns:

"Too Much Code" - our LOC metrics would have fleshed this one out quickly;
"Using Strings for Content Generation" - we spent many hours debugging HTML that rendered properly in IE but not Mozilla;
"When In Doubt Make it a Web Service" - it can be expensive mistake to implement something purely for technology's sake.

Coupled with a book or two describing J2EE at a high level, "J2EE AntiPatterns" is essential reading for technical project managers. This book will undoubtedly increase the project manager's effectiveness and help him/her better communicate with the team. A little knowledge for project managers is NOT always dangerous!

Rating:
Summary: Excellent book to avoid other's mistakes
Review: This book does an excellent job of describing a wide variety of common mistakes that are made in the design and implementation of J2EE systems. For each problem pointed out by the AntiPattern, the book also describes how you can refactor your design to avoid this problem. I strongly recommend that all J2EE architects, designers, and coders read both an AntiPattern book and a "positive" pattern book. It is very valuable to read books such as Core J2EE Patterns or EJB Design Patterns to find out positive patterns for J2EE design. Books like J2EE AntiPatterns provide the flip side of the coin by pointing out what you shouldn't do in your J2EE design.

Rating:
Summary: Common Sense for j2ee Developers
Review: This book is a very worthy addition to the pattern literature for j2ee. It is at about the same level of sophistication as the two now-standard j2ee pattern books (Alur, Malks and Crupi 2nd edition, and Marinescu).

If I were new to j2ee (but had some experience with Java, Design
Patterns, Enterprise Architecture and Refactoring) I would read Ed Roman's book, then Marinescu, then Alur's (noting that some of the patterns are now deprecated) and then this book.

The book is divided into 10 sections, each of which covers one aspect of j2ee technology, such as JSPs or Entity Beans. Overall it is well written and enjoyable to read. Each section is divided into a set of anti-patterns (things not to do) and a set of refactorings (what to do after you do the things they told you not to do). Although this leads to some redundancy (repeating the problem in the refactoring section) it
sucessfully deals with the many to many issue (antipatterns to
refactorings); the alternative would be to repeat or reference the refactoring in each antipattern section that it is applicable to.

The book is well edited with few problems. One issue is that some of the diagrams seem to be missing - what is presented is duplicates of previous diagrams. I assume this will be fixed in a future printing.

Like other pattern books, one of the advantages of this book is in the names we can now associate with common patterns we have all seen. A perfect example is "Ad Lib TagLibs", which are large taglibs which include business logic and control logic. The suggested refactoring include beanifying (the model data) and separating out a delegate controller.

Rating:
Summary: Reference book of highest quality(for J2EE implementations)
Review: What can I say:"WOW".
This book is well structured into different aspects of J2EE(example: servlets, JSPs, webservices, EJBs etc). Each of the sections are given detailed coverage with regards to design and architectural decisions that can go wrong.
This is not a start to end read. This book is better usable as a reference while we execute or plan during technical development cycle.
For each anti-pattern, a detailed background, symptoms, refactorings and example are provided. At the end of the book we are provided a Anti-pattern and Refactorings catalog.
The book also covers capacity planning type of antipatterns at the beginning. This will help give broader perspective about making design and possible implementation decisions on a enterprise scale.
A must read for enthusiastic J2EE practitioners who strive for quality output.

Rating:
Summary: Gotcha's exposed.... (A Review of one good book)
Review: Why should you read this book?... I mean you've read the J2EE Blueprints and that's supposed to be the best practices and you've followed all it's advice... didn't you? You should read this book because it gives you a way to see what you "didn't" do and how to fix it.

In this book the Antipatterns (APs) are grouped by J2EE topical area, several are identified for the area and then solutions proposed for each AP. Not only do they expose issues with designs that are common mistakes, but they then go on to not only tell you a possible solution(s) and also impart good principles on why.

Each AP has the following sections: Background, General Form, Symptoms and Consequences, Typical Causes, Known Exceptions, Refactorings, Varations, Example(s) and Related Solutions. The catalog of AP's in the appendix of the book provide a quick summary of each AP also, so you can see if your Symptoms are listed quickly.

One example is from the "Distribution and Scaling" chapter. The just of it is that in an enterprise system you use layering, workflow and the idea that the network is the computer to model and solve your problems. If you haven't you'll notice all of your code linking into libraries of many different types when library access should be localized to one workflow point that other workflow tasks utilize. By doing what they suggest you'll end up with a highly distributable solution and a weakly coupled system that will be flexible to change.

So save yourself some future troubles, or help yourself fix your current ones, read this book! It imparts knowledge you can't get from a Blueprint!!