Customer Reviews


41 Reviews
5 star:
 (25)
4 star:
 (5)
3 star:
 (10)
2 star:
 (1)
1 star:    (0)
 
 
 
 
 
Average Customer Review
Share your thoughts with other customers
Create your own review
 
 

The most helpful favourable review
The most helpful critical review


5.0 out of 5 stars Excellent book
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.
Published 2 months ago by khorchani

versus
1 of 1 people found the following review helpful
3.0 out of 5 stars Good, but not great
This book has been getting a lot of hype -the followup to Fowler's seminal Refactoring, enterprise edition of the GoF, etc etc.
It's a dense and informative read. If you didnt know anything about cricket, you will by the end, as all its examples are basd on the game. I, sadly, find cricket deadly dull as a consequence of having it force fed at me in the UK...
Published on June 28 2003 by Steve Loughran


‹ Previous | 1 25 | Next ›
Most Helpful First | Newest First

1 of 1 people found the following review helpful
3.0 out of 5 stars Good, but not great, June 28 2003
This review is from: Patterns of Enterprise Application Architecture (Hardcover)
This book has been getting a lot of hype -the followup to Fowler's seminal Refactoring, enterprise edition of the GoF, etc etc.
It's a dense and informative read. If you didnt know anything about cricket, you will by the end, as all its examples are basd on the game. I, sadly, find cricket deadly dull as a consequence of having it force fed at me in the UK educational system. This may bias me against the examples somewhat.
As to the content, well, it is a set of patterns focused on 'enterprise' applications. In this context, enterprise means server-side code connected to a database, usually with a Web Front end. Martin goes into superb depth on how to map from databases to java and .net objects, making you think about whether or not the stuff that your framework of choice gives you is the right tool for the job. Sadly, all that does is make you more aware of the failings of EJB, JDBC, whatever .NET has. Because, unless you are going to roll your own database bridge by hand, you are going to have to run with what they give you -whether it [stinks] or not.
I dont do much O/R mapping. I hand it off to tools like Castor and worry about my real problems: shipping web services to implausible deadlines to be managed by an operations team that phone me whenever something goes wrong. So my problems are web service related 'good API design', and 'executional patterns': how to design code that is easily tested, what is a good strategy for implementing configuration information, what is a good XML format for future flexibility. I also have to worry about the client side: how to architect a client that works well over long haul and intermittent links, and how to present this to the user.
Martin's book doesnt cover these kind of problems. I do like his critique of Entity EJBs (as opposed to session beans), where he observes that because EJBs are all distributable, people tend to do just that, leading to performance problems that are very profitable to him as a consultant.
The implicit message is that these days, he is spending his time tuning object to DB linkages, and not worrying about all the other aspects of the problem. Another reviewer mentioned security, but my concern is about designing for high availablity, a series of practises that focus on redundancy, caching, and interdependencies and self-diagnosis of faults, rather than caring about minutae of O/R binding.
So I'm giving the book 3-stars, as it doesn't suit my problems. Maybe it suits other people better.
-steve
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


