Vous voulez voir cette page en français ? Cliquez ici.


or
Sign in to turn on 1-Click ordering.
or
Amazon Prime Free Trial required. Sign up when you check out. Learn More
More Buying Choices
Have one to sell? Sell yours here
Tell the Publisher!
I'd like to read this book on Kindle

Don't have a Kindle? Get your Kindle here, or download a FREE Kindle Reading App.

Generative Programming: Methods, Tools, and Applications [Paperback]

Krysztof Czarnecki , Ulrich Eisenecker
3.8 out of 5 stars  See all reviews (16 customer reviews)
List Price: CDN$ 67.99
Price: CDN$ 54.39 & FREE Shipping. Details
You Save: CDN$ 13.60 (20%)
o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o
Only 1 left in stock (more on the way).
Ships from and sold by Amazon.ca. Gift-wrap available.
Want it delivered Friday, August 1? Choose One-Day Shipping at checkout.
Join Amazon Student in Canada


Book Description

June 6 2000 0201309777 978-0201309775 1
Generative programming- Breakthrough techniques for automating the creation of software systems.
Building generative models- overcoming the limitations of traditional object-oriented modeling.
Aspect-Oriented Programming, metaprogramming, next-generation code generators, and more.
Includes illustrative sample code in C, C++, and Java, and three detailed, start-to-finish case studies. 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. GPs 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.
Krzysztof Czarnecki is a Ph.D. candidate at the University of Ilmenau, Department of Software Engineering and Media Technology, and a researcher at the DaimlerChrysler AG Research Center in Ulm, Germany. Ulrich Eisenecker, a faculty member in Computer Science and Microsystem Engineering at the University of Applied Sciences Kaiserslautern. He was formerly a researcher at Daimler-Benz Research Center in Ulm, Germany.

Customers Who Bought This Item Also Bought


Product Details


Product Description

From the Inside Flap

The advent of most any new programming book evokes the question: What is, or will be, the place of this book in history? That a book even evokes that question itself says something exciting, something about paradigm shifts or about new ideas or about breaking with old ways. And it is a curiously pertinent question for this book in these times.

