countdown boutiques-francophones Learn more vpcflyout Pets All-New Kindle Music Deals Store sports Tools Registry

Customer Reviews

4.5 out of 5 stars
4.5 out of 5 stars
Format: Paperback|Change
Price:$60.04+ Free shipping with Amazon Prime
Your rating(Clear)Rate this item

There was a problem filtering reviews right now. Please try again later.

on July 23, 2002
This book is a must-read for any serious C++ programmer. Why? Because it is the only decent treatment of physical C++ design available.
Physical design issues, if not addressed, will inexorably cripple any sufficiently complex, performance-sensitive C++ project. Moreover, there is never any time to worry about physical design quality in the heat of battle, so you really need to deal with it up front.
Having said that, the book is not without its flaws.
First, the age of the text is evident. It doesn't address the interchangeability of typedefs and classes for certain purposes, it doesn't fully appreciate the power of namespaces, and it is rife with "the World didn't go that way" conventions. Fortunately, this doesn't prevent the book from getting its point across, but you do need to take some of its "rules" with a grain of salt.
Second, it's longer than it needs to be. This isn't so much of a liability, because it reads faster as a result. Still, its redundancy and long-windedness is sometimes tedious.
But all in all, if you've bothered to read this review, then you probably ought to own a copy of this book.
0Comment| 5 people found this helpful. Was this review helpful to you?YesNoReport abuse
on October 28, 2001
I suppose this is the only book of its kind --- the physical C++ design kind, as oppose to conceptual C++ design. The author and gang have been writing large-scale C++ software with millions of lines of code, I imagine. Along the way, they were bound to swallow lessons that we haven't, couldn't be bothered, or perhaps never will get to learn. Imagine what it takes to build a 2000-story skyscraper. To begin with, that building probably needs one heaven of a solid foundation. And this book is heavy on fundamentals all right. Honestly, it must have had one heaven load of principles and design rules.
This book teaches clean C++. Very clean. Well applied, pointers from this book make people who maintain your code smile. And we all know that could very well be yourself.
Most of those goodies apply to small projects as well, I (ahem!) agree with the author. After all, heck, if I can't write a 500-line program well, I wouldn't hire myself to write a 20,000-line program.
Would you?
0Comment|Was this review helpful to you?YesNoReport abuse
on June 12, 2001
This comprehensive reference covers all aspects of physical design in C++. The material is relevant to all C++ projects however the effects of poor physical design are amplified in large-scale projects. John Lakos illustrates how to eliminate cyclical dependencies, excessive link-time dependencies, and excessive compile-tine dependencies. Provides guidance for organizing the content of header files. Covers components, physical hierarchy, levelization, encapsulation, insulation, and packages. As a bonus the author includes an excellent essay on designing a function interface specification including the following tradeoffs: operator or non-operator function, free or member operator, virtual or non-virtual function, pure or non-pure virtual member function, static or non-static member function, const or non-const member function, public, protected, or private member function, return by value, reference, or pointer, return const or non-const, friend or non-friend function, and inline or non-inline function. Includes a dependency extractor/analyzer package in appendix C.
0Comment|Was this review helpful to you?YesNoReport abuse
on March 19, 2001
The complexity of developing large scale programming projects is rarely addressed in computer science texts. I find most books are written from an academic perspective that rarely addresses what "should be done" rather than what "could be done". As a systems integration professional, I found this book to be one of the few useful books that address the difference between a single person coding effort and a large scale development project.
The book is organized in three major parts. "Part I - The Basics" covers language details, common design patterns, style conventions used in the book and the fundamental design practices to be used in every C++ project. The next two sections cover the real "meat" of the information. "Part II - Physical Design Concepts" covers components, physical heirarchy, levelization, insulation and packages. The techniques in this section are designed to improved testability, reduce compile time and improve version control/configuration management. "Part III - Logical Design Issues" addresses the marriage of solid physical design with key design/architectural issues.
The book is well written and easy to follow. Logical concepts are introduced with relevant diagrams and then made tangible with actual code. I have used this book on three projects and it has helped my technical leads in every case.
0Comment|Was this review helpful to you?YesNoReport abuse
on March 25, 1999
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.
0Comment|Was this review helpful to you?YesNoReport abuse
on April 14, 2000
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.
0Comment|Was this review helpful to you?YesNoReport abuse
on February 9, 2000
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.
0Comment|Was this review helpful to you?YesNoReport abuse
on July 31, 2000
Though over 800 pages, it is very easy to read book. I think the presentation is well organized. All the major points are outlined clearly. following the charts, tables,graphes and sources, one can get essence of phyicial design immediately. (sometime I feel funny about all the definitions given by Mr.Lakos, they're too trivial to occupy some space as principals.) PartII on physical design concept is very useful for guys that already read effective c++, design patterns etc, which mostly dwell on logicial design issues. It's a thrill when I read them fisrt time as other oop classics. I think the part III on logical design is a mistake. There are lots of very good books teaching us how to write functions, oragnizing interfaces. I learned very little from those 200+ pages.
0Comment|Was this review helpful to you?YesNoReport abuse
on February 17, 1999
The book offers a lot of tips early on explaining ways to avoid keeping everything in the headers to permit changes to occur without forcing a load of code to recompile.
My problem was that to avoid this recompilation the code has to get very confusing in hiding methods and variables.
I'm halfway through the book and a reread will definitely be required, but I guess all good things come at a cost. And when he is referring to large he is referring to applications which take multiple hours to compile. Smaller apps probably won't benefit as much.
The tips also lead towards saving time during the building/compiling stage while sacraficing application speed.
It's best point is that it brings up development issues which often get overlooked.
0Comment|Was this review helpful to you?YesNoReport abuse
on November 30, 1998
I'm a single developer of about eight years who used to go around thinking that, being alone, the systems I write will always be small, and the interfaces between packages can be casual since I own both ends. Boy was I wrong! Lakos' book is the direct answer to the most persistent problems I've had with quality, maintainability and extensibility for the last year.
Even if you're a C++ genius, I'll bet the section on how redundancy (as in duplicated code) may be desirable will teach you something you didn't realize you needed to learn. And, the extensive coverage of physical insulation shows the path away from the dark side of development that logical design texts hardly even allude to. Read this book!
0Comment|Was this review helpful to you?YesNoReport abuse

Customers also viewed these items