Rating: 
Summary: An essential companion to the GoF book
Review: A succint and lucid explanation of how patterns can be actually applied. Chapter 2 is a must read where John develops a file system application - he dwells in great detail about which patterns suit best the needs of the application and which do not. He starts with the Composite pattern, then refines the model gradually with Proxy, Visitor, Template method, Abstract Factory, Singleton and Mediator patterns. The 3rd chapter introduces a new pattern called 'Generation Gap' while the 4th chapter is an extremely entertaining read containg numerous excerpts of correspondences between GoF authors where they debate whether the MultiCast pattern is just a refinement of Observer or a pattern in its own right. IMHO - read the basic patterns in the GoF book first, read chapter 2 of Pattern Hatching, go back and read the GoF book again. Do this a number of times and you'll probably have a much better insight than by just reading the GoF book. A word of warning for Java developers - it would help to have a decent knowledge of C++ (templates included ;-) ) to understand the code samples.
Rating:
Summary: My coments on the book
Review: A very helpful book especially very after GoF?s one reading . However it has a lot of C++ specific places, java developers will find the book also interesting :). It's written by one from the gang - John M. Vlissides. First part of the book gives a glance view of applying several GoF patterns in dummy simple file system building (Composite , Proxy, Visitor, Singleton, Mediator ) . The author also introduces two new patterns which don't mentioned in the Design Pattern (Generation Gap, Multicast ) in the next parts .
Rating:
Summary: The key word is "Applied"
Review: Although I was familiar with the GoF patterns before I read "Pattern Hatching", John has given me a whole new perspective on their use. "Pattern Hatching" showed me how to use the patterns in a generative way. In the past I used patterns to explain a design I came up with through "intuition". But using the patterns to generate the design has improved the final outcome. Now I have a better understanding of the role of patterns in the development process. John has an easy to read style which makes the material very accessible. The length isn't daunting either. You should certainly spare the time to read this.
Rating: 
Summary: A worthwhile read
Review: Fans of the original Design Patterns book will be pleased to find that the Gang of Four (GoF) has included a brand new pattern--Generation Gap--and a rough draft of one more, called Typed Message. This new pattern, dealing with code generators and the problems that arise when you modify generated code and then need to regenerate it, may be worth the purchase price of the book alone. This book is definitely less structured than Design Patterns--almost rambling at points as it jumps from topic to topic. Nevertheless, it is enlightening to read samples of actual communiqués between GoF members as design patterns are fleshed out. This is an insightful view of the process of writing patterns. (Indeed, chapter 5 is dedicated to how to write patterns well.) My one complaint is that the book is divided into only five chapters, several of which are overly long. The book would benefit from a little more structure. However, it is undeniably valuable and is a must-read for those interested in the patterns community. The author dedicates an entire chapter to a sample project (designing the file system for an operating system) that incorporates four or five patterns. If you found Design Patterns to be too theoretical, and have trouble seeing how to apply patterns to real-world projects, this chapter will probably help. Warning: Most of the contents of this book, as with Design Patterns, are applicable across languages. However, Chapter 3, the thickest chapter in the book, and the least useful to me as a VB5/Delphi developer, deals almost exclusively with implementation problems and "workarounds" when implementing patterns in C++. If you work mainly with some of the other viable platforms out there, you may want to skim through this section. Overall, this book was a worthwhile read and didn't actually take that long (it's only 156 pages). If you're a software designer and you're interested in patterns, you should read this book.
Rating:
Summary: Patterns Demystified
Review: GoF presents everything you need to start with patterns. This one tells how to identify a pattern when it's cooking. It explains in actuality what patterns can and cannot do, what patterns are and are not, how does a pattern come to existence and stuff related to the concept of patterns and not a list of patterns as in GoF. GoF is if you need to dive into patterns. This one if you need to swim in patterns. Don't expect a list of patterns as in GoF. This is more on how to identify a pattern, how to chose among a set of patterns, when to use, when to invent and etc. This book will serve best after the pattern hype has washed over you atleast once.
Rating:
Summary: Must read for beginners... good for others
Review: I have read lot of good books on OOAD and patterns like Design Patterns, Refactoring, Analysis Patterns etc. I wish I read this book along with Design Patterns long back. If you are starting new with patterns... read this.... just 150 pages. If the cost seems high, buy an used one.
Rating:
Summary: Blown away.
Review: I was taken back by this gem. Vlissides starts of by dismissing all of the false claims and rumors about design patterns. He then proceeds to take you through the creation of a basic file system, explaining things like what a 'mkdir' type of program should do, and how to impement it. During this whole process, he presents various design patterns taken from the GoF book in a real context. Don't buy this one alone. This is meant to be a supplement to 'Design Patterns'.
Rating:
Summary: Really get your hands dirty with the GoF stuff
Review: I've already seen the GoF book ("Gang of Four", i.e. "Design Patterns" by E.Gamma, et al.) mentioned as _the_ book of the decennium in the field of software development lots of time. And I tend to agree with that. However, for a lot of people it is "just" a boring catalog. It doesn't teach you that much and on its own doesn't really help you with your daily practical problems you face as a programma (they think). I don't really agree with that, but this book ("Pattern Hatching", by one of the original GoF) sure does a terrific job of really getting into the more practical side of things. And it seems to me that this is exactly what a lot of people need. This book is almost nothing to you if you haven't read (or in fact: don't own!) a copy of the GoF book, but for those people that wonder how to decide which of those patterns is useful in a certain situation, how patterns can be adapted, changed, augmented or just moulded into shape for a practical task at hand this book will probably exactly be what they need. Of course the principles of design patterns are not restricted to any specific programming language (even restricted to software development per se...) but even so for some people it might be a problem that this book (like the GoF book) leans somewhat heavily on C++ as the language used in the examples and such. But that certainly shouldn't be a problem to anyone. If you're into OOP - either by choice or because you somehow have to - than you need not only the GoF, but probably this book as well.
Rating:
Summary: I couldn't put it down.
Review: If you liked the "Gang of Four" book (Design Patterns: Elements of Reusable Object-Oriented Software, by Gamma et al.), you will love this book. Mr. Vlissides has an execellent writing style that is very engaging for this type of material. Besides going into some additional design patterns, and some pattern strengths and pitfalls, you get a facinating behind the scenes look at what went on in the development stages of the original Design Patterns book. Chapter 2 of the book ("Designing with Patterns") is the best written example of how patterns are used in practice that I've ever seen. That chapter should be required reading for anyone who is confronted with having to create software designs but doesn't know where to start in making various design tradeoffs. When I got the book, I was consumed until I had read it from cover to cover. If you are interested in design patterns, you will probably feel the same way.
Rating:
Summary: The next best thing to being there.
Review: In lieu of an oppurtunity to apply patterns under the tutelage of a mentor, I found this book very useful. I found Chapter 2 an especaily enlightening glimpse into how pattern choices are wieghed, applied and even, when applicable, discarded.
| 
