Customer Reviews

Generative Programming: Methods, Tools, and Applications

5 star:		(8)
4 star:		(8)
3 star:		(4)
2 star:		(1)
1 star:		(1)

 

 

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.

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.

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.

As it is said in another review, this is a solid (and rather academic) book on the theory behind code generation. Unfortunately, I find it somewhat dated and too focused on C++ templates.

The first part of the book includes a nice introduction to domain engineering (a must for anyone interested in the development of product lines). Here, feature diagrams are introduced to represent variation points without implying a particular variation mechanism (such as inheritance or parametrization in OO languages).

The core of this book deals with different implementation technologies. You will find interesting discussions on generic programming, polymorphism, C++ templates, and aspect-oriented programming. In my opinion, the chapter on AOP is probably the best, since it provides a good survey of different approaches (subject-oriented programming, composition filters, and adaptive [structure-shy] programming) and shows some examples in AspectJ Cool (a precursor of the current version of AspectJ [the Java aspect-oriented extension]) and Dynamic Cool (for Smalltalk).

The chapters on generators elaborate on the transformational model of software development, where software development is seen as series of transformations performed on various representations of a system (i.e. creating and evolving specifications of systems and implementing them). Unfortunately, the authors focus too much on C++ template metaprogramming, which is not too practical (at least for me, mainly a Java/.Net developer). The application examples in the final part of the book also follow this approach despite its limitations regarding debugging and code readability. This limitations are not present in intentional programming, which is also covered in its own chapter. Ideally, IP would enable software source code to reflect the intention that programmers had in mind when developing it, thus simplifying maintenance and allowing programmers to keep a good high-level picture of their programs as a whole. Vapor-ware? Fantasy-ware? Maybe

If you are looking for practical ideas on code generation, this book is probably not for you. It is worth its price, however, if you just want to broaden your perspective on computer programming and are not afraid of hefty academic volumes.

Out of the three programming books (the other two are: "Modern C++ design" by Alexandrescu and "C++ templates" by Vandevoorde and Josuttis) that I have read about C++ template or generic programming, this is the best one.

I have not just glided through the book but have actually taken the time following the book to implement some experiments of my own.

The other two books are excellent books on this topic but this is the only one that offers the philosophy and big picture of what generic (actually this volume is about generative, which the authors claim to be more than just generic) programming is all about.

It is a fun read, especially after one has some generic programming experience.

The more experience you have designing and implementing complex software with C++, the harder it is to find well-written and thought-provoking books on the subject, especially with regard to architecture.

The various tomes on design using "Patterns" are useful in a charming, lightweight way, but for making architectural decisions that can impact your designs in a revolutionary manner, look no farther than this book, which I consider to be crucial reading for software architects using C++.

Highly recommended.

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.

This book has revolutionary concepts and practical solutions on how to capture the variability in software in an
orderly and predictable way and more important how to provide technology for true reuse in Software Engineering. Mandatory reading for practioners and researchers in the field.

This is a solid book of the theory behind code generation. Definitely worth the look if you are interested in extending your build process with code generation or are looking at template drive programming.

This book does cover lots of techniques that fall under the rubric of generative programming, but be warned that there is a strong emphasis on C++ template metaprogramming. If you don't know C++, or are a bit fuzzy on template syntax, you'll be missing a lot. Consider this a C++ template metaprogramming book, with some bonus chapters to put it all in context.

The opening chapters are a bit dull, containing a plethora of acronyms and jargon about various design methodologies, none of which seem to have made any particular impact in the last few years. I tentatively diagnose a mixture of thesis-itis and maybe translation-itis. If it's the former, I wouldn't be surprised to find that this made up part of the introduction or literature review chapter. However, the concept of feature diagrams is quite interesting, as it allows a graphical representation of a design specifying features and other properties (such as whether they're optional), without requiring any implementation (e.g. inheritance or parametric polymorphism), which is not possible with UML. How revelatory this is may depend on how seriously you take UML as a modelling tool, versus a convenient set of boxes and lines for representing class design.

There are also chapters on Aspect Oriented Programming, which is a pretty good survey of the field, and which provides useful motivation beyond logging. Additionally, there's a chapter on generators, which provide a convenient Domain Specific Language for specifying behaviour and performance of software components (list containers is the example in the book).

There's also a rather vacuous chapter on intentional programming, the brainchild of Charles Simonyi. It's an interesting enough idea, sitting somewhere between MDA, the Smalltalk class browser, and a souped-up IDE, but there's been absolutely no progress on it since the book was published, because Microsoft didn't release it, and Simonyi wasn't allowed to take any of the code with him when he left to set up Intentional Software. This chapter is ok on the big idea, albeit a bit breathless given it's not been shown to produce any useful software, but the worked example has all the allure of an Eclipse plugin tutorial.

The above material is sporadically interesting, but often a little pedestrian. However, the real action of the book takes place in the chapters on template metaprogramming in C++, which demonstrates how to generate related families of classes at compile time, using template instantiation and careful use of inlining to avoid inefficient virtual calls and indirection. It's very impressive. There are several examples, including a class hierarchy for a banking domain, and an in depth treatment of a matrix library, which successfully unifies all the types (sparse, full, banded etc.) under one library, while maintaining performance competitive with Fortran.

These C++ chapters demonstrate the ideas of the book in practice most clearly, although it also underlines the need for new tools and language features, given the outrageous ugliness of the compiler/template-abuse that is metaprogramming. On the other other hand, it is kind of cool to see colons, angle brackets and other bits of C++ coalesce into a strange new dialect using the compiler as an interpreter. If you're going to get anything at all out of these chapters, you do need to be comfortable with C++ templates. It would probably also help to have read something like Barton and Nackman's book, 'Scientific and Engineering C++', their unorthodox template designs providing a good warm up for what's in this book.

If you don't program in C++, or don't care for template metaprogramming, you may not find huge value for money in the other chapters. And admittedly, the writing style hardly sets the pulse racing. But if you're looking to do some intellectual stretching before taking on Andrei Alexandrescu's Modern C++ Design (and that's probably a very good idea), step right up!