Modern C++ Design: Generic Programming and Design Patterns Applied

Rating:
Summary: I thought STL is all that templates can do!
Review: I liked the book from both perspectives: style and content

The book is very well written, in a vivacious and logical style. The eventual questions raised in one paragraph are answered in the following ones, so every chapter gave me a very clear understanding of the concept the author wanted to present. The chapters succeed smoothly and in a logical order.

The content is amazing; I would dare to call it a revolutionary book because it showed that the designs patterns can be actually implemented without loosing their generality. Before reading the book I lived with the idea that once you begin talking about code, that was it, it was the end, it meant that a design solution was chosen and now it is implemented and nothing follows. No, here the implementation, the code Andrei wrote and explained to us, still remains in the design area because it gives the user the option to model and transform the concept, at compile time, the way he\she needs.

I warmly recommend the book to any C++ programmer interested to explore the big potential of templates, but also as a rich source of ideas, and reusable code.

Rating:
Summary: Cool book
Review: This book sets a new standard for library development in C++. A refreshing read, Modern C++ Design fills an empty space that's between theoretical stuff such as generic programming or design patterns, and the real world. The author can explain complex design-related issues and equally complex C++ implementation details with remarkable ease.

Although the book builds heavily on Design Patterns, you don't need to read the GoF book first, though some prior exposure to design patterns helps. My only complaint is about typos - they don't affect understandability but can be annoying at times.

I recommend this book to any C++ programmer who wants to become a system or library designer.

Rating:
Summary: Taking C++ to the next level
Review: Even after the C++ Standard was published, I thought no significant work on C++ can be possible beyond the STL. Modern C++ Design changed my view on C++ forever. The author uses C++ in a metalinguistic manner to implement not specific designs, but to treat the design process in and by itself. For example, in treating a specific design pattern such as Singleton he doesn't make design decisions. Instead, he provides you with a framework that lets you choose and combine various design decisions. Modern C++ Design is a book on "designing designs" in C++.

I also like the completeness of the work; instead of broad and shallow, the author chose a narrow and deep "no nonsense" approach. Thus, the chapters on Command, Factory, Singleton, Smart Pointers, Visitor, Multiple Dispatch, really tell the first to last word on their respective subjects in the C++ implementation context.

A truly inspirational breakthrough on implementing designs with C++, the book is an instant classic. Highly recommended to anyone who wants to be a C++ expert.

Rating:
Summary: An important book for thoughtful programmers
Review: Rob Pike once said: "Narrowness in experience leads to narrowness in imagination." Andrei's book astonishes me every other page I read, showing me how to do things I couldn't even imagine were possible in C++. Did I know it was possible to assert on a condition evaluated at compile time, similar to what I used to do at run-time? Pass a list of types as an argument to a function? Customize the storage, conversion, and checking policies of a smart pointer class? Not only I found out they were attainable, but I have learned how to combine and use them to create more flexible powerful abstractions, such as memory allocators, callable entities, dispatch engines, object and class factories. This book nicely fills in a gap between the books comprehensively covering language features and standard library components and those addressing elements of software design. The techniques presented in the book are techniques that scale well and can be used in large software systems. Actually, the larger the system, the better the reusable components described in the book can be used, and the greater the benefits. As the compilers' support for the C++ standard constantly improves with each new release, I expect these components to become portable soon. Even though the presentation has some problems (typos, style, and using a constant-width font for the code snippets), I find the reading of this book to be quite relaxing and enjoyable. If I recommend it? Definitely! I'm cutting my teeth on it...

Rating:
Summary: Too far from reallity
Review: Generally I think the book is a little bit overrated. Sure the author is a C++ Guru. No doupt. And if you have the opportunity to develop applications on machines with the appropriate C++ compilers the source code of the book needs, then it is maybe one of the best choices to buy an advanced C++ book like this one. But if you don't, like me, then you will be pretty disapointed (besides the very many typos). We have to develop the same applications for many different machines and opperating systems, so that you will be pretty frustrating to have such interesting stuff like described in the book, but you will never be able to use it. And I am not talking about old systems. In the REAL world (not academic) least software developers will be able to use the code (LOKI) described in this book. -- SO BE AWARE OF THESE FACTS --. Adding to mey frustation is, that there is NO ERRATA on the books homepage AND that the author didn't realy talk about the above mentioned problems. My conclusion - NICE THEORY, but nothing for real software development. THEORY, because until we will have access to C++ compilers handling the code in the book (and the amazing stuff he does with templates) C++ will be wiped out with all its inadequatenesses by other languages and designs :-) .

