Excellent book on the physical architecture of C++ applications

books:


	• Large-Scale C++ Software Design (Addison-Wesley Professional Computing Series) John Lakos Addison-Wesley Professional, 1996 - 896 pages average customer review:based on 31 reviews view larger image
	for more information click here

highly recommended

wonderful book

This is a superb book on software design. While clearly intended for those working on large-scale projects with a broad base of users, the principles discussed are rock solid for even the smallest project. It illustrates a higher level of C++ where objects are not just used because they can represent complex concepts nicely but because proper object-orientation is insurance against many coding evils - exactly the evils which can sabotage large-scale software projects.

Large-Scale C++ Software Design. Mind the C++ !

I have to admit, this book is nothing like I thought it would be. It has more C++ than anything else. It is not "large-scale software design with few examples in C++", no sir, it is "design of large-scale software specifically in C++" !

Although not all of the ideas are restricted to C++, many of them do and the book is full of C++ code. Since I haven't done active C++ development for a while (currently digging into Python), it was rather difficult to read.

In a single sentence, the book is about modularization techniques in C++. The purposes of such modularization are different, from speeding up the build process, having the program better understood or refactored, to allowing modular testing or reusing code. And the techniques are different in each case too.

But it is all in C++. Friendship, inlining, const-correctness, abstract interfaces, .cpp and .h file naming, private/protected/public members and/or inheritance, pimpl idiom, initialization of static objects, signed vs. unsigned, that sort of thing. All this has rather limited usability unless you are practicing serious C++ right now.

Again, many of the ideas behind do apply universally, but it is difficult to find them in the thick of C++. I have found a few interesting new ideas, but I have also skimmed over many chapters because it looked too C++-ish to read through.

Worth noticing is that the book is dated (1996) and therefore does not cover such essential C++ features as namespaces and templates.

Only if you are doing serious C++ development. Then it would be great.

for more information click here

Excellent book on the physical architecture of C++ applications

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.

for more information click here

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.

for more information click here

The one and only book covering physical design

I'll start with some negative points. Due to the age of this book, much of the example code is out ot date. In particular, no bool and namespaces. This means that the advice about not polluting the global namespace, and to use structs with static members instead ought to now be advice to use namespaces. There's little on the standard library. Coverage of templates (and their potential for code bloat and link time explosion) isn't great. Another issue is the enormous improvement in computer performance since this book was written. At the time, 100MHz single core subscalar CPUs were the order of the day. Now we have 2-3GHz multicore superscalar CPUs that are of the order of 1000 times faster. What sould have taken a week to build would now take.

Some of the terminoligy used doesn't match that which I'm used to. For instance, I would tend to use composition and aggregation where Lakos uses HasA and HoldsA. I don't agree with what he calls internal linkage - basically it is everything that is not extrnal linkage. I'd add a third category, no linkage (e.g., macros, typedefs).

Now some more positive comments. Part II is good stuff. There is a lot of detail on why components can become dependent, and ways of breaking those dependencies. He also explains quite well the disadvantages to such insulation (generally more code and/or slower). Unfortunately, I'm not aware of any easily available tools that generate the metrics that Lakos uses. Without such tools, you either have to perform lengthy analysis (or develop your own tool), or just guess roughly the state of your own system. The end of Part II goes off the boil a bit. Packages are just bigger components, and what is true for packages is also true for components. This leads to a bit of repetition. The section on startup issues is a bit fuzzy as to whether it is a logical design issue or a physical one.

Part III is good enough, but a bit off topic I feel (again getting to logical design, whilst I think the book should have stayed more with physical design). Again, there are a few things that I don't entirely agree with. For instance, advice is given to be 'const correct' [good idea in my opinion], but to only use 'int' and to avoid unsigned types. My opinion on this is that just as you should be 'const correct', then you should also be 'sign correct'. You will have a hard time using just int in real C++ code. size_t is unsigned on all of the platforms that I know, and this is the type of sizeof, the dimension of arrays, returned by strlen and so on.

for more information click here

reviews: page 1, 2, 3, 4, 5, 6, 7

hot