Generative Programming: Methods, Tools, and Applications (Paperback)
Krysztof Czarnecki, Ulrich Eisenecker
- 出版商: Addison Wesley
- 出版日期: 2000-06-06
- 售價: $2,275
- 貴賓價: 9.5 折 $2,161
- 語言: 英文
- 頁數: 864
- 裝訂: Paperback
- ISBN: 0201309777
- ISBN-13: 9780201309775
立即出貨(限量) (庫存=3)
買這商品的人也買了...
-
$1,050$1,029 -
$2,500$2,375 -
$680$578 -
$1,750$1,663 -
$980$833 -
$1,274Computer Architecture: A Quantitative Approach, 3/e(精裝本)
-
$1,600$1,568 -
$780$741 -
$760$600 -
$590$466 -
$720$612 -
$990$782 -
$750$638 -
$560$476 -
$490$417 -
$480$379 -
$750$638 -
$550$468 -
$650$553 -
$520$411 -
$880$695 -
$399$339 -
$300$270 -
$730$694 -
$1,580$1,501
相關主題
商品描述
Description
Generative programming: Breakthrough techniques for automating the creation of software systems.
- Building generative models: overcoming the limitations of traditional object-oriented modeling.
- Aspect-Oriented Programming, metaprogramming, next-generation code generators, and more.
- Includes illustrative sample code in C, C++, and Java, and three detailed, start-to-finish case studies.
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.
Krzysztof Czarnecki is a Ph.D. candidate at the University of Ilmenau, Department of Software Engineering and Media Technology, and a researcher at the DaimlerChrysler AG Research Center in Ulm, Germany. Ulrich Eisenecker, a faculty member in Computer Science and Microsystem Engineering at the University of Applied Sciences Kaiserslautern. He was formerly a researcher at Daimler-Benz Research Center in Ulm, Germany.
Appropriate Courses
C++--Intermediate Programming.
Table Of Contents
1. What Is This Book About?
Generative Programming.
Benefits and Applicability.
I. ANALYSIS AND DESIGN METHODS AND TECHNIQUES.
2. Domain Engineering.
What Is Domain Engineering?
Domain Analysis.
Domain Design and Domain Implementation.
Application Engineering.
Product-Line Practices.
Key Domain Engineering Concepts.
Domain Scope and Scoping.
Relationships between Domains.
Features and Feature Models.
Method Tailoring and Specialization.
Survey of Domain Analysis and Domain Engineering Methods.
Organization Domain Modeling (ODM).
Draco.
Capture.
Domain Analysis and Reuse Environment (DARE).
Domain-Specific Software Architecture (DSSA) Approach.
Algebraic Approach.
Other Approaches.
Domain Engineering and Related Approaches.
Historical Notes.
Summary.
3. Domain Engineering and Object-Oriented Analysis and Design.
OO Technology and Reuse.
Problem Space.
Relationship between Domain Engineering and Object-Oriented Analysis and Design (OOA/D) Methods.
Aspects of Integrating Domain Engineering and OOA/D Methods.
Horizontal versus Vertical Methods.
Selected Methods.
00ram.
Reuse-Driven Software Engineering Business (RSEB).
FeatuRSEB.
Domain Engineering Method for Reusable Algorithmic Libraries (DEMRAL).
4. Feature Modeling.
Features Revisited.
Feature Modeling.
Feature Models.
Other Infon-Nation Associated with Feature Diagrams in a Feature Model.
Assigning Priorities to Variable Features.
Availability Sites, Binding Sites, and Binding Modes.
Relationship between Feature Diagrams and Other Modeling Notations and Implementation Techniques.
Multiple Inheritance.
Parameterized Inheritance.
Static Parameterization.
Dynamic Parameterization.
Implementing Constraints.
Tool Support for Feature Models.
Frequently Asked Questions about Feature Diagrams.
Feature Modeling Process.
Role of Variability in Modeling.
5. The Process of Generative Programming.
Generative Domain Models.
Main Development Steps in Generative Programming.
Adapting Domain Engineering for Generative Programming.
Domain-Specific Languages.
DEMRAL: Example of a Domain Engineering Method for Generative Programming.
Outline of DEMRAL.
Domain Analysis.
Domain Modeling.
Domain Design.
Identify Packages.
Develop Target Architectures and Identify the Implementation Components.
Identify User DSLs.
Identify Interactions between DSLs.
Specify DSLs and Their Translation.
Configuration DSLs.
Expression DSLs.
Domain Implementation.
II. IMPLEMENTATION TECHNOLOGIES.
6. Generic Programming.
What Is Generic Programming?
Generic versus Generative Programming.
Generic Parameters.
Parametric versus Subtype Polymorphism.
Bounded versus Unbounded Polymorphism.
A Fresh Look at Polymorphism.
Parameterized Components.
Parameterized Programming.
Adapters.
Vertical and Horizontal Parameters.
Module Expressions.
C++ Standard Template Library.
Freestanding Functions versus Member Functions.
Generic Methodology.
Historical Notes.
7. Component-Oriented Template-Based C++ Programming Techniques.
Types of System Configuration.
C++ Support for Dynamic Configuration.
C++ Support for Static Configuration.
Static Binding.
Inlining.
Templates.
Parameterized Inheritance.
typedefs.
Member Types.
Nested Classes.
Prohibiting Certain Template Instantiations.
Static versus Dynamic Parameterization.
Wrappers Based on Parameterized Inheritance.
Template Method Based on Parameterized Inheritance.
Parameterizing Binding Mode.
Consistent Parameterization of Multiple Components.
Static Interactions between Components.
Components under Influence.
Structured Configurations.
Recursive Components.
Intelligent Configuration.
8. Aspect-Oriented Decomposition and Composition.
What Is Aspect-Oriented Programming?
Aspect-Oriented Decomposition Approaches.
Composition Filters.
Demeter / Adaptive Programming.
Aspect-Oriented Decomposition and Domain Engineering.
How Aspects Arise.
Composition Mechanisms.
Example: Synchronizing a Bounded Buffer.
“Tangled” Synchronized Stack.
Separating Synchronization Using Design Patterns.
Separating Synchronization Using SOP.
Some Problems with Design Patterns and Some Solutions.
Implementing Noninvasive, Dynamic Composition in Smalltalk.
Kinds of Crosscutting.
How to Express Aspects in Programming Languages.
Implementing Dynamic Cool in Smalltalk.
Implementation Technologies for Aspect-Oriented Programming.
Technologies for Implementing Weaving.
AOP and Specialized Language Extensions.
AOP and Active Libraries.
Final Remarks.
9. Generators.
What Are Generators?
Transformational Model of Software Development.
Technologies for Building Generators.
Compositional versus Transformational Generators.
Kinds of Transformations.
Source-to-Source Transformations.
Transformation Systems.
Existing Transformation Systems and Their Applications.
Selected Approaches to Generation.
GenVoca.
Approaches Based on Algebraic Specifications.
10. Static Metaprogramming in C++.
What Is Metaprogramming?
A Quick Tour of Metaprogramming.
Static Metaprogramming.
C++ as a Two-Level Language.
Functional Flavor of the Static Level.
Integers and Types as Data.
Symbolic Names Instead of Variables.
Constant Initialization and typedef-Statements Instead of Assignment.
Template Recursion Instead of Loops.
Conditional Operator and Template Specialization as Conditional Constructs.
Template Metaprogramming.
Template Metafunctions.
Metafinctions as Arguments and Return Values of Other Metafinctions.
Representing Metainformation.
Traits Classes.
Traits Templates.
Example: Using Template Metafunctions and Traits Templates to Implement Type Promotions.
Compile-Time Lists and Trees as Nested Templates.
Compile-Time Control Structures.
Template Recursion as a Looping Construct.
Explicit Looping Constructs.
Code Generation.
Composing Templates.
Generators Based on Expression Templates.
Recursive Code Expansion.
Explicit Loops for Generating Code.
Example: Using Static Execute Loops to Test Metafunctions.
Partial Evaluation in C++.
Workarounds for Partial Template Specialization.
Problems of Template Metaprogramming.
Historical Notes.
11. Intentional Programming.
What Is Intentional Programming?
Technology behind IP.
Representing Programs in IP: The Source Graph.
Source Graph + Methods = Active Source.
Working with the IP Programming Environment.
Further Capabilities of the IP Editor.
Extending the IP System with New Intentions.
Advanced Topics.
Source-Pattem-Based Polymorphism.
Methods as Visitors.
Asking Questions Synchronously and Asynchronously.
Reduction.
The Philosophy behind IP.
Moving Focus from Fixed Languages to Language Features and the Emergence of an Intention Market.
Intentional Programming and Component-Based Development.
Frequently Asked Questions.
Summary.
III. APPLICATION EXAMPLES.
12. List Container.
Overview.
Domain Analysis.
Domain Design.
Implementation Components.
Manual Assembly.
Specifying Lists.
The Generator.
Extensions.
13. Bank Account.
The Successful Programming Shop.
Design Pattems, Frameworks, and Components.
Domain Engineering and Generative Programming.
Feature Modeling.
Architecture Design.
Implementation Components.
Configurable Class Hierarchies.
Designing a Domain-Specific Language.
Bank Account Generator.
Testing Generators and Their Products.
14. Generative Matrix Computation Library (GMCL).
Why Matrix Computations?
Domain Analysis.
Domain Modeling.
Domain Design and Implementation.
Generating Code for Matrix Expressions.
Implementing the Matrix Component in IP.
APPENDICES.
Appendix A: Conceptual Modeling.
Theories of Concepts.
The Classical View.
The Probabilistic View.
The Exemplar View.
Summary of the Three Views.
Important Issues Concerning Concepts.
Concept Core.
Informational Contents of Features.
Feature Composition and Relationships between Features.
Quality of Features.
Abstraction and Generalization.
Conceptual Modeling, Object-Orientation, and Software Reuse.
Appendix B: Instance-Specific Extension Protocol for Smalltalk.
Appendix C: Protocol for Attaching Listener Objects in Smalltalk.
Appendix D: Glossary of Matrix Computation Terms.
Appendix E: Metafunction for Evaluating Dependency Tables.
Glossary of Generative Programming Terms.
References.
Index. 020130977T04062001