(Back Cover Copy)
Introducing the first complete guide to the theory and practice of software design!
Until now it's been hard to find one, complete, up-to-date guide to software design theory and practice.
Not any more! Starting where programming and data structure courses end, this indispensable book is a comprehensive guide to the theory and actual practice of software design.
The book begins at the code level with programming issues such as robustness and flexibility in implementation. As it progresses, it increases in abstraction and scope. After covering these basic issues the book analyzes mid-level design issues, emphasizing a thorough understanding of standard design patterns. This is followed by a thorough discussion of components. Finally, it ends with a high-level issues: architectures, frameworks, and object-oriented analysis and design.
-Numerous design patterns with detailed explanations provide essential tools.
-Extensive discussion of UML (Unlimited Modeling Language) includes many UML samples and exercises.
-Includes coverage of JavaBeans and C++.
-A concise chapter on software process helps readers understand process concepts and the available options.
-Web-based "starter" code for many of the exercises enables readers to learn many more concepts in a hands-on fashion, without having to start every programming exercise from scratch.
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.