Generative Programming: Methods, Tools, and Applications (Paperback)

by Krysztof Czarnecki (Author), Ulrich Eisenecker (Author)

Editorial Reviews

Product Description
The authors present a grand tour of Generative Programming that is bound to become a classic. They . . . focus on the generally unappreciated connection between Domain Specific Languages and Generative Programming as a motivation for future development. Their wide-ranging and practical methods for Domain Analysis and Domain Engineering describe the first steps that developers can take right now . . . and are valuable both when existing systems are used or in preparation for emerging new generative technologies." --Charles Simonyi, Chief Architect at Microsoft Research and the inventor of Intentional Programming "The book develops strong themes around unifying principles that tie the pieces together, most notably domain engineering and metaprogramming. It is crucial to understand that this book is not just some refreshing diversion, nor 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

Generative Programming (GP) offers great promise to application developers. It makes the idea of moving from one-of-a-kind 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 right 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).

From the Back Cover
"The authors present a grand tour of Generative Programming that is bound to become a classic. They . . . focus on the generally unappreciated connection between Domain Specific Languages and Generative Programming as a motivation for future development. Their wide-ranging and practical methods for Domain Analysis and Domain Engineering describe the first steps that developers can take right now . . . and are valuable both when existing systems are used or in preparation for emerging new generative technologies."
--Charles Simonyi, Chief Architect at Microsoft Research and the inventor of Intentional Programming

"The book develops strong themes around unifying principles that tie the pieces together, most notably domain engineering and metaprogramming. ItIs crucial to understand that this book is not just some refreshing diversion, nor 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 TechnologiesI Bell Laboratories

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).

0201309777B04062001

See all Editorial Reviews

Product Details

• Paperback: 864 pages
• Publisher: Addison-Wesley Professional (June 16, 2000)
• Language: English
• ISBN-10: 0201309777
• ISBN-13: 978-0201309775
• Product Dimensions: 9.3 x 7.5 x 1.8 inches
• Shipping Weight: 3.2 pounds (View shipping rates and policies)
• Average Customer Review: 3.9 out of 5 stars See all reviews (21 customer reviews)
• Amazon.com Sales Rank: #676,818 in Books (See Bestsellers in Books)

Customer Reviews

Most Helpful Customer Reviews

94 of 95 people found the following review helpful:

5.0 out of 5 stars 5 Stars with caveats......., October 10, 2000

By	ZippyFuzzy "childofthe80s" (USA) - See all my reviews

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.

33 of 38 people found the following review helpful:

4.0 out of 5 stars Interesting for C++ template programmers, August 31, 2000

By	G. Powell (Seattle, WA USA) - See all my reviews (TOP 1000 REVIEWER)    (REAL NAME)

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.

14 of 16 people found the following review helpful:

5.0 out of 5 stars A peek at the next level of abstraction., January 23, 2001

By	Peter D. Barnhart "pdbarnhart" (Brooklyn, MI) - See all my reviews

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.