Review By: Harmon Avera Jr.
02/16/2004This is a textbook aimed at computer science students who are ready to move past programming languages and data structures to study the design phase of software development at increasingly abstract levels. It is about 550 pages long and uses a conversational writing style that is clear and easy to read, with plenty of figures and diagrams to illustrate the concepts presented.

There are fourteen chapters divided into four major sections that follow a standard textbook pattern of introduction, material presentation, summary, and follow-up exercises. Where applicable, there are also code listings for examples developed in the chapter.

Section 1 (Design Principles/Code-level Design) introduces the author's overall design principles of correctness, flexibility, reusability, efficiency, and robustness. The author reviews the timing and placement of design in the overall software development “waterfall” process model. This section also introduces the concept of object orientation, the UML, and presents elements of code-level design.

Section 2 (Design Patterns) is the largest section. Here, Braude reviews the major design patterns developed by Gamma et al., grouped into creational, structural, and behavioral patterns. The author makes heavy use of UML diagrams, as well as text, to describe the pattern’s features and design goals. In addition to defining each pattern, he gives scenarios showing how the pattern both solves a design problem and satisfies one or more of his basic design principles.

Section 3 (Components) introduces the idea of using objects and groups of objects as software “parts” that can be assembled into applications. Braude uses examples from both Sun's Java-bean and Microsoft's .NET environment to illustrate standard component features such as properties, methods, events, manifests, and introspection (metadata). He also discusses the phases of component lifetimes including design/implementation, assembly, deployment, and use.

Section 4 (Object Oriented Analysis/Design) briefly covers requirements and object-oriented analysis, finishing up with a chapter on software architectures and frameworks.

This is a book about software design, everything from designing subroutines to system architectures. There are good discussions of the trade-offs between design goals. (The most efficient design may be too specific to be reused in other applications, e.g.) Braude reviews the pros and cons of just-enough design (Extreme Programming) versus more heavyweight, flexibility-driven design, clearly preferring the latter.

My favorite part, though, is Section 2 (Design Patterns). Perhaps because this is a textbook aimed at students, Braude’s presentation of design patterns is much more approachable than Design Patterns (Gamma et al) or Applying UML and Patterns (Larman). Chapter six gives the best synopsis I've seen of individual patterns within each pattern group, showing the pattern name, design purpose(s) satisfied by the pattern (with examples), and a text summary of the pattern.

At the component level, the chapter on Microsoft’s .NET architecture and assemblies provides a balanced overview of .NET design goals and implementation for comparison with the more familiar (to me) Java-bean based components. I had only a couple of quibbles – there were several typos and the figures (mainly text bullets) are interspersed within the chapter text, which sometimes make it visually hard to follow.

Although this book is not about testing or software quality per se, I thought it was a great book, enjoyed reading it, and would recommend it highly.