Productivity, life cycle cost, and time to market are among the major concerns of developers of complex software, particularly those working on object-oriented software. In fact, “much of the cost and effort stems from the continuous rediscovery of core concepts and components across the software industry” [1]. In this context, object-oriented application frameworks emerge as “a promising technology for reifying proven software design and implementation in order to reduce the cost and improve the quality” [1]. On a more fundamental level, this reflects a paradigm shift from principle-driven design to pattern-driven design.

A framework is the skeleton of an application that can be customized by an application developer. Design patterns, on the other hand, are the micro-architectural elements of frameworks. A pattern describes a problem to be solved, a solution, and the context for that solution. In other words, a design pattern is a conceptual construct that captures what a set of recurring problems have in common.

This book is mainly addressed to Smalltalk programmers who want to write programs as quickly, safely, and effectively as possible. It provides approximately 90 design patterns (in chapters 3 through 7), each of which records an atomic design decision made repeatedly by experienced Smalltalk developers. In chapter 2, the author presents a seven-element meta-pattern for documenting patterns. The elements are title, preceding patterns, problem, forces (constraints), solution, discussion, and the following patterns. The inclusion of the preceding and following patterns in this meta-pattern is a strength of this book, since it establishes a kind of network structure among the different patterns.

Chapters 3 and 4 are devoted to the patterns used in describing the two aspects of any object model, namely, behavior and state. In chapter 3, the author presents 30 patterns that describe the behavior of a system of objects. The state of each individual object, as described by instant variables and temporary variables, is presented in chapter 4, by means of 20 patterns. As the collection hierarchy is one of the strengths of Smalltalk, the author presents 27 collection design patterns in chapter 5. These patterns cover collection classes, the major message patterns that can be sent to them, and some standard tricks that are frequently used by experienced Smalltalk programmers. In chapter 6, Beck explains how to choose meaningful and communicative class names, and presents two design patterns. Finally, believing in the importance of formatting for the review and transfer of code, the author devotes chapter 7 to formatting patterns. He encapsulates his experience into ten patterns that cover topics such as formatting message patterns, calling message parameters, the indentation of messages, and formatting blocks.

One of the best features of this book is the illustration of how to use 25 of the previously defined patterns in developing a system for handling money in several currencies (presented in chapter 8). Appendix A provides a useful quick reference. Smalltalk programmers will find a collection of ready-to-use Smalltalk design patterns in this book.