Rating: 
Summary: Provides great insight, applying multiple Patterns together
Review: John's examples are easy to follow and he provides excellent descriptions of how you can approach utilizing Design Patterns. The book goes beyond the Gang of Four work, which he is a co-author, to demonstrate integrating multiple patterns to work together. He emphasizes creating extensible frameworks and leaving the design open for future evolution without disrupting existing code. I found the book very enlightening, it was a quick easy read and the design insights obtained are beneficial to any developer.
Rating: 
Summary: Articulate writing, Pleasant reading
Review: The book is using an example of developing an UNIX-like file system to illustrate how the design decision was made, and most importantly, how to choose the right pattern to accommodate the requirement (hatching process).Composite, Observer, Proxy, Singleton, Factory, Visitor and Template Method patterns were revisited and details were given on how to pick them from the GoF patterns. Even though the classification (Creation/Structure/Behavior) is arguably useful and effective (see POSA I, personally I agree with POSA authors that Structure/Behavior classification would not be too useful in OO design, almost everything fits into these two categories), the author tried to stick to the criteria of the GoF book. Two new patterns (Generate Gap and Multicast) were introduced. Generate Gap pattern was now broadly used in stub (CORBA, RMI) code generation tool. Multicast pattern is arguably a "variation" of Observer pattern. In general, the book is very easy to follow and pleasant to read. It does not offer more "insights" to the patterns in GoF book. If you understand the 23 patterns in GoF book, you don't really need this book as a companion.
Rating:
Summary: Excellent! An escential companion of the GoF book
Review: This book is an excellent companion for the GoF book, altough it has "own substance". It is written in a very plain, enjoyable and direct language. It address some extremely interesting issues for patterns interested audience. It starts analysing the Top Ten Patterns Missconceptions, giving a great view and light on this issue. He groups the misconceptions in 3 groups, being What patterns are, what patterns do and facts about the characteristics of pattern community. The second chapter gets even better: he copes the design of a Unix like File System design with Design Patterns, using Composite for the Files and Folders, Proxy for the Links, Singleton for users, Visitor for file system commands (he uses Unix cat command as an example), Template Method for single user protection and Mediator for multiuser protection. Chapter 3 is maybe the best: it goes into some patterns and analyzes where it falls short. He goes into how to kill a singleton, Observer's class and relationship explosion problem (using of course an example!) and how to solution this with an alternative approach with a Visitor. Following, he presents the Generation Gap pattern (which didn't made it to the GoF book) and goes through some other stuff related. Chapter 4 shows the pattern creation process of the GoF. It is awesome! he tryes to demistify themselves, showing the discussions regarding the Multicast pattern (which didn't made it to the GoF book). He reproduces all the email conversations between the GoF members, showing their pattern creation process filled with great insights. Finally, chapter 5 offers 7 habits of effective pattern writting. I've found this book very inspiring. I enjoyed a lot reading it and it gave me the opportunity to see how does the GoF work. If you enjoyed the GoF book, this is one is for you!!!
Rating:
Summary: Nice reading event for the experts
Review: This book is nice to read. It is written in a clear casual style. But don't be mistaken it requires quite a bit of maturity in patterns and in C++. And yes you do learn something more about patterns even about C++. So it is worthwhile but not mandatory.
Rating:
Summary: Simply Excelent
Review: This books really work reading. Very good complement to the GoF books.
Rating:
Summary: Excellent book
Review: This is one book that makes Design patterns look manageable. This book gives insight on the kind of discussions that GoF used to have to decide on a pattern being a pattern. That discussion gives an idea on the kind of stuff a pattern user should ask him/herself when using any given pattern. A particular discussion about Observer vs. Typed message pattern really makes it an enjoyable read. :)
Rating:
Summary: A great follow up to the GoF design patterns book.
Review: This is superb book. I felt it was easy to understand, of course I had already read the GoF book. It has a complete chapter filled with a great case study. It walks your through designing a UNIX style file system. There is nothing bad to say about this book, I recommend it to anyone who wants more after reading the original Design Patterns.
Rating: 
Summary: Interesting, but not a lot of content
Review: This really is the best book I know for describing the process of applying patterns to an application. It's a definite skill, a definite thought process, and very hard to convey. I do it by setting people specific problems to solve with specific patterns and hoping they develop the mapping for themselves. That usually works, sooner or later. The first half of this book is like sitting behind Vlissides while he works at the keyboard, and listening to him talk to himself. It's very informal and conversational. I don't know how well it generalizes to other patterns in other contexts. For some people, though, a concrete example like this seems very helpful. The second half of the book didn't give me much useful information. It continues the informal, conversational style. This part, however, involves several developers in the process of identifying, characterizing, and sometimes disqualifying candidates for design-pattern-hood. As much as I respect the people in the conversation, that section has a Disney-like fictional quality that I don't like. The old conversations have been reconstructed and morphed into some cleaned-up and picked-over form that reads well. Mostly, they just don't say anything that I can really use. Seeing an example worked may help some people. On the whole, though, this book has less information per inch of shelf space than many others. Populate your bookshelf accordingly.
Rating:
Summary: A Necessary Book
Review: This slender volume should be required reading for anyone working on an object oriented system (and if you're using C++, you ought to read it three or four times). This book won't so much tell you how to solve particular problems as much as it will help to develop a way of thinking about programming problems that leads to well-design solutions. The GoF book's second chapter example is unfortunate: virtually every programmer I've recommended Design Patterns to has expressed frustration over the inaccessibility of the primary example of applying patterns in a system. The file system example in Vlissides, on the other hand, is a lucid and enaging narrative that everyone relates to and seems to gain immediate insight from. I now recommend this book as a requirement for really understanding the GoF book. It's worth the price many times over.
Rating:
Summary: Technically lacking but filled with GoF insight
Review: This was an interesting book that gave some insight into the process the GoF used to establish their famous design patterns. Initially the book utilizes a file system example when discussing new patterns and detailing existing patterns. This example disappears after the first 50 pages. The discussion of why some patterns did or did not become patterns in their own right was interesting but not very useful in a programming sense.
If you're looking for a book that lets you see into the back room of how the GoF works this is a good one but if you're hoping to be more knowledgable in how to apply patterns or expecting new patterns this book will leave you wanting.. Still, an enjoyable read that was well written and interesting!
| 
