- Paperback: 864 pages
- Publisher: Addison-Wesley Professional; 1 edition (June 16, 2000)
- Language: English
- ISBN-10: 0201309777
- ISBN-13: 978-0201309775
- Product Dimensions: 7.5 x 1.6 x 9 inches
- Shipping Weight: 3.2 pounds (View shipping rates and policies)
- Average Customer Review: 24 customer reviews
Amazon Best Sellers Rank:
#772,638 in Books (See Top 100 in Books)
- #82 in Books > Computers & Technology > Hardware & DIY > Microprocessors & System Design > Computer Design
- #265 in Books > Computers & Technology > Networking & Cloud Computing > Data in the Enterprise > Client-Server Systems
- #833 in Books > Textbooks > Computer Science > Software Design & Engineering
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Generative Programming: Methods, Tools, and Applications 1st Edition
Use the Amazon App to scan ISBNs and compare prices.
Fulfillment by Amazon (FBA) is a service we offer sellers that lets them store their products in Amazon's fulfillment centers, and we directly pack, ship, and provide customer service for these products. Something we hope you'll especially enjoy: FBA items qualify for FREE Shipping and Amazon Prime.
If you're a seller, Fulfillment by Amazon can help you increase your sales. We invite you to learn more about Fulfillment by Amazon .
Frequently bought together
Customers who bought this item also bought
Customers who viewed this item also viewed
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++
- 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.
Top customer reviews
There was a problem filtering reviews right now. Please try again later.
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.
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!
Most recent customer reviews
orderly and predictable way and more important how to provide...Read more