5.0 out of 5 stars Excellent book, Feb. 6 2014
Verified Purchase(What's this?)
This review is from: Patterns of Enterprise Application Architecture (Hardcover)
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.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


4.0 out of 5 stars Fowler defines the standards!, Nov. 10 2013
By 
Shaun Mccready (Montreal, Quebec Canada) - See all my reviews
Verified Purchase(What's this?)
This review is from: Patterns of Enterprise Application Architecture (Hardcover)
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.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


5.0 out of 5 stars What a book!, Sept. 16 2013
Verified Purchase(What's this?)
This review is from: Patterns of Enterprise Application Architecture (Hardcover)
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.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


3 of 3 people found the following review helpful
3.0 out of 5 stars Interesting But Muddled, Feb. 8 2004
By 
Vladimir Levin (Calgary, AB, Canada) - See all my reviews
(REAL NAME)   
This review is from: Patterns of Enterprise Application Architecture (Hardcover)
Overall, I was disappointed by this book. I develop business applications, and I was hoping this book would provide practical insights about such applications, more specifically in the database/web realm. While this book does contain some interesting pieces of information, it really is not of immense value to a developer such as myself. Here's why:
This book is a bit of a mishmash of different topics, but the vast majority of it (I'd say 75% or more) consists of ideas for object-relational mapping. Since most developers would use existing tools for object-relational mapping (in the Java realm, see Hibernate, JDO, etc.), I fail to see the real usefulness of this book for most developers building business (web) apps. Further, this kind of book encourages people who don't have the necessary expertise to try rolling their own OR mappers, which is simply not a good idea.
It's too bad, because the book starts off promisingly enough with 3 general approaches to business apps: Transaction Script: The procedural/transactional approach; Domain Model: The OO approach; and Table Module: The data-cetric approach. So far so good. Unfortunately the book then seems to steer off to the topic of "Fun With OR Mapping." It's not as sexy, but I think that's perhaps what the title of this book should have really been! The book then goes on to talk about different ways to architect Web applications, again mostly getting into how to develop framework code, which one largely would take for granted if one is deciding which framework to use rather than rolling one's own. Finally the book talks a bit about locking strategies (pessimistic, optimistic) and then presents a few generic items (e.g. the concept of a Money class or a Registry class).
Only a very small fraction of this book will be useful to a non-framework developer. Also, even though this book claims to be technology-agnostic, it seems rather firmly planted in the Java world. I'm not convinced an ASP/ADO.NET developer would find it particularly useful, for example. I think there is an important need to demonstrate how to put together solid business applications. I'd love to see a book of recipes that says "here's how to develop an ASP/ADO.NET app; here's how to develop using EJB; here's how to develop using Hibernate..." but without all the distracting details of how to implement the whole solution from scratch -- Basically I want a book that relies on the idea that frameworks are out there, but focuses the developer on how to choose a framework and how to take advantage of frameworks to produce solid, maintainable solutions.
Lastly, I would say Core J2EE Patterns from Sun Press is a more useful book for the Java/J2EE crowd, though it too suffers from framework-itis.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


5 of 6 people found the following review helpful
4.0 out of 5 stars A Collection of Patterns for Modestly Large Systems, March 22 2004
By 
ws__ (Hamburg, Germany) - See all my reviews
This review is from: Patterns of Enterprise Application Architecture (Hardcover)
Martin Fowler is a brand name for lucid ("UML distilled"), maturity enhancing ("Refactoring" for the practical side and the great "Analysis Patterns" for the modeling side) top notch books for software professionals. This book even has on its front cover a label telling us it is a "Martin Fowler Signature Book". This book was a disappointment. In the introduction Fowler claims much less. This book should be merely "useful". It is much better than that. It is good.
So what is the problem? The title is misleading. It is about patterns, but not really about enterprise applications. I am not in the subject of enterprise applications. I never ever have touched a program like SAP or a language like COBOL. But I encountered nearly every problem addressed in the patterns. Even the money class has corresponding problems in other fields: a Voltage has both a value and a unit. Also having complaints about the fact that 3 times 33% are less than 100% are always common.
What is this book about? It is basically about problems you have in moderately big applications. How do you connect a relational database with its structure and transactionality to a system, especially an object-oriented system (but not only)? And how do you connect to the user interface, especially a web interface. Also it contains a lot of useful small patterns at the end. As you can see: a lot of valuable stuff for many people. Yes and you get the deep judgments and fine humor of Martin Fowler too.
What is the main problem? This book is not really suited for actual reading. It contains an introductory part of a hundred and a reference part of four hundred pages. The introduction part is annoying to read. It is at the same time too simple (Some knowledge of relational databases should be a requirement for this book, and much more...) and too difficult (An extremely lot of forward references to patterns described later in this book). Also a lot of stuff is in the most trivial sense repeated within a few pages distance only. And it is repeated down to the wording of the individual sentences.
The reference part is a lot better. It gets better to read the further along you already read. The number of forward references gets less along the way. I liked especially the last part about base patterns. As their name already says they should have been much more to the beginning of the book.
This book contains an excellent book within it, just waiting to be "refactored" out of this collection of valuable thoughts. I firmly believe that Martin Fowler is well suited to do this refactoring job. I do sincerely hope that he does it for the next edition of the book. Most of the work is already invested and the result would be very valuable for many people. It is possible to write excellent and readable books about patterns as for example Buschmann et al in "Pattern Oriented Software Architecture" showed.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


1 of 1 people found the following review helpful
5.0 out of 5 stars Outstanding work in the field, Jan. 16 2004
By 
This review is from: Patterns of Enterprise Application Architecture (Hardcover)
I normally don't bother to write reviews, but some of the shallow ones I found here irritated me enough to write. I have been a developer, architect, and development manager. My latest project was a 100+ developer year enterprise application. Fowler clearly knows the field, he speaks with confidence of development experiences with projects that went live. I have no idea of what a newbie to enterprise application development would gain from this book. The DTO pattern, for example, is profoundly powerful and his representation of it is accurate, but he presents it in a casual, low-key way, and its significance might well escape the uninitiated. When you talk to programmers who only know the one thing they worked on you hear a naive, blind conviction in their voice, but when you read Fowler, you hear the weary lessons of hundreds of developers on dozens of large projects. If you are experienced, read chapter 8 first, then the patterns, then 1 - 7 if need be. If you are new, read chapter 8 first, then the patterns, then CODE the patterns a dozen times, then read the rest of the book. Fowler says you should read 1-8 then the patterns as needed, but I say the 8 pages of chapter 8 roll up the first seven chapters very nicely, and then please read all the patterns in associative order from your point of view.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


1 of 1 people found the following review helpful
5.0 out of 5 stars The right path to creating enterprise applications., Oct. 3 2003
By 
Charles Ashbacher (Marion, Iowa United States) - See all my reviews
This review is from: Patterns of Enterprise Application Architecture (Hardcover)
Fowler avoids giving a precise definition of an enterprise application, preferring to list a set of characteristics that most share. In general, they are very large systems, with many user interface screens used to concurrently access and update an enormous amount of data. In nearly all cases, the data must be persistent, in fact it most often is very persistent, meaning that it has to live through iterations of the software, alterations of the operating system, changes in the hardware, and staff and programmer turnover.
Furthermore, enterprise applications usually must communicate with other applications, which are often just as large and complex. Examples include payroll and patient records, credit card processing, insurance claim processing, banking, and foreign exchange trading. In short, most of the programs that run the modern global economy, which are many of the most complex software projects currently in use. Finally, the programs must be constructed so that they can be "easily and quickly" changed by people who did not create them to adapt to conditions that can change very quickly and often without any input from the programmer. With so much at stake, there must be a set of best practices, which is what is captured in this book.
The patterns of software construction explained by Fowler are generally in the small, in the sense that they describe specific operations rather than demonstrate a large architectural form. Each of the specific patterns is presented by first listing a one-sentence description of the purpose of the pattern and a UML diagram illustrating the structure. This is followed by sections describing how the pattern works, when to use it and one or more examples demonstrating specific implementations of the pattern using source code skeletons. Both C# and Java are used in the demonstrations, which does not create an understandability problem. The languages and contexts are so similar that anyone who can understand either one will have no problem reading and understanding the code.
Some examples of the fifty one patterns listed on the inside front cover are:
Lazy load - where an object will load only the data currently needed, but does maintain links to all other data that may be needed.
Front controller - a single handler object that consolidates all requests made for a web site. It can then send requests to the specific objects for services such as security, internationalization issues and specific displays targeted for particular users and locations.
Optimistic offline lock - used to prevent conflicts when concurrent business transactions are executing. The solution is to roll back the transaction when a conflict is detected.
Server session state - keeps the data for the session stored on a server in a serialized form.
While the examples are often of necessity extremely simple, they do illustrate some of the most effective and tested solutions to common software development problems. Therefore, this is a book that no builder of software that can be considered an enterprise application should be without. It is hard to believe that there is an enterprise application being constructed anywhere that does not involve the solving of many of the problems listed in this book.
My only complaint is the occasional bad English that appears. For example, on page 100 there is the phrase, "The only reason I've concentrating on Java . . . " and on page 119 the phrase "One factor that comes into this is comfortable used the development team is . . . " appears. While no book is error free, this type of error is frequent enough to make one wonder about the quality of the final editing.
There is nothing harder than making effective and efficient software that will run the IT equivalent of forever. That is what enterprise applications are supposed to do and if you are one of the minions tasked with doing your part to build one, then put yourself on the right path and read this book. You and everyone else who interacts with the software will be rewarded with a better experience.
Published in the online "Journal of Object Technology", reprinted with permission.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


5.0 out of 5 stars Design Patterns at the implementation level for J2EE, .NET, March 22 2004
By 
Jack D. Herrington "engineer and author" (Silicon Valley, CA) - See all my reviews
(REAL NAME)   
This review is from: Patterns of Enterprise Application Architecture (Hardcover)
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.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


5.0 out of 5 stars Application Architecture, Feb. 21 2004
By A Customer
This review is from: Patterns of Enterprise Application Architecture (Hardcover)
An excellent resource to understand the different architecture patterns, kept very simple and precise to the point.
Thanks to the author for coming up with this book.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


‹ Previous | 1 25 | Next ›
Most Helpful First | Newest First
ARRAY(0xb4c8ad38)

This product

Patterns of Enterprise Application Architecture
Patterns of Enterprise Application Architecture by Martin Fowler (Hardcover - Nov. 5 2002)
CDN$ 72.99 CDN$ 45.98
In Stock
Add to cart Add to wishlist
Only search this product's reviews