Rating: 
Summary: This is must-have book
Review: This book is the masterpiece. As Martin Fowler's Refactorings, this book will be a handbook of many, many developers. It is strange that after reading reviews of this book, I've found that many people do not understand the whole idea behind this book. If you come from the J2EE world you might not agree with some of the patterns presented in this book. But only experience in the field will show how you were wrong. If you have really complex business logic, trying to implement it with entity beans is almost always impossible. If you spent weeks fighting with your appserver environment instead of concentrating on business use cases, you would understand the value of these patterns.
Rating:
Summary: An indispensible handbook for Architects and Developers
Review: This book is the masterpiece. This book is full of sound advice, tips and traps. The patterns in this book they are very well identified, specified, clarified, and classified. Martin brings the patterns to life with just the right mixture of prose and code.
He provides a lot of code samples. If you have really complex business logic, you will find how the patterns presented in this book are useful. This book is useful for both J2EE and NET developers. This is particularly useful when attempting to gain an understanding of how application architectures differ between .NET and J2EE. Domain logic patterns described in this book are very interesting, they help you to map domain logic to a design; Data source architectural patterns can be considered as extension of entity bean and DAO; object-relational structural patterns can help you to map object to table design; there are other interesting patterns as Unit of Work (in Object-Relational Behavioral Patterns) and Query Object (in Object-Relational Metadata Mapping Patterns). In a whole, you see all of the basic patterns of object-relational mapping in this book. This book also presents some interesting presentation patterns, besides those presented in Core J2EE patterns, you can find Application Controller, Transform View, Two Step Views patterns very useful also. There are others very useful concurrency patterns, session state patterns, distribution patterns presented in the book, and you can find some "Base Patterns", which can be considered "classical" patterns. Martin has successfully shown how to use patterns to link together all of the parts of an enterprise system. Just as Design Patterns did seven years ago, this book will become the basis of a vocabulary that we will use from now on to speak about information system's architecture. This book will be a handbook of many developers.
Rating:
Summary: If you write enterprise applications, you need this book.
Review: This book sets forth essentially everything I've learned over the past twelve years or so about how to write enterprise applications (and many things I hadn't learned -- and now won't have to learn the hard way) in clear and easy-to-understand language. All of Mr. Fowler's books are worth reading. This one, along with Refactoring (ISBN 0201485672), are on the closest shelf to my computer and (I expect) will remain there for years to come.
Rating: 
Summary: If new to enterprise patterns a must read
Review: This is a well written book, with resonable explanations and samples. If you are familiar with patterns by GOF and distrubuted architecture patterns then there is not much new in this book. If not this is a must read and serves as a basis for platform independant review of a good cross section patterns to be applied in enterprise architecture, in which RDBMS's are always a key component. My expectations were high based on Mr Fowlers earlier works, not to say this is a lesser work, just it has been well covered before this work by Mr Fowler.
Rating:
Summary: An excellent architecture book
Review: This is an excellent Patterns book for a mature audience, and is a must-have for software architects and designers. In my opinion, together with the GOF's "Design Patterns", it stands out of the rest of the Patterns books, primarily because the patterns are real and are very clearly presented. A reader with a moderate experience architecting and designing industrial strength software systems will find at least some of the patterns familiar. You may actually enjoy reading this sort of patterns even more than those that are new to you: finding the validation of your own observations and ideas, as well as learning about new flavors and variations from the experience of others, can be a very satisfying process. The book consist of two parts: The Narratives and The Patterns. The first part describes architectural patterns in general, their relationships, and the problems they help to solve. Here you will find chapters about layering, organization of domain logic, object-relational mapping, web presentation, system distribution strategies, etc. The second part is a collection of patterns with a similar organization. Both parts of the book are written in a simple and clear narrative language. To get most value out of the book requires fluency in the UML; practically anyone with an object-oriented programming language experience will understand illustrative code snippets. In short: if you want to learn the wealth of architectural ideas compiled by the experts from the real-world experience and not get bored along the way -- get this book.
Rating:
Summary: Excellent book - a must read
Review: This is by far the best description of enterprise patterns I have read to date. Fowler points out that none of these patterns are new (and many have been around for a long while), but never have I seen such a vast array of useful enterprise patterns so well documented. I had heard and/or seen a lot of these patterns already, but the way he describes the patterns and the trade offs involved in choosing the patterns is truly awesome. The first half of the book is a discussion of enterprise architecture in general. I particularly enjoyed the section 'Layering' and 'Organizing Domain Logic'. I could really relate to these discussions, and much of what is written relates to problems I face often in designing my applications. I now have a much better understanding of what a true OO Domain model should look like, and I feel more comfortable in designing a fully OO business model. Some of the patterns presented in relation to database mapping may not be so useful because there are a lot of OR mapping frameworks available to do this for us now. But I still find these patterns useful in understanding how to use an OR mapping framework correctly and how they work under the covers. And you may not always have access to such a framework. I found the discussions on concurrency and transactions very valuable. I also think that the presentation patterns section is quite good too, although again there are a lot of presentation frameworks/tools available for this kink of thing like struts, webwork/velocity, asp.net etc. The only thing that I think this book lacks is a discussion on how to link the layers of an application together. Maybe I will read the book again soon in case I missed something, but I don't think he talks about how to integrate a domain model with the presentation layer, and he kind of skips how to integrate a domain model to the database layer (he just says use mapping which is difficult). I am giving this book 5 stars because it will change (has changed) the way I think about designing software in much the same way that reading a book like Gang of Four.
Rating: 
Summary: good reading
Review: This is certainly a very good reading about building enterprise applications. I like that the author gives samples for the most currently used software platforms, such as Java and .NET. Anyway, the author treats more the specifics of Java than those of .NET, and that shows the patterns he discusses don't always have such a general applicability. A certain thing not well covered is related to the table module. I have a compelling question about it and if any readers of the book are willing to help me with that, please let me know. I suppose questions aren't to be posted in a book review.
To conclude, I liked reading the book and I'm sure it's worth the money.
Rating:
Summary: Best J2EE / .Net Design Pattern Book
Review: This is the best book I've found on J2EE and .Net patterns. I think it's destined to become a classic. I found the discussions on when to distrbute ('sell your favorite grandmother first'), Unit Of Work, Domain Model and Data Mapper patterns extremely useful. It has changed the way I think about enterprise applications. I think it fits somewhere between the original 'Design Patterns' book, by Gamma, et al, and a book like 'J2EE Patterns' in terms of its scope. 'Design Patterns' describes existing patterns that are applicable to any kind of application. 'J2EE Patterns' describes patterns in terms of one platform (although many of them apply to other platforms as well.) Fowler's book describes a set of patterns that work with a certain kind of application, business apps, but that are applicable to more than one platform. It's better than the 'J2EE Patterns' book, which doesn't do a good job explaining which parts of J2EE to avoid, and which 'patterns' are in fact workarounds for problems in the platform itself. (For example, the 'Composite Entity' pattern.) I have to strongly disagree with the first reviewer. Fowler does explain which patterns work best on which platform. The first section of the book gives a good road map for deciding which set of patterns to use for your app. He mentions explicitly that .Net pulls you in the direction of Table Module, but that with J2EE you would be less likely to use that pattern. As far as the patterns being available in frameworks, I still find it useful to know about the patterns the framework implements. That way you know which framework to select. We recently went through an O/R mapping tool selection process. Reading the Unit Of Work, Data Mapper, Repository, Lazy Load and Identity Map chapters helped *immensely* in that process. Likewise reading the Front Controller pattern gave me some new ideas on how best to utilize the Struts framework. I totally disagree with the notion that "learning about the patterns that are associated with these frameworks will provide little value". Ignorance is definitely not bliss here. Finally, the idea that because the book 'just' collects and names patterns that already exist somehow decreases its value is hogwash. These are tried and true patterns that many developers have found useful. Naming and clearly describing common patterns is very helpful. This is exactly what the original 'Design Patterns' book did. By this logic, I guess the original reviewer would have given 'Design Patterns' only 3 stars. It's a great book.
Rating:
Summary: Many pearls of wisdom but spoiled by poor edit quality
Review: This is the only book I have encountered that describes .NET patterns. This is particularly useful when attempting to gain an understanding of how application architectures differ between .NET and J2EE.
The Java patterns are also very interesting, especially when compared with those described in the J2EE design pattern specific books. Note that this book might best be described as "Enterprise Design Patterns for non J2EE systems". Some of the patterns can be used to implement DAOs (perhaps for a BMP entity bean). Many others are not really J2EE compliant (eg Identity Map). To some extent, the patterns would only form part of the J2EE container implementation.
(However, "Server Component Patterns" by Volter, Schmid and Wolff provides a better coverage of the design patterns applicable to the design of a J2EE container).
This book would certainly be useful to any one wrestling with the "are EJBs useful" question. It provides an excellent description of all the issues that need to be resolved for an industrial strength implementation. Unfortunately, there are many edit problems.
For example, The MVC text uses both presentation and view interchangably. In one sentence, a typo causes this to be confused with model ("Fundamentally presentation and view are about different concerns" pg 331)
Other problems merely affect the sentence construction. (eg ".. and they people specialize in ..." pg331`)
These problems are the only reason that I did not give a 5 star rating.
Rating:
Summary: Implementation Techniques
Review: Well, I finally got through this one, so it's time to write the review...
I have to say I was disappointed by this book. Even though it's presented a MF's Signature book, in hardcover no less, the author tells us he just expects it to be "useful". Yes Martin, it is, but I expected it to be excellent, not just useful.
Another, bigger problem is that the title is very misleading: those like me looking to find something on the level of the Gamma and Alur books beware, the are very few design patterns here, as this deals mostly with implementations techniques. A title like "Strategies for Enterprise Applications" would be more accurate so you know upfront what to expect.
It has also been noted that it fails short on the Enterprise tag, discussing neither security, nor messaging or deployment, and I agree. Finally, I feel it also fails in providing "a pattern language" since there are just too many of them presented, with too many words on them.
But even as flawed as it is, I find it a good book, that will teach you some tricks you may have missed, and is also an invaluable introduction and teaching tool (just not for those of us already deep into design and architecture).
A very positive feature of the book is that it denies neither J2EE nor .NET, playing to the advantages of both depending on the subject at hand. However, for true design patterns in those technologies get the excellent "Core J2EE Patterns" and "Enterprise Solution Patterns using .NET" respectively instead.
| 
