Undergraduates who have completed elementary programming courses and professionals who want to deepen their understanding of object-oriented software design and construction in the context of the complete software engineering life cycle are likely to benefit from this work.

The book is divided into four sections: “Software Construction,” “Software Fundamentals,” “Software Design,” and “Software Durability.”

The author sets the scene with a clear statement of the various elements that together make up the software development life cycle. A useful and concise section on models draws attention to their role as a bridge between problem analysis and software synthesis. Although the book explicitly excludes real-time and event handling software, it would have been good to have mentioned in passing that highly automated testing and code generation are possible using models such as those defined by the International Telecommunications Union (ITU) Z.100 family of standards. The chapter also provides a brief presentation of software integration, which is likely to be viewed as obvious and oversimplified by the experienced professional, but is essential undergraduate reading. The relevance and importance of documentation are emphasized.

Next, he addresses abstraction in software development and its importance in constraining complexity and thus facilitating testing and reuse. The role of the unified modeling language and of standards is briefly addressed.

Consideration of control flow in C++ and C# follows. Undergraduates and professionals might be tempted to skip over what look like fairly obvious programming examples, but would do well to pay careful attention to the design considerations that pervade the chapter. For example, the need to balance readability against software performance is reiterated among the examples and could be missed by a reader whose attention is focused on the code samples.

Then we are treated to a great deal of useful material on memory management. Professionals who have experienced the evils of memory leaks will not learn much from this chapter, but undergraduates will benefit enormously from reading it.

A concise review of object-oriented design and the differences between memory management in C++ and C# are covered. This provides context, but a professional wanting to make a transition to object orientation will need to supplement the material presented here with a more detailed text. The sections on programming by contract and object-oriented design principles provide useful abstractions for reasoning about object-oriented software design. These two sections might be better placed as an introductory chapter to section 3, alongside chapters 6 and 7, which, respectively, address structural and behavioral design in object-oriented software systems.

Section 3 comprises three chapters. The role of object-oriented concepts (“has-a,” “holds-a,” and “is-a”) in structural design is presented in chapter 6, and chapter 7 presents inheritance, abstract classes, and polymorphism and their role in behavioral design. A substantial example (a disassembler) illustrates these concepts. Readers are given an unusual and useful opportunity to gain a concrete understanding of these abstract concepts by way of an example of the virtual function table (vtab) generated by the compiler.

The author then addresses the consequences of alternative design choices, including language choice. This provides an invaluable guide to the object-oriented designer who needs to consider the costs and benefits of design alternatives.

Chapter 9 presents exception handling as an integral aspect of software design rather than (as some developers mistakenly perceive) an optional afterthought. A concise summary of test design addresses security, compatibility, and compliance, as well as load and stress testing. This is likely to form a useful starting point for a detailed study of more specialized texts.

The book concludes with post-deployment aspects of the software life cycle, including evolution, refactoring, and re-engineering. Technological change and evolving nonfunctional requirements are presented as drivers of software evolution. Specific refactoring techniques are presented, as are some strategies for reverse engineering. The book includes a useful glossary and four appendices, deepening and reinforcing coverage of pointers, memory management, virtual functions, and operator overloading, which are important concepts that frequently challenge professional developers and undergraduates alike.

Other useful features include the design insights and conceptual questions presented at the end of each chapter. Overall, the book achieves a good balance between breadth of coverage and detailed presentation of specific techniques. It provides both a useful starting point for a detailed study of specific software design and construction techniques from other texts and a broad context within which prior knowledge of software engineering techniques can be integrated.

More reviews about this item: Amazon, Goodreads