Large-Scale C++ Software Design (APC): Amazon.co.uk: John Lakos: Books

Product 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. 0201633620B04062001

From the Back Cover

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.

0201633620B04062001

See all Product Description

Customer Reviews

5 star

4 star

3 star

2 star

1 star

17 reviews

4.8 out of 5 stars

Write a customer review

Most Helpful Customer Reviews

9 of 9 people found the following review helpful

Invaluable for its unique insistence on gritty realism. 25 Mar 1999

By A Customer

Format:Paperback

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.

Comment |

Was this review helpful to you?

Yes

8 of 8 people found the following review helpful

Excellent Reference, Every Professional should read 18 Jan 2002

The vast majority of Programming books follow the latest technology trends - new languages, new products. However a book like this, published five years ago, will be useful for as long as C++ is used for professional software development. I've suffered the pain of worked on multi-million line software projects that don't follow the techniques outlined, and I've converted a medium sized software project to follow the guidelines outlined in the book, and I can confirm that this was one of the most practical computer books I've ever read.

In fact I'd have to say it is more useful and practical than the books of C++ tricks and tips that seem so popular, but focus mainly on intricate details of the language.

Unfortunately it is a heavy read, because Lakos provides the sorts of examples and justifications that you need to "buy in" to his suggestions.
I think the length and indepth nature would intimidate people from reading it. However it is very much worth the effort!

5 of 5 people found the following review helpful

Excellent pragmatic advice for building complex C++ systems 22 Jun 1999

I second much of what has already been said in the previous reviews. This isn't a book for beginners, and its a tough read, but it contains many items that just aren't dealt with in any other book on C++ I've read. The most important point made is that _anything_ appearing in the C++ header file is part of the physical interface, and changing it will affect clients. As with most issues in programming, there's a trade off to be made between efficiency and insulation (and/or simplicity vs. flexibility), which this book tackles well. I certainly feel more confident about sucessfully translating an OOD into a workable C++ framework after reading and ingesting this book. Highly recommended.