Rating: 
Summary: 5 Stars with caveats.......
Review: 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 tools that will change the world (C# anyone????) Chapter 12-14 - The final chapters describe how to build template class generators that allow the application programming to specify functionality as a template parameter and the generator will build the type. It's as close to GP as we can get today. A list container class, bank account class and a highly optimized matrix library are designed using the GP methodology. It's nice to see the authors actually practicing what they preach. Aside from the overly academic feel to the book and touting Microsoft fantasy-ware (which may become available... who knows?) this book offers much food for thought for system designers and C++ library implementers. The template tricks described are difficult to debug but with a little luck future compilers will provide better support for this style of compile time design. I look forward to the 2nd or 3rd edition of this book when this stuff matures.
Rating: 
Summary: A valuable and detailed book, rich in content
Review: 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.
Rating:
Summary: A valuable and detailed book, rich in content
Review: 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.
Rating:
Summary: good book
Review: 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.
Rating:
Summary: A major book
Review: This is a major book, bound to influence the future direction of programming. The scope is wide; "big picture" discussions, reviews of existing systems, explicit "how-to-do-it" instructions, and case studies. Should be read by anyone designing reusable systems, particularly those with lots of variability. Interesting to intermediate and advanced programmers and designers. Not of much interest to beginners.
Rating:
Summary: Very informative, interesting and fun to read
Review: 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 trends in software engineering. Last two decades have seen many trends whose proponents were promising major breakthroughs in the way to develop software, that would lead to orders of magnitude improvements in software productivity. 4GL, automatic programming, CASE tools, Objet-oriented methods and most recently, component-based software development are just some of the examples. While most of these promises remained unfulfilled, each wave of thought had merits and lasting contributions. Generative Programming paints a big picture of where we are in software engineering, puts past and current trends into a perspective from which we can see their contributions and shortcomings. For software engineering practitioners and researchers, the book is a guideline in the jungle of contraditing opinions and terminological mess that proliferates the discipline.
Rating:
Summary: Seminal book, for practitioners, educators, students
Review: 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 trends in software engineering. Last two decades have seen many trends whose proponents were promising major breakthroughs in the way to develop software, that would lead to orders of magnitude improvements in software productivity. While most of promises remained unfulfilled, each wave of thought had merits and lasting contributions. Generative Programming paints a big picture of where we are in software engineering, puts past and current trends into a perspective from which we can see their contributions and shortcomings. For software engineering practitioners and researchers, the book is a guideline in the jungle of contradicting opinions and terminological mess that proliferates the discipline. In recent years, we've seen a growing awareness that the major source of trouble in large-scale software development are computational aspects that spread through functional modules. The idea goes back to the Dijkstra's concept of "separation of concerns". There are a number of initiatives (all of them are described in book) to tackle the problem of such de-localized computational aspects. Software architecture is the conceptual means to achieve separation of concerns and generative programming techniques provide automatic means for program composition out of separately defined computational aspects. The book explains in a very clear way how generative techniques can help us overcome problems with reuse and evolution of objects and components. With permission of authors, I used chapters from Generative Programming in the graduate course on Product Line approach (the book was not published yet at that time). In opinion of my students and my own too, the book provides an excellent and systematic discussion of a Product Line approach and issues that matter in domain engineering. The book is very informative, interesting and fun to read.
Rating:
Summary: Very informative, interesting and fun to read
Review: 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 trends in software engineering. Last two decades have seen many trends whose proponents were promising major breakthroughs in the way to develop software, that would lead to orders of magnitude improvements in software productivity. 4GL, automatic programming, CASE tools, Objet-oriented methods and most recently, component-based software development are just some of the examples. While most of these promises remained unfulfilled, each wave of thought had merits and lasting contributions. Generative Programming paints a big picture of where we are in software engineering, puts past and current trends into a perspective from which we can see their contributions and shortcomings. For software engineering practitioners and researchers, the book is a guideline in the jungle of contraditing opinions and terminological mess that proliferates the discipline.
Rating:
Summary: An advanced work on Code Generation
Review: 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.
Rating:
Summary: From domain analysis to hard code
Review: This is an impressive book. You could guess that immediately from the number of pages, but on the other hand thick books are quite common nowadays in computer science. What sets this book apart is that it really contains a lot of information on a wide range of subjects, spanning almost the complete software design process from its initial analysis stages to the production of actual code. And it covers not just the development of a single software program, but a complete family of programs (this is where the "generative" part comes in). Despite this broad scope and high complexity, the material is organized into a coherent whole and it is well illustrated with examples of a considerable size. I only regret that the examples are of a rather academic nature and that the book gives very little information about how to test the software under development. All in all, I can recommend this book to anyone who is not afraid of starting at the mountain top of domain analysis and then descending to get their feet wet in the swamp (excusez le mot) of C++ code. There are so many interesting sights to see on that journey.
| 
