Generative Programming: Methods, Tools, and Applications

by Krzysztof Czarnecki, Ulrich Eisenecker, Krysztof Czarnecki

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

• Format: Paperback
• Language: English
• ISBN: 0201309777
• ISBN13: 9780201309775
• Release Date: June 2000
• Publisher: Addison-Wesley Professional
• Length: 864 Pages
• Weight: 1.54 lbs.
• Dimensions: 1.7" x 7.5" x 9.3"

Customer Reviews

Towards true reuse in Software Engineering

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.

No Better Book on Software Engineering C++ that I Know Of

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.

A peek at the next level of abstraction.

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.

5 Stars with caveats.......

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

A valuable and detailed book, rich in content

The intention of this book is software re-use on different abtraction levels and within application families as well as automatisms in the software development process at the basis of components and by configuration knowledge. This book is particularly valuable because of the practical experiences of the authors. Many examples support the good comprehensibility and legibility. This book contains recommendations for the future which should you use already today. It is equally important for software designers as also for teachers at universities.