Generative Programming: Methods, Techniques and Applications: Amazon.co.uk: Krysztof Czarnecki, Ulrich Eisenecker: Books

Product Description

Generative Programming (GP) offers the promise of moving from "one-of-a-kind" software systems to the semi-automated manufacture of wide varieties of software -- essentially, an assembly line for software systems. GP's goal is to model software system families and build software modules such that, given particular requirements specs, highly customized and optimized intermediate or end products can be constructed on demand. This is the first book to cover Generative Programming in depth. The authors, leaders in their field, introduce the two-stage GP development cycle: one stage for designing and implementing a generative domain model, and another for using the model to build concrete systems. They review key differences between generative modeling and processes used for "one-of-a-kind" systems. Next, they introduce key GP concepts such as feature models, and demonstrate "generic programming" techniques for creating components which lend themselves to easy combination and reuse. The book also introduces Aspect Oriented Programming, which allows developers to solve key recurring problems in traditional O-O development; and presents metaprogramming techniques for building powerful program generators. Three detailed case studies demonstrate the entire generative development cycle, from analysis to implementation.

From the Back Cover

Praise for Generative Programming

“The book develops strong themes around unifying principles that tie the pieces together, most notably domain engineering and metaprogramming. It’s crucial to understand that this book is not just some refreshing diversionn or just an exposition of some noteworthy niche techniques. It is a harbinger of a broader enlightenment that opens the door to a new age.”

—from the foreword by JAMES COPLIEN, a Distinguished Member of Technical Staff at Lucent Technologies' Bell Laboratories, Naperville, IL

“Generative Programming offers a well-written and comprehensive discussion that integrates object technology and domain engineering. The authors’ approach to software systems generation provides very clear insights into practices essential for systematic reuse and software product lines.”

—SHOLOM COHEN, a Senior Member of the Technical Staff of the Software Engineering Institute (SEI), Pittsburgh, PA, and a co-developer of the Feature Oriented Domain Analysis (FODA) method

“If you believe that the systems you develop today will share concepts with the systems you will develop tomorrow, then the practical techniques presented in this book will reduce your time to market, decrease your engineering costs, and improve your software quality. These techniques are essential for both practitioners and researchers concerned with modern system development.”

—JAMES NEIGHBORS, President of Bayfront Technologies, Inc., Newport Beach, CA, and the author of the Draco approach

“The authors present a grand tour of Generative Programming which is bound to become a classic. They properly focus on the generally unappreciated connection between Domain Specific Languages and Generative Programming as a motivation for future development. The wide-ranging and practical methods for Domain Analysis and Domain Engineering describe the first steps that developers can take right now. They are valuable both when existing systems are used or in preparation for emerging new generative technologies.”

—CHARLES SIMONYI, Chief Architect at Microsoft Research, Redmond, WA, and the inventor of Intentional Programming

Generative Programming (GP) offers great promise to application developers. It makes the idea of moving from Ione of a kindO software systems to the semi-automated manufacture of wide varieties of software quite real. In short, GP is about recognizing the benefits of automation in software development. Generative Programming covers methods and tools that will help you design and implement the IrightO components for a system family and automate component assembly. The methods presented here are applicable for all commercial development--from "programming in the small," at the level of classes and procedures--to "programming in the large," or developing families of large systems.

Generative Programming is your complete guide and reference to this emerging discipline. It provides in-depth treatment of critical technologies and topics including:

Domain Engineering
Feature Modeling
Generic Programming
Aspect-Oriented Programming
Template Metaprogramming in C++
Generators
Microsoft's Intentional Programming

Using this book you will learn how these techniques fit together and, more importantly, how to apply them in practice. The text contains three comprehensive case studies in three different domains: programming domain (container data structures), business domain (banking), and scientific computing (matrix computations).

See all Product Description

Customer Reviews

5 star

4 star

3 star

2 star

1 star

5 reviews

4.4 out of 5 stars

Write a customer review

Most Helpful Customer Reviews

6 of 6 people found the following review helpful

wide-ranging in scope, but heavy on C++ templates 2 Mar 2007

By Thing with a hook

Format:Paperback

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!

Comment |

Was this review helpful to you?

Yes

2 of 2 people found the following review helpful

Great book 8 Sep 2002

By "gustavobt"

I really liked this book. Very interesting ideias. The first part can be a little hard to read, as it's a little bit too much theory for me to handle at one time, but when we reach the second part, and especially the third (the examples), it becames quite interesting and enthusiastic. I only think it could have been better if the authors didn't separate the chapters so well, it turnded it a little more boring to read. In spite of this, it's still very worth buying.

1 of 1 people found the following review helpful

A difficult, but in the end probably the more rewarding IT book I have ever read. 23 Mar 2008

By A. A. Moolenaar

This is a fantastic book. No IT book has ever made such an impression on me as this book. But at the same time it has been one of the hardest IT books I have ever read.

The positive side of the book is that this is one of the few IT books that made me rethink and reevaluate the way I program. The explanation of static metaprogramming in C++ is in my opinion also the best I have read, superior to the one written by Abrahams and Gurtovoy in "C++ Template Metaprogramming", and in my view also slightly better than the one provided by Andrei Alexandrescu in "Modern C++ Design". In any case, only after reading the initial 30 pages of chapter 10 "Static Metaprogramming in C++" I had the feeling that everything fell to its place, i.e. that apart from understanding what template metaprogramming was tryig to accomplish, I also understood why it was done in exactly that way. This is a bigger accomplishment as it may seem at first, given that this book predates those other books. (It also seems that the authors were also responsible for many of the ideas of template metaprogramming.)

The downside is that this is such a lengthy book, written in very capable, but at the same time such dull prose that at various moments I just had to "log off". Some explanations may have been spot on (such as the one about template metaprogramming), some of them had me really puzzled. For instance, it took me a long time to fully grasp GenVoca models. (Especially what in GenVoca jargon is called a layer had me confused.) In order to truly appreciate the book I had to go back and reread various sections many times. But if you do, at a certain point you are rewarded. You will get an idea of what the authors try to accomplish, at at that time you begin to understand and appreciate the relevance of everything that is written (with only Chapter 11 "Intentional Programming" as an exception).