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