Customer Reviews: Pattern-Oriented Software Architecture Volume 1: A System of Patterns
Automotive Deals HPCC Amazon Fashion Learn more nav_sap_plcc_ascpsc $5 Albums Fire TV Stick Sun Care Handmade school supplies Shop-by-Room Amazon Cash Back Offer CafeSociety CafeSociety CafeSociety  Amazon Echo  Echo Dot  Amazon Tap  Echo Dot  Amazon Tap  Amazon Echo Starting at $49.99 All-New Kindle Oasis AutoRip in CDs & Vinyl Segway miniPro

Customer Reviews

4.5 out of 5 stars
Format: Hardcover|Change
Price:$78.85+ Free shipping with Amazon Prime
Your rating(Clear)Rate this item

There was a problem filtering reviews right now. Please try again later.

on February 10, 2000
It is a shame that this excellent book does not receive the same level of attention (at least in the U.S.) as the Gang of Four's Design Patterns: Elements of Resusable Object-Oriented Software. Pattern-Oriented Software Architecture is more comprehensive in scope and, to my mind, better written. In particular, it provides a solid, highly pragmatic framework for understanding and utilizing patterns at 3 levels of scope/abstraction -- i.e., architecture, design, and implementation -- not only design. Moreover, the authors pay significant attention to variations of patterns, trade-offs between alternative patterns, and the relationships between patterns that in practice may need to be combined in order to accomplish the objectives at hand. The book's overall organization, presentation of material, and referencing of related pattern sources (including the GoF's work) is superb. This is my top patterns reference, with others as serving as adjuncts.
0Comment| 77 people found this helpful. Was this review helpful to you?YesNoReport abuse
VINE VOICEon May 13, 2000
While I have argued since it came out that the G of 4 book is the most important programming book of the decade, I have to agree with the other, lone reviewer here, that this is a deeper, more mature work. I rediscovered this book when Alan Holub's series of recent articles began to appear in JavaWorld about implemnting UIs and I realized that he was taking a lot of his ideas from Buschman. One of the reasons I bring this up is that it made me realize that this is the great thing about this book: it dares to wrestle some of the complex issues and tradeoffs to the ground, presenting the reader with a more useable guide to the practice of implementing patterns. You may have read John Vlissides' (Go4 author) comments about how for years after the publication of his book he'd ask when he spoke who had read the book and nearly everyone would raise their hands, then he'd ask who wanted to come up and explain the momento pattern or the bridge and only a couple of people's hands would be raised. This is in part due to the fact that the Go4 book encourages the concept of simple ICs that can just be retrieved and plugged in. In reality, as anyone who has read Vlissides' other book which spends its whole duration talking just about Visitor, the opposite is true. Buschman's book is the best in this regard at spanning the range of design issues but still dealing with the complexities of implementation, and helping the reader through the process of assessing trade-offs and still matching requirements.
0Comment| 69 people found this helpful. Was this review helpful to you?YesNoReport abuse
on June 11, 2000
This book is a perfect companion to "Design Patterns - Elements of Reusable Object-Oriented Software" (the GoF book) and it is more didactical than the later.
If you are new to patterns, I suggest that you first read this book and refer to "Design Patterns" when needed.
In "Pattern-Oriented Software Architecture", there are some chapters on pattern and software architecture concepts, but most of the book is dedicated to describing architectural and design patterns (there are a few pages on idioms). Some of the architectural patterns are well known: layers, pipes, filters, broker and microkernel.
The code is clear and written mainly in C++. The notations used are easy to understand (OMT notation is addopted for the object models and an adaptation of Message Sequence Charts to object interations).
The production (cover, paper, etc) is excellent.
0Comment| 27 people found this helpful. Was this review helpful to you?YesNoReport abuse
on June 23, 2000
Definitively, after reading the GoF book, get this one ! The Design Patterns receive more attention in my own opinion, because patterns newcomers (I was one of them, few years ago) found at first (nices) solutions that may be applied directly. It take a little time to understand that the great idea is elsewhere. POSA book (this one) tackle directly to this great idea, and exposes several patterns categories (3, in fact). Architectural patterns are really well explained, much better than in the GoF. The POSA book receive less attention probably because authors forget the idea to "attract" newcomers, at least in my mind. Anyway, the Design Patterns is my "book of the Decade". I consider this one as the second to purchase in the patterns movement, but it's not a second hand material, it's a complementary materials.
0Comment| 32 people found this helpful. Was this review helpful to you?YesNoReport abuse
on July 6, 2005
First of all, you need to understand the patterns in the gang of four book before you attempt to read this one. They talk about them all over the place without explaining them. That's a warning, it didn't affect my review.

The major thing I don't like about this book is the abstractness with which they talk. They give you a high level description of a pattern and leave you with that fogginess.

I think the examples were poorly chosen. I would have prefered to have examples that are only as complicated as they needed to be. Unfortunately the book uses examples like, "We're going to make a voice recognition application" or "We're going to make an OS that can run applications that were built on Unix or WinNT or Linux". I think the intent was to have some real-world-I've-been-working-for-six-years examples... it would have been smarter to put the real world examples in a separate chapter and keep the design pattern explanations simple.

Also, I hate the diagrams. They should have just copied the diagrams in the GoF book! Instead they chose these diagrams that give less info and IMO are downright ambiguous in some situations. Another thing the GoF book does is have 2 separate diagrams, one that's a (simple) real world example and another that's a diagram of the actual pattern. This book only has the diagram of the actual pattern.

I disagree with those that say this book is better than the GoF book. I think what they like is the material covered. Material aside, the GoF book presents the information in a much clearer way. That's why I prefer the GoF book over this one.
0Comment| 36 people found this helpful. Was this review helpful to you?YesNoReport abuse
This is an unusual book in the pattern genre. It presents a number of patterns, categorized by archtiectural level. That's just the first part of the book, though. The third of the book is about the process of using, relating, collecting, and distributing patterns.
Only chapter 2 really addresses patterns for the strategic, architectural level of a software system. It does a very adequate job, using a variety of notations, examples, and analysis steps. This book is from 1996, so time has changed our view of some patterns. "Reflection," for example, has become pervasive in applications based on plugins and software components. It is also a fundamental API in the major langauges (Java and C#) released since this book was published - perhaps reflection should be downgraded to an "idiom". That's just nitpicking, though, since reflection is even more important now than when the book was written.
For contrast, the authors present additional design patterns (including some from Gamma's book) for use at tactical design levels. They also discuss idioms patterns that typically involve just a few lines of code within on function. The contrast between the three different levels of implementation and design gives a useful discussion. The authors also present a weak chapter on "systems" or "langauges" of patterns The discussion is OK as far as it goes. The weakness is in what it omits. After reading this brief chapter, the programmer has very little practical information about choosing patterns from some library for some task. The poor programmer has no information at all about how to link patterns together, and that's a real stumbling block for beginning pattern users.
The final section of the book is really sociology. It's about the pattern community, what that community is for, and how to be a working member. I find the discussion un-helpful, but I expect opinions to differ.
Even today, this is a good second book (after Gamma's 'Design Patterns') on patterns and pattern usage. It lack the depth and precision of Gamma's book, and tends to add words without adding meaning. On the positive side, it's broader than Gamma's, and addresses a wider range of implementation levels.
0Comment| 9 people found this helpful. Was this review helpful to you?YesNoReport abuse
on July 19, 2001
It's a nice reading after the GoF book. The GoF book provides more practical and easy to implement design level patterns, so I suggest you start from it first. After that, if you want to continue your journey in the software patterns, you should read this one. The first 300+ pages, talking about Architectureal Patterns/Design Patterns, are very good. The rest 100 pages are still interesting, but are a little bit light. Overall, it's a worth reading for software architects/developers. I'd like to give it 4.5 stars - well, 5 stars should also be O.K., considering there are so many quick & rush computer books on the market.
0Comment| 11 people found this helpful. Was this review helpful to you?YesNoReport abuse
VINE VOICEon June 15, 2003
POSA1 is written far better than other related texts, such as GoF. (And be aware of the fact that GoF only contains design level patterns - it does not contain system architecture level patterns.) At the same time, after its nth reprinting and redesigned book cover, the text still contains non-UML diagrams (although there are some UML-like sequence diagrams included), and very few real code examples. The lack of code examples, though, can in some ways be seen as a positive aspect of the text. Compare this text with Applied Java Patterns, for example. AJP has very extensive code examples, but because the code examples for each pattern run for pages (rather than simply providing code snippets), the reader may be inclined to narrow their view of how the pattern is applied. For example, MVC is definitely not a pattern limited to GUI user interfaces! The point on which I think that POSA1 seems to come out ahead is that the stronger-than-ususal pattern descriptions and applicability, with a small amount of code provided where deemed especially relevant to the point being attempted to make, helps one understand the patterns better rather than memorizing language-specific implementations of patterns. This point is why I think the text was chosen to accompany Software Architecture in Practice for the graduate software engineering course in software architecture I just took.
0Comment| 7 people found this helpful. Was this review helpful to you?YesNoReport abuse
on October 22, 2005
Second best isn't bad when the #1 book changed forever the way software architecture is talked about. GoF is not only well-written, but it covers all the basic, most-used patterns. Everybody thereafter is going to have to either re-hash GoF, criticize it, or come up with new patterns which are not as fundamental.

This book is full of new patterns, and fortunately they are good ones: Command, Broker, Layers and worth the price of the book in itself Presentation-Abstraction-Controller.

PAC can be seen as a generalization and extension of Model/View/Controller. The Abstraction is the domain-specific part of the architecture, effectively the Model. The Presentation exposes the Model in some interesting way, either as a user-interface in which case it is a View, or as an API, in which case the Presentation becomes a new Abstraction used by the next level up. The Controller is left with the job of coordinating the Presentation and the Model. The key to the pattern is that PAC agents can be built up into layers with the Presentation API of each lower agent creating a higher abstraction for the next level. Thus PAC becomes MVC for all or your architecture, not just the UI.

The book goes into this at length and adds useful discussion of MVC. Highly recommended.
0Comment| 7 people found this helpful. Was this review helpful to you?YesNoReport abuse
on June 1, 2003
I recommend this book for students like me who are taking intermediate computer science courses for the the following reasons. It's a readable book for students who are new to the concept of applying patterns to software design. Many of the patterns in the book can be used for school projects. Furthermore, the book exposes the reader to a new way of thinking during the design of large programs. School projects are often short and programmed individually. This book deals with real world situations where programming projects are large and complex and done in teams. It emphasizes design and takes into account non-functional programming issues such as changeability, exchangeability, and extendibility. These issues are barely covered in school. This book will force the student to look at programming and design from a differenct perspective. It will make you into a better programmer. Also, you can read it all in about a week.
0Comment| 5 people found this helpful. Was this review helpful to you?YesNoReport abuse