Design Patterns for Object-Oriented Software Development

Rating:
Summary: Wannabe
Review: First, counter to the Amazon listing, Erich Gamma has nothing to do with
this book -- though I would guess that he would probably be willing to
articulate his opinion about it if asked.

Second, this book has little in it that is of practical use to the
everyday programmer. A German habilitation thesis re-hashed
as a consumer book, it creates its own worldview of software
development in a way that is technically compatible with the
GOF view, but only in the sense that the structure of a broken
glass is compatible with the original. The book has none of
the insight that comes from the Alexanderian tradition of patterns.

There are a few parts of the book that are harmless: the "hot
spot" metaphor, for which this book is best known, is useful.
But its articulation in the domain engineering literature, which
predates this book book by a decade, is more thorough and
applicable. Perhaps Pree's legacy will be the introduction of a
cute phrase for something that all designers have long found
useful, and which all but the most clueless designers have found
obvious.

Rating:
Summary: Past its sell--by date
Review: I haven't quite worked out who was meant to read this book. It starts with a lengthy discussion of polymorphism and inheritance, presumably addressing a reader to whom those would be unfamiliar. Even in 1994, when this first came out, object orientation had wide acceptance. There may have been some readers back then who needed the introduction, along with the OO-savvy readers. The OO-positive readers didn't need the introduction, but the OO beginners would have had a very hard time with the more advanced discussions that follow.

Pree's whole concept of metapatterns seems to have been dropped from the literature. It's not that the ideas were bad, or even obscure. Quite the opposite, they were so pervasive that they mostly seem to represent language primitives. For example, creating a variable of type X and letting it reference an object of some X subtype is incredibly basic. Yes, it needs to be handled in introductory programming courses, and subtle cases can cause real confusion. On the whole, though, it's about like calling a "for" loop a meta-pattern.

Still, some of the OO advice was sound, and still worthwhile today. For example, the "principle of testability" says that a module should be testable independently, without regard to its environment. The whole discussion of frameworks is interesting, but more recent writing is more informative.

The book does discuss design patterns, as we generally use the term now. The DP literature has matured, though, and settled into a fairly predictable way of describing patterns. This book predates those descriptive conventions, so comes across as scattered or hard to read.

I can't fault a book for being written at some particular time. Back in the 90s, I would probably have four stars, maybe more. Literature and common practice have moved on, though. This book's ideas have been developed, extended, and cast in modern terms by more recent writers. Other writings now present the same material, more clearly, and in more current terms.

This book gives an interesting look at the debates and developments that were current back when it was written, but is no longer on, or even near, the wave of current practice.

Rating:
Summary: An excellent book about design pattern
Review: It was a coincidence that I found this book. First I thought - just another book about that topic. But was the book has to give is far more than many other books of this topic do. I think it is at least worth the same as Design Patterns by the gang of four. In my opinion someone should read it before that book. It offers a view from above. I never want to miss it.