Large-Scale C++ Software Design View Larger Image | John Lakos
Addison-Wesley, Paperback, Published July 1996, 896 pages, ISBN 0201633620 | List Price: $64.99
Our Price: $50.50
You Save: $14.49 (22% Off)
| | | Availability: Out-Of-Stock |
Customer Reviews: 1 Average Customer Rating:  Write a Review and tell the world about this title! People who purchase this book frequently purchase: - Modern C++ Design; Andrei Alexandrescu, $46.50, 22% Off!
- The C++ Standard Library: A Tutorial and Reference; Nicolai M. Josuttis, $57.95, 23% Off!
- C++ Templates: The Complete Guide; David Vandevoorde, et al, $57.95, 23% Off!
- Exceptional C++ Style: 40 New Engineering Puzzles, Programming Problems, and Solutions; Herb Sutter, $34.95, 22% Off!
Books on similar topics, in best-seller order:Books from the same publisher, in best-seller order:
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.
Table of Contents
Preface.
0. Introduction.
From C to C++.
Using C++ to Develop Large Projects.
Reuse.
Quality.
Software Development Tools.
Summary.
I. BASICS.
1. Preliminaries.
Multi-File C++ Programs.
typedef Declarations.
Assert Statements.
A Few Matters of Style.
Iterators.
Logical Design Notation.
Inheritance versus Layering.
Minimality.
Summary.
Overview.
Member Data Access.
The Global Name Space.
Include Guards.
Redundant Include Guards.
Documentation.
Identifier-Naming Conventions.
Summary.
II. PHYSICAL DESIGN CONCEPTS.
3. Components.
Components versus Classes.
Physical Design Rules.
The DependsOn Relation.
Implied Dependency.
Extracting Actual Dependencies.
Friendship.
Summary.
A Metaphor for Software Testing.
A Complex Subsystem.
The Difficulty in Testing “Good” Interfaces.
Design for Testability.
Testing in Isolation.
Acyclic Physical Dependencies.
Level Numbers.
Hierarchical and Incremental Testing.
Testing a Complex Subsystem.
Testing versus Tested.
Cyclic Physical Dependencies.
Cumulative Component Dependency (CCD).
Physical Design Quality.
Summary.
Some Causes of Cyclic Physical Dependencies.
Escalation.
Demotion.
Opaque Pointers.
Dumb Data.
Redundancy.
Callbacks.
Manager Class.
Factoring.
Escalating Encapsulation.
Summary.
From Encapsulation to Insulation.
C++ Constructs and Compile-Time Coupling.
Partial Insulation Techniques.
Total Insulation Techniques.
The Procedural Interface.
To Insulate or Not to Insulate.
Summary.
From Components to Packages.
Registered Package Prefixes.
Package Levelization.
Package Insulation.
Package Groups.
The Release Process.
The main Program.
Start-Up Time.
Summary.
III. LOGICAL DESIGN ISSUES.
8. Architecting a Component.
Abstractions and Components.
Component Interface Design.
Degrees of Encapsulation.
Auxiliary Implementation Classes.
Summary.
Function Specification.
Fundamental Types Used in the Interface.
Special Case Functions.
Summary.
10. Implementing an Object.
Member Data.
Function Definitions.
Memory Management.
Using C++ Templates in Large Projects.
Summary.
Appendix A. Protocol Hierarchy.
Appendix B. Implementing an ANSI C-Compatible
C++ Interface.
Appendix C. A Dependency Extractor/Analyzer
Package.
Appendix D. Quick Reference.
Index.
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
Customer Reviews: 1 Average Customer Rating: Jun 12, 2001 James Olson from Chicago, IL
Excellent Treatment
Superb treatment of the physical aspects of C++ software design, i.e. how to modularize code and reduce both compile time and link time interdependencies so that compile and link times are kept reasonable. Without these techniques C++ projects can easily suffer from exponentially increasing build times as code evolves. For example, doing
#ifndef _INCLUDED_HEADER_H
#define _INCLUDED_HEADER_H
#include header.h
#endif
can dramatically help in compilation times especially if network traffic is involved. Also how to design modules hierarchically to reduce circular dependencies and thereby make code more testable. Mr. Lakos also includes the best discussion I've seen on when to define functions in the header or source file, when to make them private, protected, public, when to use friendship, and other valuable insights that are systematically exposed (Chapter 9). Going back to read Stroustrup after this book is a lot easier, as the latter assumes an understanding of these issues in his book. Lakos also provides code that can be downloaded and built to analyze dependencies in your own code.
|
