Rating: 
Summary: Light content, great format
Review: It does not introduce that many new patterns. It seems to rehash a set of key patterns in different contexts and combinations. Fortunately, in the case of this book, this rehashing is a good thing. By the time you complete the book you will have clear understanding of the patterns and how to apply them. Summary, the content is light but format is great
Rating:
Summary: Light content, great format
Review: It does not introduce that many new patterns. It seems to rehash a set of key patterns in different contexts and combinations. Fortunately, in the case of this book, this rehashing is a good thing. By the time you complete the book you will have clear understanding of the patterns and how to apply them. Summary, the content is light but format is great
Rating: 
Summary: An excellent must have book
Review: It's a MUST HAVE book for anyone who is dealing with J2EE at a technical level. The simple language and excellent code snippets help understand the patterns easily. It also establishes common vocabulary for patterns which makes communication among different groups like designers, developers, etc very easy. By including strategies, authors help understand different possible ways of implementing the pattern, which is very helpful.So if you don't already have this book, go get it
Rating:
Summary: Very nice book
Review: Its just amazing to me that this book has put together a few years of intuition that I've been relying upon into one place. Nice job. Very good book! bctinc@yahoo.com
Rating:
Summary: Superior J2EE Design Book
Review: J2EE technology is rapidly becoming a technology standard for many application server solutions. By providing a common set of services, J2EE makes the development task more straightforward and also moves IT customers away from the use of proprietary vendor APIs for many common development situations. In so doing, it gives Java developers an ability to work at a higher level of abstraction and share greater commonality with other applications than could be done previously. With Core J2EE Patterns, the authors provide a reusable set of software structures which can be used with great success to take advantage of these new Java technologies. The authors carefully construct basic architectural patterns using easy to read UML diagrams with supporting code snippets. However, this book is not designed to be a programming guide. Instead, it seeks to provide stylistic insight into which patterns to use and where, while also providing useful examples of bad practices which may arise -- and how to remedy them. A refreshing plus for the book is that the authors give proper credit to the inventors of each pattern. The Gang of Four authors and Martin Fowler are cited extensively, but lesser known innovators are also acknowledged. The "Core" of the book is the exhaustive J2EE Pattern Catalog for Presentation, Business and Integration tiers. The explanations are clear and the cross-referencing between patterns is extensive and quite helpful. The structure by which each pattern is presented is identical, which helps for ease of use, especially when browsing through for quick reference. The book ends with a valuable epilogue, where three use cases based on a Professional Services Automation application are presented. The business context of the application is self-evident for most in the software industry, and the pattern realizations are textbook examples of how object-oriented analysis and design should be performed. For all who wish to design J2EE applications for the enterprise, this book will prove to be an invaluable reference.
Rating:
Summary: A Hands-on Patterns book - And a must read for J2EE Pros.
Review: Just one line - "Excellent book - A well written Practical guide and Patterns library for all J2EE development". A must-have in every Java pro library. I can't wait for the 'second edition', It looks like it is coming soon.
Rating:
Summary: A Hands-on Patterns book - And a must read for J2EE Pros.
Review: Just one line - "Excellent book - A well written Practical guide and Patterns library for all J2EE development". A must-have in every Java pro library. I can't wait for the 'second edition', It looks like it is coming soon.
Rating:
Summary: Required Reading for Anyone working with EJB
Review: Not another line of code for Servlets, JSPs, or EJBs should be written by anyone who hasn't read this book and understood the concepts explained. This book is about best practices in designing and coding J2EE applications. The lessons explained here were developed by the Sun Java Center based on their work in the field. As they developed applications for clients they noticed that the same problems occurred over and over again. This book documents the standard solutions to solve these problems that were built as a catalog of design patterns and best practices. Part 1 is an introduction to design patterns and the J2EE platform. Part 2 is a catalog of bad practices (the authors describe these as, "less than optimal ways to solve problems"), and refactorings (ways to correct these problems). Developers working with poorly designed J2EE applications will find this section especially helpful. In Part 3, fifteen separate design patterns and strategies are explained. Each pattern is described in detail with the motivation for using the pattern and the design goals to be achieved. UML class and sequence diagrams are included along with detailed code examples that serve to further clarify the pattern. These patterns aren't theoretical constructs but rather are practical strategies that can be applied to real world applications. Using the strategies in this book will make you more productive and your code easier to understand and maintain. Anyone designing, architecting, or coding with J2EE will find this book to be extremely useful.
Rating:
Summary: Overall very good, but there are still things to be desired
Review: Overall it's a very good book. It covers many of the design level patterns of J2EE applications. Many of the previous reviews have covered everything good about the book, I do agree with most of them. I particularly like part 2 of the book - "Design Considerations, Bad Practices and Refactoring". However, the book also left a few things to be desrired (at least IMO): 1) The Consequences of pattern should have been cleared marked as pros and cons, together with trade-off discussions 2) The last chapter "J2EE Patterns Applied" is way too light
3) I'm not so comforatable of the authors' using of the word "strategy": IMO, calling them "Implementation Variants" would be more appropriate
4) Some of the UML diagrams (especially class diagrams) are rather weak, even confusing at times
5) Lack of discussion of the high level architectural patterns, e.g. MVC Overall it's still a excellent book, definitely worth reading! Considering there are so many rush/not-well-thought tech book out there, I certainly have no problem giving it 5 stars.
Rating: 
Summary: ok summary, still much room for improvement
Review: positive:
- summary in one book (like gof) neutral:
- nothing new (but neither was gof) negatives:
- too much jingoism. i feel like i was reading a book from the marketing and not the engineering department. we are reading this book because we are pretty senior and do not need to be convinced that java is the second coming
- the authors would be more effective if they just stick to the facts give us the tradoffs, since nothing is free. (gof tells us when to use and as important when not to use the patterns.)
- only 15 elements (gof had 23)
- 459 pages. these people (tech writers) should reread k&r and learn how to write more clearly and more succintly, i.e. it is much easier to read and understand one good paragraph, rather than pages of materials repeating themselves.
- useless examples. again, reread k&r. the examples there were concise *and* from real life, pratical code.
- essentially oo enables encapsulation, polymorphism, and most importantly code reuse (which usually means less code, hence less bug). patterns illustrates correct use of oo. hence the elements here are not patterns (like gof), but anti-patterns. they are essentially known hacks around known distributed problems that j2ee had putatively solved.
| 
