In Stock: Marketplace

Buy from our Authorized Marketplace Sellers

4 new and used from $67.36

Generative Programming : Methods, Tools, and Applications View Larger Image

Generative Programming : Methods, Tools, and Applications

Czarnecki, Krysztof (Author) Eisenecker, Ulrich (Author)

ISBN-10: 0201309777
ISBN-13: 9780201309775

Available from our Authorized Marketplace Sellers
In our Marketplace:
4 new and used from $67.36
null
Author Affiliation
Krzysztof Czarnecki is a researcher and consultant with the Software Engineering Lab at DaimlerChrysler Research and Technology in Ulm, Germany.Author Affiliation
Ulrich W. Eisenecker is a professor of computer science at the University of Applied Sciences Kaiserslautern at Zweibrucken, where he chairs the department for componentware and windows interfaces.Back Cover Copy
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).BDS Summary
The authors have been at the forefront of generative programming research. This text covers important application development issues including distribution, synchronisation, persistency and and security.Introduction or Preface
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 commu
Praise for "Generative ProgrammingP"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, ILP"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) methodP"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 approachP"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 andGenerative 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 valuableBack Cover Copy
Praise for Generative Programming The book develops strong themes around unifying principles that tie the pieces together, most notably domain engineering and metaprogramming. Its 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).Back Cover Copy
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 ProgrammingUsing 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).Long 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.
Covers methods and tools for designing and implementing the right components for a system family and automating component assembly. Methods are applicable to all commercial development, from the level of classes and procedures to developing families of large systems. Coverage encompasses domain engineering, feature modeling, and generic programming. Includes case studies in the programming, business, and scientific computing domains. Czarnecki is a research and consultant in the private sector. Eisenecker teaches computer science at the University of Applied Sciences Kaiserslautern at Zweibr:ucken. Annotation c. Book News, Inc., Portland, OR (booknews.com)
What Is This Book About?p. 1
From Handcrafting to Automated Assembly Linesp. 1
Generative Programmingp. 5
Benefits and Applicabilityp. 13
Analysis and Design Methods and Techniquesp. 17
Domain Engineeringp. 19
Why Is This Chapter Worth Reading?p. 19
What Is Domain Engineering?p. 20
Domain Analysisp. 23
Domain Design and Domain Implementationp. 24
Application Engineeringp. 30
Product-Line Practicesp. 30
Key Domain Engineering Conceptsp. 32
Domainp. 32
Domain Scope and Scopingp. 34
Relationships between Domainsp. 37
Features and Feature Modelsp. 38
Method Tailoring and Specializationp. 43
Survey of Domain Analysis and Domain Engineering Methodsp. 44
Feature-Oriented Domain Analysis (FODA)p. 44
FODA Processp. 45
Organization Domain Modeling (ODM)p. 46
The ODM Processp. 48
Dracop. 48
Capturep. 51
Domain Analysis and Reuse Environment (DARE)p. 51
Domain-Specific Software Architecture (DSSA) Approachp. 52
Algebraic Approachp. 53
Other Approachesp. 54
Domain Engineering and Related Approachesp. 55
Historical Notesp. 56
Summaryp. 57
Domain Engineering and Object-Oriented Analysis and Designp. 60
Why Is This Chapter Worth Reading?p. 60
OO Technology and Reusep. 60
Solution Spacep. 61
Problem Spacep. 61
Relationship between Domain Engineering and Object-Oriented Analysis and Design (OOA/D) Methodsp. 64
Aspects of Integrating Domain Engineering and OOA/D Methodsp. 64
Horizontal versus Vertical Methodsp. 67
Selected Methodsp. 69
Rational Unified Process 5.0p. 69
OOramp. 71
Reuse-driven Software Engineering Business (RSEB)p. 73
FeatuRSEBp. 79
Domain Engineering Method for Reusable Algorithmic Libraries (DEMRAL)p. 80
Feature Modelingp. 82
Why Is This Chapter Worth Reading?p. 82
Features Revisitedp. 82
Feature Modelingp. 83
Feature Modelsp. 86
Feature Diagramsp. 87
Mandatory Featuresp. 88
Optional Featuresp. 89
Alternative Featuresp. 90
Or-Featuresp. 91
Normalized Feature Diagramsp. 93
Expressing Commonality in Feature Diagramsp. 95
Expressing Variability in Feature Diagramsp. 95
Other Information Associated with Feature Diagrams in a Feature Modelp. 96
Assigning Priorities to Variable Featuresp. 99
Availability Sites, Binding Sites, and Binding Modesp. 100
Sitesp. 100
Availability Sitesp. 100
Binding Sites and Binding Modesp. 101
Relationship between Optimizations and Availability Sites, Binding Sites, and Binding Modesp. 101
Relationship between Feature Diagrams and Other Modeling Notations and Implementation Techniquesp. 102
Single Inheritancep. 105
Multiple Inheritancep. 107
Parameterized Inheritancep. 108
Static Parameterizationp. 111
Dynamic Parameterizationp. 112
Implementing Constraintsp. 113
Tool Support for Feature Modelsp. 114
Frequently Asked Questions about Feature Diagramsp. 116
Feature Modeling Processp. 119
How to Find Featuresp. 119
Role of Variability in Modelingp. 123
Separation of Concernsp. 123
Decomposition Techniquesp. 125
Variability in Modelingp. 128
The Process of Generative Programmingp. 131
Why Is This Chapter Worth Reading?p. 131
Generative Domain Modelsp. 131
Main Development Steps in Generative Programmingp. 134
Adapting Domain Engineering for Generative Programmingp. 135
Domain-Specific Languagesp. 137
DEMRAL: Example of a Domain Engineering Method for Generative Programmingp. 142
Outline of DEMRALp. 144
Domain Analysisp. 146
Domain Definitionp. 146
Domain Modelingp. 148
Identification of Key Conceptsp. 149
Feature Modelingp. 151
Feature Starter Set for ADTsp. 151
Feature Starter Set for Algorithmsp. 154
Domain Designp. 155
Scope Domain Model for Implementationp. 155
Identify Packagesp. 156
Develop Target Architectures and Identify the Implementation Componentsp. 156
Identify User DSLsp. 156
Identify Interactions between DSLsp. 157
Specify DSLs and Their Translationp. 157
Configuration DSLsp. 158
Expression DSLsp. 162
Domain Implementationp. 164
Implementation Technologiesp. 165
Generic Programmingp. 167
Why Is This Chapter Worth Reading?p. 167
What Is Generic Programming?p. 167
Generic versus Generative Programmingp. 170
Generic Parametersp. 171
Parametric versus Subtype Polymorphismp. 173
Genericity in Javap. 176
Bounded versus Unbounded Polymorphismp. 184
A Fresh Look at Polymorphismp. 186
Parameterized Componentsp. 190
Parameterized Programmingp. 192
Types, Interfaces, and Specificationsp. 193
Adaptersp. 195
Vertical and Horizontal Parametersp. 197
Module Expressionsp. 200
C++ Standard Template Libraryp. 201
Iteratorsp. 202
Freestanding Functions versus Member Functionsp. 203
Generic Methodologyp. 205
Historical Notesp. 209
Component-Oriented Template-Based C++ Programming Techniquesp. 211
Why Is This Chapter Worth Reading?p. 211
Types of System Configurationp. 212
C++ Support for Dynamic Configurationp. 213
C++ Support for Static Configurationp. 213
Static Typingp. 214
Static Bindingp. 214
Inliningp. 214
Templatesp. 218
Parameterized Inheritancep. 221
Typedefsp. 221
Member Typesp. 221
Nested Classesp. 222
Prohibiting Certain Template Instantiationsp. 222
Static versus Dynamic Parameterizationp. 224
Wrappers Based on Parameterized Inheritancep. 231
Template Method Based on Parameterized Inheritancep. 231
Parameterizing Binding Modep. 234
Consistent Parameterization of Multiple Componentsp. 236
Static Interactions between Componentsp. 236
Components with Influencep. 238
Components under Influencep. 240
Structured Configurationsp. 243
Recursive Componentsp. 245
Intelligent Configurationp. 248
Aspect-Oriented Programmingp. 251
Why Is This Chapter Worth Reading?p. 251
What Is Aspect-Oriented Programming?p. 252
Aspect-Oriented Decomposition Approachesp. 254
Subject-Oriented Programmingp. 254
Composition Filtersp. 256
Demeter / Adaptive Programmingp. 259
Aspect-Oriented Programmingp. 262
How Aspects Arisep. 264
Composition Mechanismsp. 267
Requirements on Composition Mechanismsp. 267
Minimal Couplingp. 267
Different Binding Times and Modesp. 270
Noninvasive Adaptabilityp. 272
Example: Synchronizing a Bounded Bufferp. 275
"Tangled" Synchronized Stackp. 278
Separating Synchronization Using Design Patternsp. 281
Separating Synchronization Using SOPp. 287
Some Problems with Design Patterns and Some Solutionsp. 292
Object Schizophreniap. 294
Preplarming Problemp. 295
Traceability Problemp. 295
Implementing Noninvasive, Dynamic Composition in Smalltalkp. 296
Model of the Compositionp. 296
Composition APIp. 297
Instance-Specific Extension Protocolp. 298
Defining Methods in Instancesp. 299
Adding Instance Variables to Instancesp. 301
Kinds of Crosscuttingp. 303
How to Express Aspects in Programming Languagesp. 305
Separating Synchronization Using AspectJ Coolp. 306
Implementing Dynamic Cool in Smalltalkp. 310
Example: Synchronizing an Assembly Systemp. 310
Architecture of the Smalltalk Implementation of Dynamic Coolp. 315
Implementation Technologies for Aspect-Oriented Programmingp. 317
Technologies for Implementing Aspect-Specific Abstractionsp. 317
Technologies for Implementing Weavingp. 321
AOP and Specialized Language Extensionsp. 328
AOP and Active Librariesp. 328
Final Remarksp. 331
Generatorsp. 332
Why Is This Chapter Worth Reading?p. 332
What Are Generators?p. 333
Transformational Model of Software Developmentp. 335
Technologies for Building Generatorsp. 339
Compositional versus Transformational Generatorsp. 341
Kinds of Transformationsp. 344
Compiler Transformationsp. 344
Refinementsp. 344
Optimizationsp. 345
Source-to-Source Transformationsp. 348
Transformation Systemsp. 350
Scheduling Transformationsp. 352
Existing Transformation Systems and Their Applicationsp. 355
Selected Approaches to Generationp. 357
Dracop. 357
GenVocap. 363
Example: Applying GenVoca to the Domain of Data Containersp. 364
GenVoca Modelp. 366
Defining Realms and Layers in P++p. 372
Implementing GenVoca Layers in C++p. 375
Composition Validationp. 385
Transformations and GenVocap. 387
Frameworks and GenVocap. 388
Approaches Based on Algebraic Specificationsp. 389
Static Metaprogramming in C++p. 397
Why Is This Chapter Worth Reading?p. 397
What Is Metaprogramming?p. 398
A Quick Tour of Metaprogrammingp. 399
Static Metaprogrammingp. 405
C++ As a Two-Level Languagep. 406
Functional Flavor of the Static Levelp. 410
Class Templates As Functionsp. 410
Integers and Types As Datap. 411
Symbolic Names Instead of Variablesp. 411
Constant Initialization and typedef-Statements Instead of Assignmentp. 411
Template Recursion Instead of Loopsp. 412
Conditional Operator and Template Specialization As Conditional Constructsp. 413
Template Metaprogrammingp. 413
Template Metafunctionsp. 414
Metafunctions As Arguments and Return Values of Other Metafunctionsp. 416
Representing Metainformationp. 418
Member Traitsp. 419
Traits Classesp. 420
Traits Templatesp. 421
Example: Using Template Metafunctions and Traits Templates to Implement Type Promotionsp. 425
Compile-Time Lists and Trees As Nested Templatesp. 427
Compile-Time Control Structuresp. 433
Explicit Selection Constructs (? : , IF[], and SWITCH[])p. 433
Implementing IF[] without Partial Template Specializationp. 434
Switch Construct (SWITCH[])p. 436
Taking Advantage of Lazy Behaviorp. 438
SWITCH[] without Partial Template Specializationp. 444
Template Recursion As a Looping Constructp. 444
Explicit Looping Constructs (WHILE[], DO[], and FOR[])p. 451
While-Loop (WHILE[])p. 451
Do-Loop (DO[])p. 455
For-Loop (FOR[])p. 459
Code Generationp. 462
Simple Code Selectionp. 462
Composing Templatesp. 464
Generators Based on Expression Templatesp. 464
Recursive Code Expansionp. 465
Explicit Loops for Generating Code (EWHILE[], EDO[], and EFOR[])p. 473
EWHILE[]p. 473
EDO[]p. 476
EFOR[]p. 477
Nesting Static E-Loopsp. 479
Example: Using Static Execute Loops to Test Metafunctionsp. 487
Partial Evaluation in C++p. 493
Workarounds for Partial Template Specializationp. 497
Problems of Template Metaprogrammingp. 499
Historical Notesp. 499
Intentional Programmingp. 503
Why Is This Chapter Worth Reading?p. 503
What Is Intentional Programming?p. 504
Technology behind IPp. 510
System Architecturep. 510
Representing Programs in IP: The Source Graphp. 512
Treelike Structuresp. 513
Graphlike Structuresp. 513
Source Graphs: The Big Picturep. 516
The Essence of Source Graphs: Abstraction Sharing and Parameterizationp. 518
Source Graph + Methods = Active Sourcep. 518
Kinds of Methodsp. 519
Working with the IP Programming Environmentp. 522
Editingp. 524
Further Capabilities of the IP Editorp. 528
Extending the IP System with New Intentionsp. 537
Advanced Topicsp. 541
Questions, Methods, and a Frameworklike Organizationp. 542
Source-Pattem-Based Polymorphismp. 543
Methods As Visitorsp. 545
Asking Questions Synchronously and Asynchronouslyp. 546
Reductionp. 547
The Philosophy behind IPp. 551
Why Do We Need Extendible Programming Environments? or What Is the Problem with Fixed Programming Languages?p. 551
Problems with General-Purpose Languages and Conventional Librariesp. 551
Problems with Comprehensive Application-Specific Languagesp. 553
The IP Solution: An Extendible Programming Environmentp. 555
Moving Focus from Fixed Languages to Language Features and the Emergence of an Intention Marketp. 556
Intentional Programming and Component-Based Developmentp. 557
Frequently Asked Questionsp. 559
Summaryp. 566
Application Examplesp. 569
List Containerp. 571
Why Is This Chapter Worth Reading?p. 571
Overviewp. 571
Domain Analysisp. 572
Domain Designp. 573
Implementation Componentsp. 577
Manual Assemblyp. 583
Specifying Listsp. 586
The Generatorp. 586
Extensionsp. 590
Bank Accountp. 593
Why Is This Chapter Worth Reading?p. 593
The Successful Programming Shopp. 593
Design Pattems, Frameworks, and Componentsp. 596
Domain Engineering and Generative Programmingp. 597
Feature Modelingp. 599
Architecture Designp. 600
Implementation Componentsp. 603
Configurable Class Hierarchiesp. 610
Designing a Domain-Specific Languagep. 612
Bank Account Generatorp. 619
Testing Generators and Their Productsp. 623
Generative Matrix Computation Library (GMCL)p. 624
Why Is This Chapter Worth Reading?p. 624
Why Matrix Computations?p. 625
Domain Analysisp. 626
Domain Definitionp. 626
Domain Modelingp. 628
Domain Design and Implementationp. 634
Matrix Type Generationp. 638
Target Architecture and Matrix Implementation Componentsp. 639
Matrix Configuration DSLp. 654
Matrix Configuration Generatorp. 661
Configuration DSL Parserp. 664
Assigning Defaults to DSL Featuresp. 666
Matrix Component Assemblerp. 672
Generating Code for Matrix Expressionsp. 678
Evaluating Matrix Expressionsp. 678
Modeling the Elementwise Expression Evaluation Using Objectsp. 680
Overview of the Implementationp. 685
Matrix Operator Templatesp. 686
Matrix Expression Templatesp. 690
Matrix Cachep. 696
Generating getElementp. 698
Metafunctions for Computing Result Types of Expressionsp. 701
Generating Matrix Assignmentp. 706
Lessons Learnedp. 708
Problems with Template Metaprograrnmingp. 710
Implementing the Matrix Component in IPp. 713
Appendicesp. 719
Conceptual Modelingp. 721
What Are Concepts?p. 721
Theories of Conceptsp. 722
Basic Terminologyp. 723
The Classical Viewp. 724
The Probabilistic Viewp. 727
The Exemplar Viewp. 728
Summary of the Three Viewsp. 728
Important Issues Concerning Conceptsp. 730
Stability of Conceptsp. 730
Concept Corep. 731
Informational Contents of Featuresp. 732
Feature Composition and Relationships between Featuresp. 732
Quality of Featuresp. 733
Abstraction and Generalizationp. 733
Conceptual Modeling, Object-Orientation, and Software Reusep. 736
Instance-Specific Extension Protocol for Smalltalkp. 738
Protocol for Attaching Listener Objects in Smalltalkp. 741
Glossary of Matrix Computation Termsp. 746
Metafunction for Evaluating Dependency Tablesp. 749
Glossary of Generative Programming Termsp. 754
Referencesp. 757
Indexp. 799
Table of Contents provided by Syndetics. All Rights Reserved.
null
Edition: 2000
Publisher: Addison Wesley Professional
Binding: Trade Paper
Pages: 864
Size: 7.50" wide x 9.00" long x 1.50" tall
Weight: 2.88 lbs.
Language: English

100% Money Back Guarantee: Wrong item? No problem! Our hassle-free returns policy has you covered. We'll also process your order within 24 hours. Learn more about our shipping policy.


About TextbooksRus.com

TextbooksRus.com is dedicated to providing customers with the lowest prices on textbooks, trade books and professional books. In addition to low prices, TextbooksRus.com offers a buyback system that is unparalleled by competitors.
© 2002-2010, TextbooksRus.com