Large-Scale C++ Software Design

by John S. Lakos and John S. Lakos

Book Overview

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.

• Format: Paperback
• Language: English
• ISBN: 0201633620
• ISBN13: 9780201633627
• Release Date: July 1996
• Publisher: Addison-Wesley Professional
• Length: 896 Pages
• Weight: 2.93 lbs.
• Dimensions: 1.3" x 7.5" x 9.2"

Customer Reviews

The Best Computer Science Book I've Ever Read - Period

I read this book back in 1998. It is the foundation for my understanding of the design of object oriented software. Prior to reading this book I programmed in C++ for more than 8 years. It was apparent to me that there were gaps in my understanding of how to design medium and large scale object oriented systems. This is a huge and dense book, but as I read through it, many times a light went on in my head (those ah ha moments). The book also gives specific details about consideration for the C++ language. C++ has changed over the years, and the examples do not use newer language features. I do not feel that this is important. The code clearly illustrates the ideas, which are not limited by the state of C++ at the time the code was written. Regardless of the object oriented language you use to develop software this book will teach invaluable concepts that I have not found explained elsewhere.

Excellent book covering important but rare ropics

After having this book reccomended to me a number of times by various people, I decided to check it out. It is an excellent primer on how to design reusable classes in C++. It discusses a number of aspects of programming we tend to ignore, like the difference between logical and physical design. Anyone who wishes to write reusable, stable software in C++ should read this book.I have one criticism, though, and that is that I believe the book is poorly organized. Although each individual peice of information in the book is useful and well thought out, I found that I wished he would cover things in a more natural order. Often I would read something and have to go back and reconcile it with what had been said earlier in the book, which was sometimes difficult. Don't let this criticism stop you from reading, however.

Excellent and still one of the best

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.

Invaluable for its unique insistence on gritty realism.

Have you ever noticed that none of your introductions to C++ ever mention things like header files? This book corrects that omission with a vengeance, taking us deep into the nuts and bolts of real software. It describes things no other book is going to mention (e.g. redundant external include guards, or static nonmember functions to replace private members) and things the object-oriented community prefers to be silent about (e.g., encapsulation in files, not in classes).Lakos's great strength is in pragmatics; this is advice on programming from someone who has been there. If your project is large enough to need source code control, it's large enough to need this book.Sometimes the book drifts away from its roots, assuming a dragging academic tone. However, this does not change the overall rating -- a book with no substitutes.

a 'should read' for every programmer.

This book contains a lot of good hints for things to think about and mistakes to avoid in designing and/or coding a large software projekt. John Lakos hints are very well documented and argumented, they are not just like 'make this, do that'. I really recommend this book to everyone programming something larger than 'Hello World'. Sometimes J. Lakos tends to get a bit long winded when getting to something he thinks is important, but the book is still easy to read and very good to understand.