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

Rating:
Summary: Read this milestone book!
Review: I highly recommended this book if you are interested in generic techniques and Design Patterns

This book uses C++ and Generic programming techniques to implement GoF Design Patterns [1]. It introduces Andrei's "Generic Design Patterns Library", called "Loki". Loki's techniques are more important than the library itself and should be applicable in many other contexts. (Since the library is not yet available, I cannot comment on it further.) One word of caution (lest you get overly excited) - Loki uses some of the latest C++ features and requires standard-adhering compilers [g++ v2.95.2-5, Borland C++ v5.5, and EDG's v2.45 or later. Microsoft's VC++ 6.0 fails-Ed.]

The book is written for intermediate or expert level programmers. A fair knowledge of C++, particularly templates, is needed Also, some knowledge of Design Patterns is useful, although not strictly necessary, since the book describes the patterns in a pretty self-contained fashion.

With these prerequisites the book makes for quite an enjoyable read, but I would not call it easy due to the inherently complexity of the material covered. Andrei's writing style is frank and friendly, which makes the reading easier.

I found the code fragments to be very accurate bar some mechanical/typesetting errors, some of which will be fixed by the time of the printing. The book's strong points include:

1) Taking techniques as complex as template meta-programming and bringing them back to us earthly beings. You could get a more extensive treatment of these techniques from the book Generative Programming [2] or from Todd Veldhuisen's papers [3] but the examples in this book make a very good introduction to the area.

2) Creating a generic library of design patterns using "policy-based" classes eliminate the redundancy found in many systems that utilize Design Patterns.

3) The one line of the book I'd like to (mis?)quote in my review is "Remember, the design constraints buried in the class's design are as bad as magic constants embedded in code". As obvious as it is, this principle is often overlooked (I know...) and largely because people do not see a solution to it and are willing to live with the "this is as good as it gets" mentality. In this sense the book was a great eye-opener - it showed the feasibility of the solutions and the techniques for the implementation.

Personally, I hope you enjoy the book as much as I did!

Rating:
Summary: C++, revisited
Review: Most intriguing book on C++ I have read lately. Totally changed my understanding of what templates are. If you feel like there is no more surprises in C++ for you left - read it, 'casue you have seen nothing yet!

Well, seriously, Andrei has worked out the most incredible and powerful techniques that allow one to write highly reusable, flexible code, implement design patterns the way I haven't think is possible. It will give you a great deal of ideas that will most profoundly influence your design and coding. Very easy to read for an above entry level programmer.

In general - "C++ in Depth" is very nice series from A-W. Must have.

Rating:
Summary: Too complex to use
Review: I am an advanced user of C++. Though what the book contains is useful, it was frowned upon by my team mates as something too complex. If I were to write code using the techniques in this book, someone else reading the code would have a tough time understanding it. Don't get me wrong, my team mates are some of the best programmers you would get to meet.

Rating:
Summary: Great for advanced c++ programmers
Review: There are several good reviews already; here I just want to make it brief.

The central concept is that by using template, especially template specialization, one can write template code that the compiler can generate at compile time. Thus, template and template specialization provides a standard way to write a generic library code that the compiler can generate specifically for the application.

Base on the above concept, the author explained and wrote a great library that contains many of the fundamental design patterns.

I like the book because:

1) The author explanation and writting style is clear and smooth; it is perfect.

2) It extends my understanding of template and template specialization. It shows the power of template.

3) It extends my understanding of many of the design patterns.

4) The library code (must be download) can be a priceless when the need arises.

There is only one bad part about the book: it contains some typos, mostly in the early chapters.

In my opinion, this is a book that any serious C++ programmer must read.

Rating:
Summary: Outstanding!
Review: This book is for the very advanced C++ programmer. You'd better be up on templates or ready to get so for this book. The book is clearly written, but some of the techniques take a while to sink in (I don't think it's just me). Once they do - wow!

