Echo Spot countdown boutiques-francophones Introducing Fire TV Stick Basic Edition WFM home Kindle Paperwhite Vinyl Day sports Tools

Customer reviews

4.2 out of 5 stars
42
Patterns of Enterprise Application Architecture
Format: Hardcover|Change
Price:$68.48+ Free shipping with Amazon Prime


on May 16, 2017
A basic book that helps understanding the foundations of the construction of enterprise systems. It is not the ultimate source of truth though, and requires further reading on the trending topics and concepts that are gaining momentum and have been proven to work.
0Comment|Was this review helpful to you? Report abuse
on November 10, 2013
In this book, Fowler defines the standards that all programmers should know. These design patterns are used every day in real world applications and he makes a lot of valid points and guidelines to follow when programming. This is an essential book in my opinion for any programmer, especially J2EE developers.
0Comment|Was this review helpful to you? Report abuse
on September 16, 2013
More than 10 years after it was first published this book is still relevant.

Read it if you want to understand:
Databases,
ActiveRecord,
Hibernate,
Web frameworks,
Enterprise systems,
and anything in between.

Don't read it if you think programming is boring or your level of expertise is unmatched or you know enough.
0Comment| One person found this helpful. Was this review helpful to you? Report abuse
on February 6, 2014
Even if many of the patterns are used via frameworks, it is useful to understand the mechanics and the ideas behind them.
I apprecait the Fowler writing style. it's clear and easy to undersatnd even for those not fluent in english. This book will step you up if y're not already there.
0Comment|Was this review helpful to you? Report abuse
on June 14, 2015
perfect!!!!
0Comment|Was this review helpful to you? Report abuse
on March 22, 2004
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.
0Comment|Was this review helpful to you? Report abuse
on June 22, 2003
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.
0Comment|Was this review helpful to you? Report abuse
on February 20, 2003
I agree wholeheartedly with an above post which pointed out that the subject material is mostly known to the average enterprise developer. I am at best an average developer and found I'd already thought of much of this stuff myself.
One thing I would like to add is that this book was still excellent reading and skimming through the patterns sparked my creative energies. I find that when I read through it, even if I 'know' the patterns already, it helps me explore their organization and consequences.
I was disappointed that I wasn't blown away with helpful new concepts, but quite happy with my purchase all the same. Buy this if you want a thorough guide to EAA and maybe some enjoyable afternoon reading.
(The following was added about 2 months after the original review) After owning this book for awhile, I've found it more and more indispensible. My original review, above, mentions that few of the concepts seem new, however, now that I've read it more thoroughly and applied some of the concepts, I don't think that 'mind-blowing originality' is what I should have been looking for.
Fowler's 'Refactoring' is another example of a great book without any stunningly original concepts. Like Refactoring, PEAA can serve as a great guide to page through when you're stuck on a project and need to review your options.
0Comment|Was this review helpful to you? Report abuse
on May 1, 2003
Martin Fowler does it again. He manages to capture complexities of enterprise class application development in a simple, easy to read book.
If you've read any of Fowler's other titles, the structure of this one will come as no surprise. The first have of the book discusses the patterns in "narrative" format, and the second half presents them in reference format. If you are new to this subject, I highly recommend reading through the narrative section to understand how the patterns fit together.
If you've been involved in enterprise application development before, chances are you can simply flip to the second half of the book and start skimming the patterns. Each is only a handful of pages long and is accompanied by a description, use cases and example code.
Like other "patterns" titles, if you've been doing software development for a while you'll read the patterns and think "oh.. of course, I did that in xyz project". The patterns themselves may not be groundbreaking and chances are you've seen them in some form, but having a well documented reference of them nearby will be an asset to any software development effort.
0Comment|Was this review helpful to you? Report abuse
on November 23, 2002
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.
0Comment|Was this review helpful to you? Report abuse