Patterns of Enterprise Application Architecture

Patterns of Enterprise Application Architecture

$49.99 $49.99

  • Release Date: 05 November, 2002
  • Collectible Price: $119.98
  • Used Price: $35.00
  • Availability: Usually ships within 24 hours
  • Third Party Used Price: $38.52

Authors: Martin Fowler, David Rice, Matthew Foemmel, Edward Hieatt, Robert Mee, Randy Stafford

Similar Products

Enterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions

From $31.49:

Enterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions

Refactoring: Improving the Design of Existing Code

From $42.34:

Refactoring: Improving the Design of Existing Code

Beyond Software Architecture: Creating and Sustaining Winning Solutions

From $32.39:

Beyond Software Architecture: Creating and Sustaining Winning Solutions

Test Driven Development: By Example

From $30.79:

Test Driven Development: By Example

Core J2EE Patterns: Best Practices and Design Strategies, Second Edition

From $34.99:

Core J2EE Patterns: Best Practices and Design Strategies, Second Edition

Customer Rating: 4.35 of 5 (37 total reviews)

  • 3 starsWould have been a great book 2-3 years ago

    First, I'd like to say that I think Marin Fowler is awesome. I've been a long time fan of his and I really enjoy his talks and his books. So when you read this review, you can tell that it pains me to write what I have to say. I don't want to rip apart his book so that he potentially sells fewer copies - that's not my intention at all. By writing 3 books myself, I appreciate that authors don't make a lot of money for developing the book itself. Usually people like Martin write books for the experience and to generally help people.

    That being said, many developers will unfortunately not find this book very useful. Many of the patterns Martin shows us have a lot of dependency on the platform you are using to implement the application. For instance, if you use Microsoft's .NET platform, you are going to be leaning towards a Table Module instead of a Domain Model. If you do not use a Table Module, you will not be able to take advantage of a considerable amount of functionality that is provided for you within the .NET platform. In Java, the same is true; the Table Module doesn't look as appealing if you are using EJBs, JDO or even Hibernate - you won't ever consider it.

    Many of the patterns in the book have this characteristic described above, so architects won't actually learn anything from them. In other words, architects will not be able to take advantage of these alternate design patterns without some initial headaches that are often not worth it because the platform they use restricts and penalizes their usage.

    Another complaint about the book is that many of the patterns are already available as frameworks. For instance, many of the presentation patterns are handled by frameworks like Struts or Webwork. In these cases, learning about the patterns that are associated with these frameworks will provide little value. These patterns have already been discussed many times before in other books like "Advanced Java Server Pages" for example.

    The same could also be said for persistence frameworks of O/R mapping tools. There is literally over a 100 pages (in a 500 page book) that talk about lazy loads, unit of work, locking strategies, metadata patterns and inheritance mappings. Although sometimes they are useful, in most situations the developers would be abstracted away from all these underlying mechanics using a good persistence framework or O/R mapping tool. I realize not all that the this is true, but implementing Martin's suggestions would take a month or two alone if you didn't buy anything off the shelf - that's too much time to waste. Martin should have talked more about these tools and the patterns they currently implemented instead as this is a more pragmatic approach.

    Martin also doesn't talk about the load-on-startup servlet that can be used to store application-scoped values in the ServletContext (for J2EE systems) in his Registry pattern. This was unfortunate because many non-ejb systems use this approach. Considering the book advocates using POJOs, JDO or JDBC instead of EJBs (which is sound advice in practice for most systems), they didn't cover the registry alternates for this approach. Many of us use containers like Resin because they are extremely fast and have no need for EJB development.

    Coming from three different environments myself (PHP, .NET and J2EE), I was disappointed that I didn't learn anything from this book. I had, in fact, learned about many of these patterns on my own, but didn't exactly know what they were called. This left me disappointed, but it's not Martin's fault. I don't mean to build me up that I know everything, but I think I've reached a plateau when it comes to designing and architecting systems - I'm good at it. If you happen to be a good designer too and you think you might want to broaden your knowledge, then this book won't help in those areas. If this book doesn't, I don't think you'll find another book that will either. So again, this isn't Martin's fault.

    Now before you say something, Martin explicitly states in his book that many experienced designers *will not* learn much. He mentions more than a few times that this book is meant to enhance the communication between architects and designers more than anything and that it is meant to be a documented repository of patterns that we know as an industry and use over and over. I completely agree with these statements. Thus, the book has value in these regards and it will definitely help the industry evolve and mature.

    I know I've said some negative things about the book, but let's face it - this is Martin Fowler! The quality and style of the writing is top notch and the organization of the information couldn't have been better. The explanations and examples are very clear and this book is what it claims to be. In this respect, the book should be regarded as the best in its market.

    I would advocate purchasing this book in combination with "EJB Design Patterns" and "Expert One-On-One: J2EE Design and Development" for the J2EE developer. As for you .NET folks, I have no idea. From experience, I suspect that .NET developers will have even less use for this book since Microsoft has limited your choices about design in favour of simplifying the platform. That's one of the major differences between J2EE and .NET, and Martin can't control that either.

    Overall, this is a good book. I give it only 3 stars, however, because of the initial problems described above.

  • 5 starsAn excellent architecture book

    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.

  • 5 starsDesign Patterns at the implementation level for J2EE, .NET

    This book is a little more implementation specific than the incredibly popular Gang of Four Design Patterns book. Many of the patterns, the Data Transfer Object pattern, for example, are fairly specific to the J2EE structural problem at hand. Other patterns, like the Lazy Load, are good architectural patterns on any platform. There is enough generic content to justify the purchase of the book for architects implementing on any platform (J2EE, .NET, PHP, etc.) but it does favor the two current platforms de jour; J2EE and .NET.

    One of the nice things about the book is how the code tends to de-emphasize the application container by doing most of the work in the raw database access systems (e.g. JDBC), which makes it easy to understand what is going on but will offend the true J2EE believer. This makes the patterns in the book accessible to anyone coding in any environment, which I greatly appreciate.

    One pet peeve is that some of the patterns are obvious shells for a single technique, such as the Transform View, which is really just XSLT. The text says as much, but shouldn't there be more than one example of a particular pattern in nature? It's just a pet peeve though, it's no reason to avoid the book.

    Overall, the book is well written and edited and the graphics add to the exposition but are not gratuitous. It's a useful guide for anyone looking to raise the level of the enterprise application (read web application) thought up to the next level.