Rating: 
Summary: Briljant but difficult...
Review: Without any doubt I rank this book with 5 stars! Not because of a nice description of policies, singletons, smartpointers or a generic container, etc... But because it I finaly learned some new and USEFULL tricks. (an example is the trick to switch from run-time errors to compile-time errors!)I'm not a c++ beginner nor an expert. I think this book is pretty hard to understand if you're not an expert. Nevertheless this is an absoluut 'must have'! Specially if you want to write your own c++ code instead of using the MS-garbage. Read the book and ask yourself if you are a c++ expert!
Rating:
Summary: Absolutely brilliant...
Review: I have managed to get this book after 1 whole year of trying... And, boy, was it worth the wait... This book is perhaps the only book I own for Software Engineering & Design Patterns... (not even the GoF book is so honoured...). This book opens new vistas for thinking, and for that alone, this book is a must buy... If you believe in the future of C++, and that templates is yet another weapon in your armoury, get this book ASAP!!!
Rating: 
Summary: ...
Review: ... The stuff in this book IS an intellectual challenge, as such it's great, BUT! Life's full of intellectual challenges that offer a better practical payoff. This stuff is typical highbrow snobbery, academic extremism by (and for) tenured people who do no actual work and must squeeze out of themselves a piece of writing for the C++ Report on a monthly basis. That, btw, is precisely why I haven't read this useless publication in years. Like I said: it is intellecually stimulating, if you got nothing else to do, by all means, indulge. Otherwise (if you are like 99.9(9)% of normal people) you'll spend your time much better working on something else - algorithms, hardware, another language, another OS, distributed systems, business issues, pricing, marketing, job-hopping, beer drinking, fulsome flattery towards your chief, checkin out babes, trainspotting... for goodness' sakes, what-...-ever, just simply get some extra sleep! - before you waste your time on this book. Just my $.02 obviously.
Rating:
Summary: Readme.txt
Review: Let me start by saying, I have never given a book 5 stars. While this book does have its problems, the writing style is excellent. If you are into Generic programming there are very few books to read (only two that I know of). Luckily, this is one of them. While the problems with the book have been listed in other reviews: - Sample code (aka loki) doesn't match what's in the book
- Code won't compile on MSVC++ 6.0
- Obscure references to other material
- Editorial Mistakes
- Only for C++ template masters
- (Etc.) I can't seem to put this book down. The ideas are nothing short of inspirational. As you read it, there seems to be something bigger going on. It reminds me of the early 90's when all my C++ buddies where trying to figure out what Object Oriented Programming really meant in terms of how it will impact software development. I suspect a lot of what is presented will morph over the coming years as programmers discover what are truly good and bad generic programming practices. Even with all of that, this book will make you think about how you program. The combination of Object Oriented and Generic Design is so powerful; I don't think I will ever go back to pure Object Oriented Development. If you find Object Oriented C++ is becoming a "worn out record" (oops, just dated myself), buy this book.
Rating:
Summary: Rquired Reading for Contemporary C++ Programmers
Review: Whether C++ helps your productivity or not is a different debate; but it most certainly is an intellectual challenge - if you have time for it! And, Alexanderescu's book is an essential read if you come anywhere near (or, forced to come near :-)) accepting that challenge. The book is mostly about Templates. One could justify the title by claiming that most of modern C++ involves templates. Probably right. In a way, this is a good follow up to Scott Meyers book on STL. The sub-title of the book is informative of the content: "Generic Programming and Design Patterns Applied". Chapters 5: Generalized Functors, 7: Smart Pointers, and 8: Object Factories are probably the most interesting ones. Fortunately, these chapters are also some of the best chapters in the book. If you already know everything in these three chapters, very likely you will breeze through the rest of the book. But I spent most of my time at those. I had seen the topics in bits and pieces in C++ Report articles, but reading about them in one place and going through them in a systematic, text-book like manner helped further. The library described in the book - Loki - does NOT "work off the box" completely with Visual C++ 6.0. However, with some effort I got it to (mostly) work with it. You can do that. In any case, Stan Lippman has said that it is one of the priorities for the Visual C++ Architecture team to support templates better and to ensure that libraries such as Loki and Boost work with it. With gcc Loki seems to do fine with SGI STL, as far as I have stretched it.
Rating:
Summary: good book to read after the GoF book
Review: This book was really hard to read b/c it was the first book I read about Templates. I liked it. It took me a while to get thru the book, but it was well worth the effort.
Rating:
Summary: Why I Give It 5 Stars?
Review: I've never read this book. But only for the prefaces -- written by Meyers and Vlissides -- I'll give it 5 stars! Don't you agree me?
Rating:
Summary: The most important C++ book in many years
Review: Many years ago, I began to feel that the power of templates in C++ has not been fully exploited. In more recent years, the emergence of the STL has shown that templates can be used to great advantage for containers, allowing conceptually simple generic implementations to be reused in a wide variety of situations, with no run-time penalty. This advance only increased my sense that we haven't yet seen the full power of templates. Alexandrescue's remarkable work is, in my view, the most original and important advance in C++ since the STL. It has been an article of faith in the design patterns community that one can't implement a reusable design patterns library in any language, because each pattern has dozens of important variations, and an unlimited number of custom variations, all seemingly interdependent. Alexandrescue's work seriously challenges this assumption. He uses "policy classes" (explained in Chapter 1) together with many innovative template techniques to pull apart these interdependencies. The heart of the book describes in detail how he developed the "Loki" library containing many gang-of-four design pattern implementations. Loki's SmartPtr, one of the high points of the book, puts to shame the Standard C++ auto_ptr, which has been the state of the art until now. Even before Alexandrescue's work, templates provided C++ programmers with major advantages not available in "more modern" object-oriented languages such as Java and C#. Alexandrescue multiplies the existing advantages many times, facilitating dramatic increases in C++ programming productivity and quality. Isn't that what high-level language programming is all about? The only negative comment I have is not really a criticism of Alexandrescue's work, but of the deplorable state of C++ compiler implementations. Because many C++ compilers, especially the most popular ones, still do not fully support Standard C++, many of Alexandrescue's techniques cannot yet be used in many practical situations. I would like to think that the importance of supporting Alexandrescue's library will motivate compiler vendors to make the necessary, and long-overdue upgrades.
Rating:
Summary: A seminal work with practical application
Review: This book is a clear presentation of groundbreaking C++ techniques. Even so, it is hardly an academic exercise, and contains a great deal of code that can be immediately applied to most projects. The various chapters, eleven of them, have minimal relationships and dependencies among themselves. Together they constitute an eclectic collection of some of the most powerful techniques available to today's programmers. Each technique is presented clearly and in-depth, with illustrative code. Despite the subtitle of "Design Patterns Applied", there is much more here than design patterns. I have little use for most of the patterns covered (at the moment); however there are many techniques presented which solved pressing problems in my own projects. These include type-lists (tuples), singletons, small object allocation, and functors. Although many reviewers have complained about the inability to use the code given in MSVC, the concepts presented are exposed with enough clarity that I have had little trouble implementing them, including type-lists, using MSVC. I considered myself a template expert long before this book was published, and still I found it the most valuable and enlightening book on the topic in recent memory.
Rating: 
Summary: Template Showboating
Review: While this is an interesting book, I'm not as unconditionally enthusiastic about it as most of the reviewers here seem to be. I felt that, as opposed to Scott Meyers' books and the original _Design Patterns_ book, many of the techniques presented in this book are the result of research into "elegant" solutions rather than experience with what really works in practical applications. I really liked chapter 1 discussing policy-based class design, chapter 2 discussing various template techniques, chapter 6 discussing singleton implementation, anbd chapter 7 discussing smart pointers. Chapter 11 discussing multimethods, appears to be a good discussion of various alternatives but I'm not inclined to use multimethods anytime soon. Chapter 3 about typelists is interesting, but after all the dazzling manipulations, all that typelists seem to be good for is generating class hierarchies, which I didn't find very compelling - it looks as if the typelists help to manage complexity that possibly wouldn't be there if the typelists hadn't been used in the first place. Chapter 4 about small object allocation was of limited interest to me. The other chapters, 5 (Functors), 8 (Object Factories), 9 (Abstract Factory), and 10 (Visitor) offered fairly complex, template based solutions that to me did not look obviously superior to the straightforward manual implementations shown in _Design Patterns_. Overall, a stimulating book, but one whose recipes will need careful evaluation before use.
| 
