author : John Vlissides

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.

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

Contents

• 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

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.