<pre>Author/s : Bill Dudney, Stephen Asbury, Joseph K. Krozak, Kevin Wittkopf Publisher : Wiley Category :J2EE Review by : Michael Morris Rating : 9 horseshoes</pre> J2EE AntiPatterns is a must read for any developer that wants to improve their architectural skills. If understanding basic design patterns in software development is necessary then so is the understanding of patterns that are detrimental to overall performance, scalability and maintainability. Each AntiPattern is presented with a synopsis of aliases, scale, refactorings, refactor type, root causes, unbalanced forces (forces that work with the root cause to realize the AntiPattern) and anecdotal evidence (what a development team may say when stuck in the AntiPattern). Background info, general form, symptoms and consequences, typical causes, exceptions, refactorings, variations, an example and related solutions are provided for each AntiPattern. The only problems I noted with the book were a few typos and it seemed that some of the AntiPatterns were duplicated under different technologies. This is a reference that all serious J2EE architects should keep along with their copy of the GOF patterns.
Review by : Thomas Paul Rating : 9 horseshoes </pre> 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.
Originally posted by Chris G Lee: How does this compare to Bitter Java or some other Antipatterns books, such as Jakarta Pitfalls and More Java Pitfalls and even Rod Johnson's book?
I haven't read Bitter Java or Bitter EJB. I can tell you that this book covers most apects of J2EE including design. Based on the reviews of the Bitter books it probably is comparable to both of them and covers similar material to both of them.
This book is well structured into anti-patterns specific to different parts 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.