Generative Programming: Methods, Tools, and Applications 1st Edition by Krysztof Czarnecki (PDF)

Description

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.

User’s Reviews

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

Reviews from Amazon users which were colected at the time this book was published on the website:

⭐The packaging was too thin (plástic bag), and part of the book was folded so I will have to put some weight on it to fix it. Otherwise OK.

⭐This book has some cool stuff and I was quite impressed by the part on functional programming using C++ template. Do you know C++ template has the same computing power as a Tuning machine.

⭐This book has revolutionary concepts and practical solutions on how to capture the variability in software in anorderly 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.

⭐very good book, especially for programmers c ++

⭐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. If you don’t know C++, or are a bit fuzzy on template syntax, you’ll be missing a lot. Consider this a C++ template metaprogramming book, with some bonus chapters to put it all in context.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!

⭐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 entirely unsuitable. When applied to programming this implies that anyone who wants to be good at problem analysis and program design should always be on the lookout for new methods.Generative Programming provides an introduction to a collection of methods that are not commonly known. These methods are not the only possible way to produce high quality programs in a reasonable amount of time, but they are very useful for certain types of problems. Most exciting for me are the feature and aspect based decompositions of a problem.Aspects and features are not always easily represented in more common analysis tools, as is explain in the book, but a proper understanding of the features and aspects in your program can greatly improve design.Also useful is an extended discussion of techniques that can simplify code generation for programs that are compositions of features and aspects. This involves selecting the features needed and allowing the preprocessor and compiler to generate code on the fly. In lare software systems, this technique greatly reduces program complexity and improves readability.While I recommend this book, it is with a few qualifications.First, just as no other techniques are right for every problem, these are not either. Always check to see if the tools are right for the job before applying them. In this case, the tools in this book are rarely a good choice for small projects or for functions that will only be used one way. They are better suited to creating code that can be reused in a variety of different circumstances, or large libraries of code to support a broad user base.Second, though the book has a ton of useful information, it is not always the most readable way to present the information. The writing is fairly dense, and spends more time surveying the historical development of some of the tools than I would prefer.Finally, though the tools presented can be used in a wide variety of languages, the presentation is mainly done in C++. Comfort with the language will be essential for anyone wishing to understand the techniques presented.

⭐As I’m writing the review, the year is 2013 and I think by now most people recognize that while C++ template metaprogramming is ‘quaint’ and can, in certain cases, produce excellent results, we’re way past the situation where this would actually be recommended in a production setting. Alexandrescu himself went off to work with Walter Bright on D instead (see

⭐The D Programming Language

⭐), and this book, which actually has a feed of a PhD thesis on system-level software engineering, serves as a reminder that not all methodologies survive and thrive, and that some are left by the wayside. Don’t get me wrong, C++ is still alive and kicking, and there may be some uses to metaprogramming-based design, but abusing the preprocessor to evaluate templates at compile time and build structures is something that D also does very well with its mixins and without so much template magic.

⭐If you tried the book “C++ Template Metaprogramming” (from the “C++ in-depth” series) and would just like to have another way to get the point, then use this book. Chapter 10 “Static Metaprogramming in C++” is really helpful. But this book has much more (e.g. aspect-oriented programming). I also like the lots of cross-references to other useful books and publications. It’s within my top-five books for programming.

⭐Mejor de lo que esperaba. Un buen libro para ampliar conocimientos de c++, y aprender técnicas poco usuales mediante explicaciones y ejemplos claros.

⭐

Keywords

Free Download Generative Programming: Methods, Tools, and Applications 1st Edition in PDF format
Generative Programming: Methods, Tools, and Applications 1st Edition PDF Free Download
Download Generative Programming: Methods, Tools, and Applications 1st Edition 2000 PDF Free
Generative Programming: Methods, Tools, and Applications 1st Edition 2000 PDF Free Download
Download Generative Programming: Methods, Tools, and Applications 1st Edition PDF
Free Download Ebook Generative Programming: Methods, Tools, and Applications 1st Edition