Programming Books C Java PHP Python Learn more Browse Programming Books

Sorry, this item is not available in
Image not available for
Color:
Image not available

To view this video download Flash Player

 


or
Sign in to turn on 1-Click ordering
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]

by Krysztof Czarnecki, Ulrich Eisenecker
4.0 out of 5 stars  See all reviews (22 customer reviews)

List Price: $64.99
Price: $42.93 & FREE Shipping. Details
You Save: $22.06 (34%)
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 4 left in stock (more on the way).
Ships from and sold by Amazon.com. Gift-wrap available.
Want it tomorrow, April 25? Choose One-Day Shipping at checkout. Details
Free Two-Day Shipping for College Students with Amazon Student

Shop the new tech.book(store)
New! Introducing the tech.book(store), a hub for Software Developers and Architects, Networking Administrators, TPMs, and other technology professionals to find highly-rated and highly-relevant career resources. Shop books on programming and big data, or read this week's blog posts by authors and thought-leaders in the tech industry. > Shop now

Book Description

June 16, 2000 0201309777 978-0201309775 1
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.

Frequently Bought Together

Generative Programming: Methods, Tools, and Applications + Language Implementation Patterns: Create Your Own Domain-Specific and General Programming Languages (Pragmatic Programmers)
Price for both: $66.89

Buy the selected items together


Editorial Reviews

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



About the Author

Krzysztof Czarnecki is a researcher and consultant with the Software Engineering Lab at DaimlerChrysler Research and Technology in Ulm, Germany. He gained firsthand experience with Aspect-Oriented Programming and Intentional Programming during research visits at the Xerox Palo Alto Research Center and the Microsoft Research in Redmond, Washington. He received an M.S. degree in computer science from California State University at Sacramento, and M.S. and Ph.D. degrees in computer science from the University of Ilmenau in Germany.

Ulrich W. Eisenecker is a professor of computer science at the University of Applied Sciences Kaiserslautern at Zweibrocken, where he chairs the department for componentware and windows interfaces. Prior to his university career he spent nearly a decade in industry. He is an editor of a special supplement on component software of the German IT magazine OBJEKTspektrum, for which he also writes a C++ column. He has published more than a hundred articles, and frequently speaks at national and international IT conferences.



0201309777AB04062001


Product Details

  • Paperback: 864 pages
  • Publisher: Addison-Wesley Professional; 1 edition (June 16, 2000)
  • Language: English
  • ISBN-10: 0201309777
  • ISBN-13: 978-0201309775
  • Product Dimensions: 9.3 x 7.4 x 1.7 inches
  • Shipping Weight: 3.2 pounds (View shipping rates and policies)
  • Average Customer Review: 4.0 out of 5 stars  See all reviews (22 customer reviews)
  • Amazon Best Sellers Rank: #142,104 in Books (See Top 100 in Books)

More About the Author

Discover books, learn about writers, read author blogs, and more.

Customer Reviews

4.0 out of 5 stars
(22)
4.0 out of 5 stars
Share your thoughts with other customers
Most Helpful Customer Reviews
101 of 103 people found the following review helpful
5.0 out of 5 stars 5 Stars with caveats....... October 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 ›
Comment | 
Was this review helpful to you?
36 of 41 people found the following review helpful
4.0 out of 5 stars Interesting for C++ template programmers August 31, 2000
Format:Paperback
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.
Comment | 
Was this review helpful to you?
15 of 17 people found the following review helpful
5.0 out of 5 stars A peek at the next level of abstraction. January 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 ›
Comment | 
Was this review helpful to you?
Most Recent Customer Reviews
5.0 out of 5 stars 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... Read more
Published on October 4, 2009 by Moises Almeida C. Branco
4.0 out of 5 stars Generative programming
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... Read more
Published on February 21, 2009 by Yuanchyuan Sheu
3.0 out of 5 stars This book has some cool stuff
This book has some cool stuff and I was quite impressed by the part on functional programming using C++ template. Read more
Published on September 12, 2007 by Z. Guo
4.0 out of 5 stars wide-ranging in scope, but heavy on C++ templates
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. Read more
Published on March 1, 2007 by Thing with a hook
4.0 out of 5 stars A useful addition
One very important lesson in problem solving is that there is no one method that always works. No matter how good you are at one technique, there will be problems for which it is... Read more
Published on November 14, 2006 by John Phillips
3.0 out of 5 stars A+ in content, C- in execution
As it is said in another review, this is a solid (and rather academic) book on the theory behind code generation. Read more
Published on February 8, 2006 by Fernando Berzal Galiano
5.0 out of 5 stars 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... Read more
Published on August 20, 2005 by G. Kiyooka
3.0 out of 5 stars Strangely boring
I bought this book because I was looking for a language-agnostic guide to generic and aspect-oriented programming. Read more
Published on June 23, 2004 by B. Hutchison
4.0 out of 5 stars An advanced work on Code Generation
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... Read more
Published on December 13, 2003 by Jack D. Herrington
4.0 out of 5 stars good book
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. Read more
Published on January 2, 2003
Search Customer Reviews
Only search this product's reviews
ARRAY(0xa3f82e64)

What Other Items Do Customers Buy After Viewing This Item?


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

Forums

There are no discussions about this product yet.
Be the first to discuss this product with the community.
Start a new discussion
Topic:
First post:
Prompts for sign-in
 



Look for Similar Items by Category