Rating: 
Summary: extracts from published reviews
Review: 'Design Patterns' (Gamma et al) is already a widely read classic and I think 'Pattern-oriented
Software Architecture deserves to become one too. Whereas 'Design Patterns' covers a single
level of abstraction in object-oriented development, the present book covers three levels: the
high-level architectural patterns, design patterns and language-specific idioms.
CVu, Jan 1997
Now that the initial rave around patterns has fallen away, there is a need for a book to build
a bridge between academe and industry. This may be one such book... The authors of 'Pattern-
oriented Software Architecture' are using it as a vehicle to a new approach to software development
that brings in the learning gained by experience...
An inexperienced designer might look for a left-handed screwdriver that the inexperienced engineer
might try to provide. Educators and employers must both take steps to lead the gullible novice from
theory into practice - and 'Pattern-oriented Software Architecture' will be useful on the journey.
Object Expert, March-April 1997
'Pattern-oriented Software Architecture: A System of Patterns' (which has become known as the POSA book)
is not a substitute for other pattern texts currently available. I recommend reading the preliminary pieces
even if you are already familiar with patterns...this text is good and I recommend it as an addition
to any collection of books on patterns.
C++ Report, January 1997
Rating: 
Summary: The second book on patterns
Review: 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.
Rating:
Summary: Adds Engineering to CS
Review: 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.
Rating: 
Summary: Too basic
Review: If you're writing a book on patterns, then I think the ones you should pick are ones that _aren't_ straightforward. The book assumes that a reader is somehow unable to comprehend architecture by using various algorithms or operating systems. I learned about divide-and-conquer/master-slave from using quicksort. I learned about microkernals from Unix. I learned about pipes and filters from using Unix and DOS. I learned about Layers in networking. Publisher/Subscriber and MVC are basic components of C++ Windows programming. I'm just not seeing the advantage of much of this book, when I can pick up a significant number of the patterns through core CS courses or a basic Windows programming book. I think the assumption that the book makes is that somehow the reader has not been able to connect things together that they've learned while getting a CS degree. The patterns described seem to me to be enabling frameworks that already exist on many operating systems or common libraries already. In this case, it really doesn't help me to have an overview of many different systems. I want to know specifically how a particular framework does things. Even if I am architecting a new system, it would be much more in my interest to study existing systems in detail rather than look at POSA1. If you're wondering what I think about pattern description in general, a book that is not billed as a "patterns book", but is much more about patterns than anything else I've seen is Transaction Processing by Gray and Reuter. In it, they describe a number of different approaches to systems, what seems like the right way to do things and _isn't_ and why it's wrong, and finally what IS the right way for a working system. Along with this is p-code applicable to the discussion, not examples like Point, Shape, Maze or the other silly throwaway illustrations that I see in most patterns books. Others compare this book with the GoF book. I find GoF more helpful than POSA1, but in their favor, both POSA1 and POSA2 have far better clarity.
Rating:
Summary: A book for every software architect
Review: It covers architecture patterns for UI, command processors, layers, ... etc. It is a very good book for every developer who is designing a software product. Following the patterns, it allows one to really shorten the design time needed
Rating:
Summary: A book for every software architect
Review: It covers architecture patterns for UI, command processors, layers, ... etc. It is a very good book for every developer who is designing a software product. Following the patterns, it allows one to really shorten the design time needed
Rating:
Summary: Simply outstanding
Review: 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.
Rating:
Summary: Nice reading after the GoF book
Review: 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.
Rating: 
Summary: Decent software patterns book
Review: 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.
Rating:
Summary: 4.5 Stars: Thorough, Deep and READABLE
Review: There is a basic problem with the pattern literature. It is usually as easy to read as a cookbook. This book can actually and worthwhile be read from cover to cover. Big achievement! I learned quite a bit from it and found it very well spent time reading it. The authors try to be very systematic. They try to do everything as good as they can. They are of a high quality. They even use extensive peer review at the patterns conference. Still the different sections are of a very diverse quality both in depth and breadth. Sometimes difficult concepts are just dropped on the reader, while fairly trivial stuff is explained over some pages. Anyhow this book is an excellent complementary book to the GoF (Gamma et al.) one.
| 
