Rating: 
Summary: Great book, probably the best one on templates
Review: I re-read this book despite not being too impressed with it the first time and during my second reading a new pathway was opened into my understanding of templates. This book is very topic specific and isn't one you should pick up if you're looking for a general overview on C++. As a primer for templates though I believe it is probably the best one and goes about as deep into this subject as most anyone can imagine. It is a very library driven book which was one of things I didn't like about the book, however it is a very well written library and is something that has many unique features which would be worthwhile to document. This book does things in ways that most programmers probably wouldn't be able to fathom, but once you see that what it does actually works and is possibly the best solution under the circumstances, then you it helps you see templates in a way that many people say you get when you read Design Patterns for the first time.
Rating:
Summary: just don't let your newbies read it...
Review: Perhaps I can best convey my admiration for this book by mentioning some hesitations about how people may use its content. Despite the outrageous popularity of OO design techniques, especially including design patterns, I still don't believe that they are appropriate for most one-off small-to-mid-sized applications. Despite the prevalence of smart pointers, I usually think it's best to carefully allocate and delete memory the old fashioned way. And despite the (unintended?) power of the C++ template mechanism, I generally think it's more legible to use it sparingly. Those unfortunate programmers who like to turn a simple problem into a mish-mash of UML jargon are only going to be more dangerous when they see how to implement design patterns directly in C++ code.But when the week arrives where you need to write sixteen separate eighty-thousand-line multithreaded programs in the same problem domain -- dang, you better have read this book. Alexandrescu offers detailed implementations of smart pointers, multiple dispatch, and various design patterns. He displays a consistent awareness of other existing work (including Meyers, Veldhuizen, & Schmidt) and the contributions of other languages (like Dylan, and ML). His text is uniformly clear and legible. And his library is rapidly becoming a community standard. This book takes a huge step in smoothing over the conceptual gap between current design standards and C++ code. The results aren't as pretty as you might get with a program generator, but they're free, they're fast, and you retain complete control over what happens.
Rating: 
Summary: This book is dangerous!!!
Review: I repeat, this book is dangerous! If my clients ever understand the consequences of what this book presents, I'm in trouble! The fact that you can change the whole behaviour of a program by simply changing one line of code (policy classes) or generate complete class hierarchies generically, and numerous other things, they'll expect that I can do everything in no time at all. There go my billable hours!!! No really, I actually give this book 6 stars because it has finally shown me ways of doing things I've always wanted to do but lacked the intelligence to figure out myself (namely generic Object Factories, Functors, among other things). I'm still looking forward to Andrei's description of a generic Observer class as that has been stumping me for quite a while now. I've had to read this book a few times just to absorb what's going on. As for practical, I've applied the concepts to be able to write code in a few lines instead of thousands.
Rating:
Summary: Excellent book on it's topic
Review: First note, this is more of a theoretical than a practical book. Very little of what is taught in this book is applicable to everyday programming tasks. However, these ideas are likely a foundation for new types of programming. The advanced templating concepts in this book are absolutely amazing. And, the book is concise, without lacking explanation. You may have to read it 4 or 5 times to really grasp what he's saying, but it's all there. This is a must read for advanced C++ programmers, because you get a new look at the power of templates. It is truly amazing!
Rating:
Summary: Fantastic!
Review: Anyone saying that these techniques are esoteric or useless in normal practice really didn't absorb what the book presents. Essentially, a form of dynamism that's captured at compile time instead of run time, which still lets you write very flexible, abstract code. Only now, there's no efficiency write-off for it. The syntax of it all can be a little hard to get used to, but it _is_ worth it.
Rating:
Summary: Among the Pinnacle of Abstract C++ Software Designs
Review: Hi. In Modern C++ Design, Andrei Alexandrescu presents software design concepts that take OOP paradigm using C++ to the next level. He discusses design patterns, shows how each pattern affects C++ compilers at compile-time and during run-time, and points out how certain design patterns circumvent weaknesses in the C++ language. For example, many programmers have at least thought about instantiating an object using its string name, which is not possible in C++. As another example, the author examines advantages and disadvantages of polymorphism (RTTI) versus long compile-time (template). These are just two examples of the many key C++ design concepts and implementations the author thoroughly examines throughout this book. Modern C++ Design is about advanced C++ design patterns and implementation. Its author analyzes each design pattern from a truly abstract perspective. Andrei Alexandrescu shows design patterns that further encapsulate already encapsulated C++ OOP designs. This is one of the few C++ design books where every topic is essential in terms of software design via abstract pattern and implementation via advanced C++ technique. I recommend Modern C++ Design to real-world, professional and advanced C++ programmers. Kuphryn
Rating:
Summary: Way too esoteric for normal C++ programmers
Review: For normal practice, this book is useless. Even if somebody used some of the techniques in the book, the maintainability of the code would be zero.
How many programmers with a top 0.5% IQ do you know, anyway?
This book is way too esoteric for normal C++ programmers.
Rating:
Summary: Template metaprogramming on crack
Review: Simply put, this is one of the best C++ books I have come across. It will open your eyes to what generic programming really is and how it can be done with C++. As another review states, "this book is mostly about templates". Certainly true. This book takes templates where few have dared venture. Rather than use templates as a glorifed macro system, Alexandrescu uses templates to define small code generation engines. Your knowledge of C++ will most certainly be expanded, but you'll also come away from this book with a different way of looking at programming problems. The book also picks apart many popular design patterns and shows how to implement them in very generic ways. Alexandrescu's treatment of certain patterns is so thorough that you'll understand the pattern better from this book than the original. Perhaps the techniques go too far, perhaps there is a limit to how generic one should go. That is yours to decide, but this book is definitely a keeper for the C++/software development bookshelf.
Rating:
Summary: Exceptionally educating
Review: I have read bunch of not 5 stars reviews. All of them are nonsense. The book is for real professionals who know the depths of C++ and want to make their code nicer, more friendly, but more important, REUSABLE. The sophisticated techniques of using templates ARE NOT far from reality. They can be used for everything. And if you think that templates are only for containers (vector, list, etc.), you are deadly wrong. You may turn your messy code into a perfectly ordered programming piece of art. Moreover, you will be able to create another artistic piece by tuning the first one just a little bit. I would give 10 stars if I could.
Rating:
Summary: Why All C++ Developers MUST Read This Book
Review: If you want to know where C++ is today, there's a great selection of books out there to choose from (Stroustrup, Meyers, Sutter, Koenig/Moo, GOF, etc). If you want to know where C++ is GOING, "Modern C++ Design" is a must read. Sure, some compilers will choke on the code, but eventually the compilers will catch up (especially now that Loki is pushing the boundaries), and these techniques WILL become more common. This book is mind-expanding. New techniques like typelists, and policies, (and, the whole concept of template meta-programming, in general) give us a glimpse into what state-of-the-art C++ will look like in the coming years. It reminds me of a book I read back in the early 1990s: "Advanced C++ Programming Styles and Idioms", by James Coplien. Very little of that book was immediately applicable at the time, but the insight gained from reading it was invaluable. I found myself re-reading (sometimes re-re-reading) chapters from Coplien's book for years to come, as I encountered new problems to solve. The same is true for Alexandrescu's "Modern C++ Design" today. I don't refer to it daily, but I always keep it handy, in case I need to re-read a chapter to gain some insight into a problem. And, as the language and compilers catch up, it will become even more relevant on a daily basis. If you plan to retire in the next two years, skip this book. Otherwise, buy it, read it, and expand your mind.
| 
