Customer Reviews

Pattern Hatching: Design Patterns Applied

5 star:		(18)
4 star:		(6)
3 star:		(1)
2 star:		(0)
1 star:		(0)

 

 

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.

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.

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.

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.

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.

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.

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.

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.

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.

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!!!