Books : reviews

Erich Gamma, Richard Helm, Ralph E. Johnson, John Vlissides.
Design Patterns: elements of reusable object-oriented software.
Addison Wesley. 1995

rating : 2 : great stuff

This was one of the first, and is still one of the best, books to take Christopher Alexander's ideas of a Pattern Language from architecture, and apply it to object oriented software design.

The book has a large introductory motivational example of how to use patterns in software design: the case study is that old chestnut, a text editor, brought to life by the skillful writing and innovative way of describing the design.

The bulk of the book is a Pattern Catalogue, documenting 23 creational, structural, and behavioural patterns. A beauty of Alexander's Pattern Language is that it provides a truely useful documentation structure, including the problem solved by the pattern, the solution itself, and the consequences and trade-offs of using the pattern.

Design Patterns is a must for the reference library of any software designer (object oriented or not). The range of patterns gives a new vocabulary for expressing designs, and a ready-made set of solutions to standard design problems.

1998: I added an (unlimited) 'undo' capability from scratch to the Formaliser structure editor, by instantiating one of the Patterns from this book. I was amazed that it took me less than two days: a testament both to the value of Patterns, and the productivity of Smalltalk.

John Vlissides, James O. Coplien, Norman L. Kerth, eds.
Pattern Languages of Program Design 2.
Addison Wesley. 1996

The patterns presented are grouped into: • General-Purpose Patterns • Special-Purpose Patterns • Architectural Patterns • Process and Organization • Exposition • Concurrent Programming/Distributed Systems • Reactive Systems


Tom Cargill. Localized ownership: managing dynamic objects in C++. 1996
Ken Auer, Kent Beck. Lazy optimization: patterns for efficient Smalltalk programming. 1996
Bobby Woolf. Partitioning Smalltalk code in ENVY/Developer components. 1996
Peter Sommerlad. Command Processor. 1996
Jung J. Kim, Kevin M. Benner. Implementation patterns for the Observer pattern. 1996
Dirk Riehle. Patterns for encapsulating class trees. 1996
Hans Rohnert. The Proxy design pattern revisited. 1996
Alexander S. Ran. MOODS: Models for Object-Oriented Design of State. 1996
Jim Doble. Shopper. 1996
Aamond Sane, Roy Campbell. Detachable Inspector/Removable cout: a structural pattern for designing transparent layered services. 1996
Gustavo Rossi, Alejandra Garrido, Sergio Carvalho. Design patterns for object-oriented hypermedia applications. 1996
Stephen P. Berczuk. Organizational Multiplexing: patterns for processing satellite telemetry with distributed teams. 1996
Satish Subramanian, Wei-Tek Tsai. Backup pattern: designing redundancy in object-oriented software. 1996
Kyle Brown, Bruce G. Whitenack. Crossing Chasms: a pattern language for Object-RDBMS. 1996
Ralph E. Johnson. Transactions and Accounts. 1996
Mary Shaw. Some patterns for software architectures. 1996
Frank Buschmann. Reflection. 1996
Brian Foote, Joseph Yoder. Evolution, Architecture, and Metamorphosis. 1996
Alistair Cockburn. Prioritizing forces in software design. 1996
Allen Hopley. Decision deferral and capture pattern language. 1996
Neil B. Harrison. Organizational patterns for teams. 1996
Martin Fowler. Accountability and organizational structures. 1996
Ward Cunningham. EPISODES: a pattern language of competitive development. 1996
Dana L. G. Anthony. Patterns for classroom education. 1996
Todd A. Coram. Demo Prep: a pattern language for the preparation of software demonstrations. 1996
Robert Orenstein. A pattern language for an essay-based web site. 1996
Douglas C. Schmidt, Charles D. Cranor. Half-Sync/Half-Async: an architectural pattern for efficient and well-structured concurrent I/O. 1996
Aamond Sane, Roy Campbell. Resource Exchanger: a behavioral pattern for low-overhead concurrent resource management. 1996
Peter Sommerlad, Michael Stal. The Client-Dispatch-Server design pattern. 1996
R. Greg Lavender, Douglas C. Schmidt. Active Object: an object behavioral pattern for concurrent programming. 1996
Paul E. McKenney. Selecting locking designs for parallel programs. 1996
Amund Aarsten, Giuseppe Menga, Luca Mosconi. Object-oriented design patterns in reactive systems. 1996
Michael (2) Adams, James O. Coplien, Robert Gamoke, Robert Hanmer, Fred Keeve, Keith Nicodemus. Fault-tolerant telecommunication system patterns. 1996
William C. Wake, B. Douglas Wake, Edward A. Fox. Improving responsiveness in interactive applications using queues. 1996
Gerard Meszaros. A pattern language for improving the capacity of reactive systems. 1996

John Vlissides.
Pattern Hatching: design patterns applied.
Addison Wesley. 1998

rating : 3.5 : worth reading
review : 29 July 2000

This slim book, by one of the original Gang of Four, is based on Vlissides' column in the C++ Report. It is not just a straight republication of those columns: the material has been reworked into a structure more appropriate for a book, and some additional thoughts and discussions have been added. Given its origin, it is necessarily very C++ oriented.

It starts out with a summary of what Patterns are and are not, in an attempt to defuse some of the hype, and back-lash cynicism, that patterns have attracted. Then we get a "tutorial" chapter, showing how to design a file system with patterns. This nicely complements the first part of the original Design Patterns, with its longer tutorial on using patterns to design an editor.

The next chapter discusses some variations on, and problems with, existing patterns, and introduces a great new pattern, GENERATION GAP. This is a pattern for separating automatically generated code from user modifications to it, so that those user mods do not get trashed whenever the code is regenerated.

Then we get an historical account of the discussions over whether type-safe MULTICAST is a pattern in its own right, or merely a specialisation of OBSERVER. [Given the observation that each can be viewed as a refinement of the other under the right circumstances, I wonder if they are in fact both refinements of some yet more abstract pattern.] It is resolved by introducing the TYPED MESSAGE pattern, to be used with OBSERVER when needed. [Although, being a Smalltalker myself, I was left somewhat sympathising with the complaints of the Smalltalking member of the GoF that a lot of this seems to be merely fighting with C++'s strong typing.]

This leads into the beginning of an interesting discussion about how patterns scale and relate to one another. The original patterns were designed to be as orthogonal as possible -- but are there cases where some patterns, real in their own right, are nevertheless "merely" refinements of others? Patterns are needed because the class is not a large enough unit of abstraction to describe architectures. Now it seems that, as patterns are more widely used, some of their own scaling problems are becoming apparent. But we shouldn't be surprised by this: in the real world new levels of complexity produce new kinds of structuring -- and we shouldn't expect to be able to invent one structuring mechanism to be the answer to everything.

Pattern Hatching makes an interesting adjunct to the original Design Patterns.