Rating:
Summary: Templates are for containers only?
Review: This book changed my look on templates. I thought I'd use them only for containers... This bool explains advanced template techniques that allow You to customize you software by using templates ( and therefore in a very runtime efficient way ). I would give it a 'must read' even if you do not use templates because it also helps you understand how a C++ compiler sees the world. Be aware however that not all compilers can compile and run the samples ( and the Loki ) library ( M$VC 6.0 can't ).

The quality may not be up to where we excpect it from AW, but don't let that keep you away from this book. If something does not work or fails, call on comp.lang.c++.moderated, mostly the author himself will answer questions.

Rating:
Summary: An instant classic
Review: This is a concise but very informative book about the powerful features of C++ and how to use them. This book covers some of the same areas as the "Generative Programming" book, and then some. In particular, the chapter on Typelists provides a powerful demonstration of the compile-time functional programming style afforded by the C++ template system. There is also an extensive coverage of how to implement some of the classic GoF patterns -- Command, Singleton, Factory, AbstractFactory, Visitor -- and, more importantly, covers the various trade-offs involved. Finally, it demonstrates the power of Policy-based template classes in expressing these trade-offs in code.

Being a conscientious reviewer, let me also point ot a few problems. It is somewhat startling that Addison-Wesley has done such a bad job about producing such an useful book. There definitely is a feel that the book has been rushed to print. There are many obvious errors that any competent copy-editor would have caught and fixed. Typos abound. Names are inconsistent -- for example in one paragraph the same class is called both 'Singleton' and 'SingletonHolder'. The flow is sometimes somewhat jarring -- for example, in the discussion about smart pointers, and using the 'SmartPtr<...> sp; if (sp)' construct -- one paragraph essentially says there's no safe way to do this, "end of story", and then immediately after that presents a technique to implement this, as far as I could make out, safely. Another small distraction is that the fixed-width font used for presenting the code uses a 'fi' ligature (i.e., the two letters 'fi' take up the space of one letter) -- a simple error that should have been caught. All these make the reading experience somewhat less pleasant than it should be.

However, these detract little from my overall opinion of the book. This book belongs on your bookshelf.

Rating:
Summary: practical and powerful techniques elucidated
Review: This books exemplifies many practical techniques to fully utilize the power of c++ templates. When combined with other language facilities, they make creating flexible and extensible application easier. After finishing the book, you gotta wonder what other wonderful and creative things c++ templates can do.

Rating:
Summary: An important book for thoughtful programmers
Review: Rob Pike once said: "Narrowness in experience leads to narrowness in imagination." Andrei's book astonishes me every other page I read, showing me how to do things I couldn't even imagine were possible in C++. Did I know it was possible to assert on a condition evaluated at compile time, similar to what I used to do at run-time? Pass a list of types as an argument to a function? Customize the storage, conversion, and checking policies of a smart pointer class? Not only I found out they were attainable, but I have learned how to combine and use them to create more flexible powerful abstractions, such as memory allocators, callable entities, dispatch engines, object and class factories. This book nicely fills in a gap between the books comprehensively covering language features and standard library components and those addressing elements of software design. The techniques presented in the book are techniques that scale well and can be used in large software systems. Actually, the larger the system, the better the reusable components described in the book can be used, and the greater the benefits. As the compilers' support for the C++ standard constantly improves with each new release, I expect these components to become portable soon. Even though the presentation has some problems (typos, style, and using a constant-width font for the code snippets), I find the reading of this book to be quite relaxing and enjoyable. If I recommend it? Definitely! I'm cutting my teeth on it...

Rating:
Summary: modern C--
Review: Interesting book but dont' call it modern C++ design. GoF can call their book Modern Design, Mr. Stepanov can call his library Modern Design, Mr Meyers can call his books Modern Design, but this book has nothing to do with Modern Design. Either it is an old technique, wrapped in template implementation or some cumbursome code which is not applicable in real life.