Over the past ten years the object-oriented literature has seen a peppering of apparently unrelated ideas ranging from subject-oriented programming to components. What they all had in common is that there was something decidedly unobject-oriented about each of them, though each of them spent time in the object-oriented limelight. But in the past one or two years many of these fragments have found common ground and have rallied together around common themes: metaobject protocols, reflection, intentionality, an insightful interpretation of components, the cutting of features across structure and, in general, the breakdown of classic models of simple modularity. For me, one of the highlights of 1999 was the First International Symposium on Generative and Component-Based Software Engineering (GCSE '99) in Erfurt, Germany, where many researchers had already linked many of these ideas together and shared a consciousness about their significance. But it is just one forum where these ideas came together; one sees the same things at many conference workshops and in some of the emerging literature.

It's always difficult to assess history from within the events that contribute to it, but it is perhaps no less responsible nor dangerous to do so than to try to interpret it after the fact, distanced from the firsthand events. In that spirit, look around and consider that we might, right now, be at a crucial turning point in computer science, particularly in the area of programming and design technique. The industry has been struggling with how to move beyond the limiting confines of the object paradigm. Patterns were one noble attempt and, though they have done much good to draw attention to the value of experience and of the human element in programming, it is unlikely that computer science will ever achieve anything remotely approaching Alexander's vision or level of systems thinking. It is rare that software achieves a true paradigm shift in the Kuhnian sense. Perhaps we're a conservative bunch. And our fascination with novelty sometimes keeps us even from the simplest learnings; many of the tenets of the vernacular components movement hark back to early principles of object-oriented design that experience suggests should have been dropped after only a few years of experience.

But there are new signs of seeds of change. Perhaps the industry can't easily suffer a revolution, but it can tolerate a move to new techniques that build on the status quo. There is a strong and recurring move to find programming and design expression that go beyond objects and things to concepts and features. That is the essence of intentional programming, for example and, to a large degree, of techniques such as domain engineering. This vein of thought is blossoming in a wide range of forums across the industry. We see it in the vulgar (non-Alexanderian) pattern movement; we see it in aspect-oriented programming; we see it in the resurgence of generic programming and in techniques such as multi-paradigm design. And as conferences like OOPSLA focus less and less on the foundations of those things called objects and more and more on conceptual extensions, we start thinking less about parts and more about systems and features. And as OOPSLA shrinks, conferences like GCSE are becoming more numerous and popular. There is a broad-based move in this direction today. And this book finds itself squarely in the middle of this shift. I believe that the reader should neither underestimate the significance of this shift nor of this book's role in both communicating and shaping that shift. We are at the threshold of an evolution, and this book is one of the early normative works of this new genre.

This book perhaps reflects a degree of maturation in computer science that, for the first time, attempts to legitimize an integrative view in its own right rather than extol a technique by differentiating it from its predecessors. As such, the book covers much ground and embraces many disciplines: components, objects, aspects, reflection, intentional programming and generic programming for the technology-focussed, and domain engineering for the systems thinkers. It is a great introduction to both emerging and established techniques for those who are encountering them for the first time. An uninformed glance at this book might take it to be a compendium of existing practice, certainly in the area of domain engineering, but in the broader arena of things beyond objects as well.

Yet this book is more than a collection of techniques. The book develops strong themes around unifying principles that tie the pieces together, most notably domain engineering and metaprogramming. The authors treat the reader to a broad survey of domain engineering and guide the reader to appreciate its essence. Perhaps more than any single idea, domain engineering provides a common thread or theme that one could use to "explain" generative programming. But more than that, the authors draw on other schools of programming as building blocks that can be used to delineate gestalten that amplify each other in a broad, cogent vision called generative programming. The result is certainly more than the sum of the parts; most of the parts have been around for years, but an understanding of how to bring them together is just now emerging and receiving broad exposure.

It's 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. It is the coming of age of techniques, such as reflection, metaprogramming, and aspects that could augment and even displace objects as the foundations of mainstream programming practice in the years to come.

And even if the historical analysis is wrong, it doesn't diminish the book's value. The ideas are sound and timeless. Though the book builds most heavily on the C++ legacy, the ideas should provoke thought in any partisan linguistic community and indeed in the communities for most programming ideologies.

This book is just a beginning. This book invites others to follow: those who will bring methods and processes to help the designer and programmer better master and apply generative programming, and those who will bring formalisms and unifying models that will carry this work into the next generation of research. To those researchers and practitioners who are willing to go behind the confines of objects, this book raises the bar and challenges them to carry its own ideas further. I am sure nothing would please the authors more than if you took up the challenge. The first joy of publishing a book comes for an author when holding the first copy between one's hands, almost in wonder. But the greater joy comes much later, and only vicariously, as the book visibly leaves its mark on emerging practice. Few books offer this return on the authors' investment. I am both hopeful and confident that this will be one of these books, and that is because I believe the power of these ideas will draw you in as a reader and excite you to adopt these new expressive programming and design constructs. I wish you great pleasure in learning from this book, as I did, and exhort you to seek your own place in history as a pioneer who helps take these ideas forward into our discipline through the artisanship of your own programs.

James Coplien
Naperville, Illinois
February 2000



0201309777P02212002

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




Sell a Digital Version of This Book in the Kindle Store

If you are a publisher or author and hold the digital rights to a book, you can sell a digital version of it in our Kindle Store. Learn more

Customer Reviews

Most helpful customer reviews
3.0 out of 5 stars Strangely boring June 23 2004
Format:Paperback
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.
Was this review helpful to you?
4.0 out of 5 stars An advanced work on Code Generation Dec 13 2003
Format:Paperback
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.
Was this review helpful to you?
4.0 out of 5 stars good book Jan. 2 2003
By A Customer
Format:Paperback
This is a good book. It can be an even better one if the chapter on 'Intentional Programming' can be cut in half or more. I don't mind reading about the ideas of intentional programming, but the first half of the chapter reads like a manual for a particular software. "Click this button to compile, that button to do some other stuff..." For a theory flavored book I was surprised it included this kind of stuff.
The rest of the book is fine. It's a good survey of programming methodologies with an extensive list of literature. The discussion on generative programming and templates are inspiring. One thing to keep in mind is in a lot of places the book talks about the ideals of how programming should be, which is why it may sound silver-bulletish. But it didn't claim to have reached all those ideals. So you need to think for yourself what can be solved by using the techniques introduced in this book. Unlike some other reviewers, the academic style is ok with me. I'd rather a technical book to be a little too serious than too comical.
Was this review helpful to you?
1.0 out of 5 stars Too much fluff May 28 2001
Format:Paperback
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.
Was this review helpful to you?
5.0 out of 5 stars A peek at the next level of abstraction. Jan. 23 2001
Format:Paperback
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.
Read more ›
Was this review helpful to you?
5.0 out of 5 stars 5 Stars with caveats....... Oct. 10 2000
Format:Paperback
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!
Read more ›
Was this review helpful to you?
Want to see more reviews on this item?
Most recent customer reviews
1.0 out of 5 stars A Trifling Book
I gave this book an honest try, well past my initial impressions (which were unequivocally negative. Read more
Published on Sept. 28 2000 by J Jacob Jingleheimer Schmidt
4.0 out of 5 stars Interesting for C++ template programmers
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... Read more
Published on Aug. 31 2000 by G. Powell
5.0 out of 5 stars Very informative, interesting and fun to read
This is a seminal and very timely book. It is great in many ways, but for me, the great value of Generative Programming is in providing a unified view on major past and current... Read more
Published on Aug. 29 2000 by Stan Jarzabek
4.0 out of 5 stars 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... Read more
Published on Aug. 29 2000 by Heather Olszyk
3.0 out of 5 stars Interesting but academic
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... Read more
Published on Aug. 18 2000
5.0 out of 5 stars Seminal book, for practitioners, educators, students
This is a seminal and very timely book. It is great in many ways, but for me the greatest value of Generative Programming is in providing a unified view on major past and current... Read more
Published on Aug. 11 2000 by Stan Jarzabek
2.0 out of 5 stars Save your money
If you are a Java developer, you will find some very grating passages, which derive from the strongly C++ centric bias of the authors. Read more
Published on Aug. 4 2000
Search Customer Reviews
Only search this product's reviews

Look for similar items by category


Feedback