Rating: 
Summary: Interesting for C++ template programmers
Review: Czarnecki & Eisenecker are the authors of the the famed IF<> template used in many template libraries (Blitz++, GGCL, FAST, VTL and Lambda) They also discuss creation of a linked list, binary tree, SWITCH, FOR, WHILE templates. These are compile time constructs for generating code, not the resulting executable code. All cool stuff. There have been some advances in this realm of coding since this book has been published, but for the most part this is a good reference text. (Its an area of programming that is moving fast.)The complaint about this book for JAVA programmers is legit, JAVA without templates or some other meta language is an inappropriate tool to do Generative Programming. That's not a slam on JAVA its just the way it is. Screws and nails, the right tool for the job at hand. The discussions on design methodologies is pretty dry. If I'm having trouble sleeping, reading a chapter on it will do the trick. However there is a great chapter on "Feature Diagrams". These are a great addition to any design document as it can show what things are missing. After applying one to the VTL library we realized that we are missing a shared reference base. The best part of this book is that each chapter starts out with a paragraph of why you should read that chapter. Would all technical books do this, I would be forever grateful. There is also a summary of the important points in the margin. Feels like I'm reading an annotated text, again a great writing style. C++ code design is hard, mostly because the problems we are trying to solve are difficult. The real world is messy. (Witness the Zebra, looks like a horse but isn't.) The formalism this book brings to the table will help create better designs. Recommended for Advanced C++ program designers, and anyone writing generic libraries.
Rating:
Summary: Interesting for C++ template programmers
Review: Czarnecki & Eisenecker are the authors of the the famed IF<> template used in many template libraries (Blitz++, GGCL, FAST, VTL and Lambda) They also discuss creation of a linked list, binary tree, SWITCH, FOR, WHILE templates. These are compile time constructs for generating code, not the resulting executable code. All cool stuff. There have been some advances in this realm of coding since this book has been published, but for the most part this is a good reference text. (Its an area of programming that is moving fast.) The complaint about this book for JAVA programmers is legit, JAVA without templates or some other meta language is an inappropriate tool to do Generative Programming. That's not a slam on JAVA its just the way it is. Screws and nails, the right tool for the job at hand. The discussions on design methodologies is pretty dry. If I'm having trouble sleeping, reading a chapter on it will do the trick. However there is a great chapter on "Feature Diagrams". These are a great addition to any design document as it can show what things are missing. After applying one to the VTL library we realized that we are missing a shared reference base. The best part of this book is that each chapter starts out with a paragraph of why you should read that chapter. Would all technical books do this, I would be forever grateful. There is also a summary of the important points in the margin. Feels like I'm reading an annotated text, again a great writing style. C++ code design is hard, mostly because the problems we are trying to solve are difficult. The real world is messy. (Witness the Zebra, looks like a horse but isn't.) The formalism this book brings to the table will help create better designs. Recommended for Advanced C++ program designers, and anyone writing generic libraries.
Rating:
Summary: Interesting for C++ template programmers
Review: Czarnecki & Eisenecker are the authors of the the famed IF<> template used in many template libraries (Blitz++, GGCL, FAST, VTL and Lambda) They also discuss creation of a linked list, binary tree, SWITCH, FOR, WHILE templates. These are compile time constructs for generating code, not the resulting executable code. All cool stuff. There have been some advances in this realm of coding since this book has been published, but for the most part this is a good reference text. (Its an area of programming that is moving fast.) The complaint about this book for JAVA programmers is legit, JAVA without templates or some other meta language is an inappropriate tool to do Generative Programming. That's not a slam on JAVA its just the way it is. Screws and nails, the right tool for the job at hand. The discussions on design methodologies is pretty dry. If I'm having trouble sleeping, reading a chapter on it will do the trick. However there is a great chapter on "Feature Diagrams". These are a great addition to any design document as it can show what things are missing. After applying one to the VTL library we realized that we are missing a shared reference base. The best part of this book is that each chapter starts out with a paragraph of why you should read that chapter. Would all technical books do this, I would be forever grateful. There is also a summary of the important points in the margin. Feels like I'm reading an annotated text, again a great writing style. C++ code design is hard, mostly because the problems we are trying to solve are difficult. The real world is messy. (Witness the Zebra, looks like a horse but isn't.) The formalism this book brings to the table will help create better designs. Recommended for Advanced C++ program designers, and anyone writing generic libraries.
Rating: 
Summary: Too much fluff
Review: I bought the book with much hope... yet I was unhappy with it. I am looking for new, improved ways to design and implement programs using C++, and sadly this book doesn't offer much help in that direction. The book is a bit silver-bulletish: pompous terms, academic "serious" style, predictions, they're all there. Yet the practical examples the authors give are not very conclusive. The book is too long. A very hard, and not much rewarding, read. And the forward references are really annoying. Practically the first half of the book keeps saying that the details about X, or even the full definition of X, will be found in a subsequent chapter... Too hard to read, too little outcome for me as a reader. The information is there but it's drawned in mere fluff.
Rating: 
Summary: Strangely boring
Review: I bought this book because I was looking for a language-agnostic guide to generic and aspect-oriented programming. Its scope includes these subjects in the broader topic of building software that builds software; a search for yet higher level tools and methods. While this is undoubtedly an important area, there is something strangely boring about this books presentation of the topic. I have found it sits unread on my desk. I think it's because the book is often rather vaugue and conceptual in its discussion of the issues, and Im unable to relate the material to the practical challenges and solutions I have encountered in my day to day work in Java enterprise systems development. The authors can be tediously verbose. Each chapter starts with a section "Why you should read this chapter" which describes the contents, then goes on to an Introduction that describes the contents again. The very need to individually justify each chapter suggests Im not the only one who has found it a lottle bit dull.
Rating:
Summary: A Trifling Book
Review: I gave this book an honest try, well past my initial impressions (which were unequivocally negative.) The intro by Coplien (this guy had better quit writing untruthful blurbs, or his credibility will end up in the toilet) kept me trying, but, no, sorry, the book *is* disappointing. It is purported that there are some earth shattering discoveries in it, but in reality, this book is simply the first in what I suspect will be a new series of scientific-sounding drivel from Addison Wesley (the "patterns" cash cow has run its course, I guess, now it's time for something less tired, with new-style covers.) The truth is, all these supposed conceptual breakthroughs are very trivial things. Yes, C++ templates expose some functional side effects that can be used for a bit of compile-time code generation. Btw, this is not what they were designed for, and the use of them in such a way produces very convoluted, unintuitive code--imho, not a good band for a buck, so to say. YOu can achieve the same with extra-compiler tools, and in a conceptual book you'd think the authors ought to talk about conceptual things, not about some accidental properties of C++ templates. And so on and so forth. In the chapter on "Intent-based Programming" (hee-haw! "OO" and "patterns" shamanism is passé now) the writing style descends into unadulterated MS-style hype--every third word is "our exciting technology". For goodness' sakes, tell me what you have to say--if you have anything--and leave it to me to get excited over it. In other words, if you're a working developer, it is very certain that you've run into the things this book talks about; not only that, you've run into them about five zillion times by now and you take all this for granted, w/o attaching cute (suitable for trademarking--"Intent Programming", etc) names to every insignificant code doodad, every trifling design habit, w/o making a big deal out of any of this stuff--just like it is the case with the "patterns". It's just you've never figured that you can write thick tomes filled with a mix of boring banalities with gratuitous word coinages (to make your droning appear academic.) We have too many CS PhDs having nothing to say who produce these bloated compendia of absolute vapor that dishonest publishers clearly intend for corporate sales (no working professional with three pennies' worth of understanding will fall for this "literature.") God bless Amazon for their generous return policy: this is clearly the case such policies are designed for. The drivel goes back today. I'm looking forward to seeing this book in my favourite remainders store in the same dusty three-for-$10 pile of "patterns" and the rest of magic word-infested junk.
Rating: 
Summary: A peek at the next level of abstraction.
Review: If we think of OOP as a level of abstraction beyond procedural programming, we can ask the question "what's the next level of abstraction beyond OOP?" Application of OOP allows us to design and create programs of far greater complexity than traditional procedural approaches. Similarly, another level of abstraction should lead to a quantum leap in our abilities, both conceptually and practically.
The question addressed by this book is how can we go about designing programs that generate programs? How might we specify families of programs to cover whole domains of problems, in the same sense that a modern auto design specifies a near infinity of specific autos with varying sets of options? How might we implement such designs - and what tools are currently available, or under construction, for doing so? How do we go about thinking about such questions?
This book doesn't have all the answers, but certainly the ideas of feature modelling and domain-specific languages must be parts of the answer. If we stuck to those sections of the book (chapters 1-5), it would be important enough, but unsatisfying without any means of implementing something - and probably too short for a PhD thesis!
The majority of the book looks at a variety of implementation approaches - a few briefly, one (intentional programming) in somewhat more depth, and focuses on C++ template metaprogramming as the one most of us can do something concrete with today. Even there - as the MS Visual C++ compiler doesn't support partial template specialization - it's difficult to experiment. Too, the quote at the beginning of chapter 10 says it all: "I always knew C++ templates were the work of the Devil, and now I'm sure." (Cliff Click).
But that's not the point. More effective tools will come, but only after we think hard about what kind of tools we need - just as C++ was the culmination of a lot of people thinking hard about object oriented programming. This book opens the door - and our eyes - to what might someday be. At that level, it's breathtaking.
If you agree with the quote opening chapter 9: "I would rather write programs to help me write programs than write programs" (Dick Sites), then this book is for you. If you think that's nonsense, you'll get little or nothing out of it.
Rating: 
Summary: Save your money
Review: If you are a Java developer, you will find some very grating passages, which derive from the strongly C++ centric bias of the authors. They basically dismiss Java because it does not have templates and typedef enumerations... They favor the IDE/'project' type interface you will see in products like Visual Studio over the clean-n-simple approach of the JDK... While everybody wants to address the issue of excess complexity in software systems, these guys approach it by recommending a new class of expensive developer tools, which will magically abstract away the specifics of the programming language (without bugs?)... They recommend this absurd new Microsoft monstrosity called 'Intentional Programming'... In short, it represents a way for domain-specific sublanguages (or superlanguages.. whatever) of programming languages to be created, with the primary foreseeable effect of balkanizing developer skillsets into hundreds of splintered little libraries, and never the twain shall meet... If people would just lose their enfatuation with complexity and silver bullet toolkits, perhaps a rational discipline for writing software will emerge. Until then, we can continue to waste money on books that describe flashy new ways for creating yesterday's software...
Rating:
Summary: Interesting but academic
Review: It is unfortunate that they do not mention (and are probably unaware of) the Shlaer-Mellor methodology which is probably the closest we have at present to an industrial workable aproach to generating programs for a wide variety of domains (as opposed to domain specific approaches like Verlog, etc.).
Rating:
Summary: 5 Stars with caveats.......
Review: Its hard to tell from the title of this book who will benefit from reading it but from a practical standpoint, C++ library designers and those with an interest in the "bleeding edge" of software engineering should find it very enlightening. The primary focus of this book is speeding up the lifecycle of program design by utilizing "Generative Programming". GP is a fancy name for programming using domain specific notations and generating highly optimized code without burdening the application programmer with low level details of domain libraries. Chapter 1 "What is this book about?" - The authors describe GP. Short and sweet..... Chapter 2 "Domain Engineering" - A rather dry, pedantic review of current Domain Engineering methods. This chapter reads like a PHD lit review. Boring.... Chapter 3 "Domain Engineering and OO Analysis and Design" - Why OO Analysis isn't appropriate for designing reusable libraries and analysis methods that are more suitable for the task. Quick and painless.... Chapter 4 "Feature Modeling" - One of the high points of the book. For those of you who have been stymied by the inflexibility of UML, the authors introduce the technique of "feature diagrams" which allow library designers to defer decisions like inheritance vs. aggregation until later in the design. Potentially very useful. Chapter 5 "The Process of GP" - Describes how GP should work in an ideal world (which unfortunately doesn't exist yet). A bit too abstract..... Chapter 6 "Generic Programming" - Describes type based programming (i.e. C++ templates) and various languages support for Generic Programming. Java programmers won't like this one! Chapter 7 "Component-Oriented Template-Based C++ Programming Techniques" - The title pretty much says it all. Good introduction to C++ templates. Chapter 8 "Aspect-Oriented Programming" - Aspects are portions of code that have little to do with the actual intent of the code. Examples are synchronization and error handling. This chapter describes how messy aspects can make code and how to separate aspects from core functionality. Good stuff.... Chapter 9 "Generators" - Describes how ideal code Generators should work. Good introduction to the topic. Chapter 10 "Static Metaprogramming in C++" - For me this is the high point of the book. Compile time control structures such as IF<>, SWITCH<>, DO<> and WHILE<> are introduced. These can be used to generate configurable types as shown in later chapters. These structures are difficult to debug but if used conservatively are very powerful! Chapter 11 "Intentional Programming" - A description of Microsoft's Intentional Programming environment. IP is the ideal GP development environment that allows library designers to enhance the main IDE with domain specific libraries. Developers interact directly with the source parse trees that are rendered to the IDE in a domain specific manner. The description is interesting but the IP Software is potential Vaporware and I'm kinda sick of reading about MS development tools that will change the world (C# anyone????) Chapter 12-14 - The final chapters describe how to build template class generators that allow the application programming to specify functionality as a template parameter and the generator will build the type. It's as close to GP as we can get today. A list container class, bank account class and a highly optimized matrix library are designed using the GP methodology. It's nice to see the authors actually practicing what they preach. Aside from the overly academic feel to the book and touting Microsoft fantasy-ware (which may become available... who knows?) this book offers much food for thought for system designers and C++ library implementers. The template tricks described are difficult to debug but with a little luck future compilers will provide better support for this style of compile time design. I look forward to the 2nd or 3rd edition of this book when this stuff matures.
| 
