Large-Scale C++ Software Design

by John Lakos

Publisher: Addison-Wesley Professional
ISBN: 0201633620

Check price @ amazon.com , amazon.ca , amazon.co.uk

Book Description

Developing a large-scale software system in C++ requires more than just a sound understanding of the logical design issues covered in most books on C++ programming. To be successful, you will also need a grasp of physical design concepts that, while closely tied to the technical aspects of development, include a dimension with which even expert software developers may have little or no experience.

This is the definitive book for all C++ software professionals involved in large development efforts such as databases, operating systems, compilers, and frameworks. It is the first C++ book that actually demonstrates how to design large systems, and one of the few books on object-oriented design specifically geared to practical aspects of the C++ programming language.

In this book, Lakos explains the process of decomposing large systems into physical (not inheritance) hierarchies of smaller, more manageable components. Such systems with their acyclic physical dependencies are fundamentally easier and more economical to maintain, test, and reuse than tightly interdependent systems. In addition to explaining the motivation for following good physical as well as logical design practices, Lakos provides you with a catalog of specific techniques designed to eliminate cyclic, compile-time, and link-time (physical) dependencies. He then extends these concepts from large to very large systems.

The book concludes with a comprehensive top-down approach to the logical design of individual components. Appendices include a valuable design pattern "Protocol Hierarchy" designed to avoid fat interfaces while minimizing physical dependencies; the details of implementing an ANSI C compatible C++ procedural interface; and a complete specification for a suite of UNIX-like tools to extract and analyze physical dependencies. Practical design rules, guidelines, and principles are also collected in an appendix and indexed for quick reference.

About the Author

John Lakos works at Mentor Graphics, a company that has written more large scale C++ programs than most other software companies and was among the first companies to attempt truly large-scale C++ projects. Lakos has been programming professionally in C++ since 1987, and in 1990 developed Columbia University's graduate course in object-oriented programming which he continues to teach.

Customer Reviews

This book is full of advise that comes from actual experience in implementing C++ projects in the real world. Everything is explained clearly, while going straight to the point. Definitely the best book I've read about Object Oriented Development, and certainly one of the best I've read on design. Definitely a good buy

The material presented is of paramount importance when it comes to design and implementation of software solutions meant to address real-world needs. Even though it focuses primarily on C++, many of the principles apply to any programming language that supports inheritance and interfaces. Without understanding CCD (Cumulative Component Dependency) and other quantitative measures and applying them to architecture design, any software solution may experience increased maintenance cost and degraded reliability (due to difficulty of testing components in isolation). As a matter of fact, we applied many of the measures to develop a framework in Java and build a solution using it, in a 3-tier architecture with browser-based clients. Mr. Lakos indeed deserves high remarks for his excellent and pioneering work.

This book assumes you're already proficient in C++ and basic OOP design principles, and considers design at a level one higher than individual classes. You'll learn how to arrange your classes into modules and packages, and then how to organise communication within and between these higher-level constructs. Nonetheless, the book never forgets that the important thing is working C++ code, not diagrams and acronyms, so it's always practical.

There are two core advantages to the designs discussed in this book: maintaining the correct level of abstraction, and reducing recompilation times. Performance issues always run the risk of becoming outdated fairly quickly, and to a certain extent, some of the timing material is no longer relevant. In particular, Sutter and Alexandrescu, in C++ Coding Standards, explicitly disavow the advocated method of external header guards. Additionally, although namespaces are mentioned, they are not used much, and the older method of using prefixes is recommended instead.

The last part of the book drops down to more low level concerns, such as Schwartz counters, operators, and function arguments. This leans heavily on the likes of Effective C++, C++ Strategy And Tactics and C++ Programming Style, and to be honest, you'd be better off looking in more modern books for up to date best practices. For example, in this book assignment is implemented through the copy-and-destroy idiom, which is nowadays considered to be a mistake.

But this is a big book, and you won't be buying it for the lower-level stuff, but for the large amount of higher level material that makes up the bulk. The main practices and metrics remain extremely relevant, the text is clear and well written. And there just isn't many other places where you can go and read about this sort of stuff. It's a must-read.