The book covers generic programming to the nth degree. Many of the ideas are not new, but for me this was the first time (other than some STL) where they really sank in. The author then applies many of these techniques to implement several well know patterns and/or idioms of C++ in mind blowing ways. This is a totally different way of programming than you are probably used to (well, okay, in some ways it's like the STL, but even more "out there").

Be warnined, though, if you are using MSVC 6.5 or less, you'll not be able to make use of several of these techniques as they require standard C++ template conformance (something that 7.0 is supposed to have...maybe).

In the meantime, check out Andrei's articles at the most excellent "Expert's forum" of ...

Rating:
Summary: A must-read C++ book
Review: Every C++ programmer should have this awesome book. I highly recommend this book as it will help you better understand the generic programming and techniques I never found elsewhere. It really deserves the five stars above. Best regards!

Rating:
Summary: A Milestone book on C++
Review: This book makes me feel like I know nothing about C++ templates, and I thought I knew a lot. After all I can make STL complaint containers, I can write iterators, I've written several expression template libraries all of which use templates in as complex a way as I thought it was possible. But then I read the chapters on ObjectFactory, AbstractFactory and Smartpointers and I was humbled.

Ok, this book is NOT for C++ newbies. It's for folks who have access to gcc, or another decent compiler and that's nearly everyone, and who want to know what C++ is really all about. It's not just "C" with classes. Those C++ templates may have started out as a replacement for MACRO's but they are not limited by that. In fact, in some cases they are a poor substitute for a good MACRO. But in Andrei's hand, they are code generators magnificant! if you are an intermediate programmer having read the Meyer's books, and have embarked on "IOStreams" by Langer and Kraft then you will find this book will stretch your mind even more.

That said, this area of programming (generative programming) is moving fast. There are already alternative ways of specifing template arguments, the policy concept has turned many a programming idiom on its ear, so I am looking forward to a "Yet More C++" title from Andrei next year. It's won't make this book obsolete but it will expound upon the concepts presented here.

Don't buy this book if all you have is MSVC 6.5 (They have promised that in the first patch of 7.0 to have most of what we need for the code in this book.) First go to the gcc home site and get ver 3.0 for your system. Get comfortable with it, then go get a copy of this book.

This book is what "Advanced C++ Programming Styles and Idioms" by Colien was to C++ when it first came out. (Another good classic text.) You'll also want a copy of "Design Patterns" by Gamma, Helm, Johnson, and Vlissides to have by your side when you are reading about the templatized versions of the patterns in Modern C++. The two books speak in different languages about the same problems and between the two of them you will understand the issues better.

Rating:
Summary: Should be part of every C++ coder's library. A must-read.
Review: This book puts into very practical use many advanced C++ idioms in a combined and very comprehensive approach. If you want to know how to write a C++ library that is efficient, maintainable, and extensible, then you MUST study this book. It makes a great companion to "Generative Programming" and "Design Patterns" (also must-reads). This book should have a major impact on how the advanced C++ camp uses the language.

Note: Go get a good compiler if you plan to utilize these techniques...

Rating:
Summary: An Essential C++ Book
Review: First came type-safe containers and generic algorithms, and then came traits. Now, thanks to Andrei Alexandrescu's ground breaking new book "Modern C++ Design," we have policies. Policies provide a means of creating very flexible and extendable libraries with little to no run-time overhead.

As an example consider the Singleton pattern. What is the lifetime of the singleton? Should it be destroyed? If so, when? What, if any, threading model should the used by the singleton? Unfortunately, there is no one best answer. The good news is that policies allow the application developer to choose the answer that best fits their needs. Several policies are presented in the book but best of all is the fact that if none of the policies are well suited to the problem at hand, it is remarkably easy to write a new policy that plugs into the library.

While it may be tempting to write an entire book on singletons, the book covers a myriad of other topics, including but not limited to, smart pointers, object factories, abstract factories, visitors, and a memory allocator optimized for small objects. Each topic is covered thoroughly and is easy to read and understand. Be forwarded however, the reader must have of strong understanding of C++ template fundamentals. This is not an introductory tutorial on templates.

There are a number of books that should be considered "must have" for all professional C++ programmers and designers. These books include Scott Meyers' "Effective C++" and "More Effective C++", Herb Sutter's "Exceptional C++", and the "Gang of Four's" "Design Patterns." "Modern C++ Design" is the newest addition to this list.

Rating:
Summary: After two disappointments...
Review: I was longing for a good book on advanced C++. First, I bought "Multi-Paradigm C++". It does have some insights but author's style is baroque to the extreme. A good cure for insomnia. Then I bought "Generative Programming". I found it too much of a PhD thesis garnished with too much fluff for my taste.

Not wanting to risk anymore, I borrowed this book from a friend... to lose sleep for two nights reading it! It is the book I was looking for: no-nonsense, eye-opening, inspirational. The author's mastery of C++ and the creativity with which he solves real-world problems are phenomenal.

Alexandrescu discusses and implements the following design patterns: Command, Singleton, Proxy (in the form of smart pointers), Factory Method, Abstract Factory, and Visitor. In doing so, he creates highly configurable components that support most variations that accompany the patterns, and allow the component users to add their own variations. This is done through template parameters. The technique is not new but the author documents it thoroughly (coining the Policy-based design term) and uses it very creatively to achieve elegant designs.

The book also has foundation chapters: Techniques, Typelists, and a small object allocator. The latter is not really in sync with the rest of the book, being a low-level component written in straight C++, but in compensation, the chapter on typelists is as meta as you can imagine, and more :-).

In short: a great book if you use C++, especially so if you need to participate in the architectural stage of projects. But the best thing the book has done for me is, it made me extremely excited about programming - a feeling forgotten since my college days. Five stars plus.