Generators take a high-level software specification and produce an implementation. GenVoca is an approach to building generators that composes reusable component layers. It models software as realms of components with vertical and horizontal parameters. Components are implemented as C++ templates containing member classes. Composition validation ensures semantics are correct. Aspect-oriented programming (AOP) and GenVoca both aim to improve code reuse but differ in focus, concepts, and implementation mechanisms like aspect languages versus type expressions. Generators automate implementation through transformations while GenVoca provides a systematic approach through composable and customizable components.
L0001 - The Terminology of the Eclipse PlatformTonny Madsen
This is a basic walk-through of all the central concepts of the Eclipse platform and how these fit together. The primary goal of this module is to establish a common terminology.
L0001 - The Terminology of the Eclipse PlatformTonny Madsen
This is a basic walk-through of all the central concepts of the Eclipse platform and how these fit together. The primary goal of this module is to establish a common terminology.
Efficient and Advanced Omniscient Debugging for xDSMLs (SLE 2015)Benoit Combemale
Talk given at the 8th ACM SIGPLAN Int'l Conf. on Software Language Engineering (SLE 2015), Pittsburgh, PA, USA on October 27, 2015. Preprint available at https://hal.inria.fr/hal-01182517
EclipseCon Eu 2015 - Breathe life into your Designer!melbats
You have your shiny new DSL up and running thanks to the Eclipse Modeling Technologies and you built a powerful tooling with graphical modelers, textual syntaxes or dedicated editors to support it. But how can you see what is going on when a model is executed ? Don't you need to simulate your design in some way ? Wouldn't you want to see your editors being animated directly within your modeling environment based on execution traces or simulator results?
The GEMOC Research Project designed a methodology to bring animation and execution analysis to DSLs. The companion technologies required to put this in action are small dedicated components (all open-source) at a "proof of concept" maturity level extending proven components : Sirius, Eclipse Debug, Xtend making such features within the reach of Eclipse based tooling. The general intent regarding those OSS technologies is to leverage them within different contexts and contribute them to Eclipse once proven strong enough. The method covers a large spectrum of use cases from DSLs with a straightforward execution semantic to a combination of different DSLs with concurrent execution semantic. Any tool provider can leverage both the technologies and the method to provide an executable DSL and animated graphical modelers to its users enabling simulation and debugging at an early phase of the design.
This talk presents the approach, the technologies and demonstrate it through an example: providing Eclipse Debug integration and diagram animation capabilities for Arduino Designer (EPL) : setting breakpoints, stepping forward or backward in the execution, inspecting the variables states... We will walk you through the steps required to develop such features, the choices to make and the trade-offs involved. Expects live demos with simulated blinking leds and a virtual cat robot !
Compilers have been improving programmer productivity ever since IBM produced the first FORTRAN compiler in 1957. Today, we mostly take them for granted but even after more than 60 years, compiler researchers and practitioners continue to push the boundaries for what compilers can achieve as well as how easy it is to leverage the sophisticated code bases that encapsulate those six decades of learning in this field. In this talk, I want to highlight how industry trends like the migration to cloud infrastructures and data centers as well as the rise of flexibly licensed open source projects like LLVM and Eclipse OMR are paving the way towards even more effective and powerful compilation infrastructures than have ever existed: compilers with the opportunity to contribute to programmer productivity in even more ways than simply better hardware instruction sequences, and with simpler APIs so they can be readily used in scenarios where even today's most amazing Just In Time compilers are not really practical.
For this info-packed and hands-on workshop we cover:
📍 Introduction to Kubernetes & GitOps talk:
We cover the most popular path that has brought success to many users already - GitOps as a natural evolution of Kubernetes. We'll give an overview of how you can benefit from Kubernetes and GitOps: greater security, reliability, velocity and more. Importantly, we cover definitions and principles standardized by the CNCF's OpenGitOps group and what it means for you.
📍 Get Started with GitOps:
You'll have GitOps up and running in about 30 mins using our free and open source tools! We'll give a brief vision of where you want to be with those security, reliability, and velocity benefits, and then we'll support you while go through the getting started steps. During the workshop, you'll also experience in action and see demos for:
- an opinionated repo structure to minimize decision fatigue
- disaster recovery using GitOps
- Helm charts example
- Multi-cluster example
- all with free and open source tools mostly in the CNCF (eg. Flux and Helm).
If you have questions before or after the workshop, talk to us at #weave-gitops http://bit.ly/WeaveGitOpsSlack (If you need to invite yourself to the Slack, visit https://slack.weave.works/)
Uncover the mysteries of infrastructure as code (iac)!Prashant Kalkar
In the era of cloud and containerisation, infrastructure as code (IAC) is invaluable. In this talk, we will explore the evolution of Infrastructure practices and tools. We will further look at the practices and tools before the emergence of the clouds. Then we will explore how the rise of the cloud changed the infrastructure automation practices and made the IAC a mainstream practice.
We will also explore what it means to treat infrastructure as code. We will talk about Code vs Configuration, versioning, Configurability vs Standardisation, Modularity and code organisation for infrastructure code.
Efficient and Advanced Omniscient Debugging for xDSMLs (SLE 2015)Benoit Combemale
Talk given at the 8th ACM SIGPLAN Int'l Conf. on Software Language Engineering (SLE 2015), Pittsburgh, PA, USA on October 27, 2015. Preprint available at https://hal.inria.fr/hal-01182517
EclipseCon Eu 2015 - Breathe life into your Designer!melbats
You have your shiny new DSL up and running thanks to the Eclipse Modeling Technologies and you built a powerful tooling with graphical modelers, textual syntaxes or dedicated editors to support it. But how can you see what is going on when a model is executed ? Don't you need to simulate your design in some way ? Wouldn't you want to see your editors being animated directly within your modeling environment based on execution traces or simulator results?
The GEMOC Research Project designed a methodology to bring animation and execution analysis to DSLs. The companion technologies required to put this in action are small dedicated components (all open-source) at a "proof of concept" maturity level extending proven components : Sirius, Eclipse Debug, Xtend making such features within the reach of Eclipse based tooling. The general intent regarding those OSS technologies is to leverage them within different contexts and contribute them to Eclipse once proven strong enough. The method covers a large spectrum of use cases from DSLs with a straightforward execution semantic to a combination of different DSLs with concurrent execution semantic. Any tool provider can leverage both the technologies and the method to provide an executable DSL and animated graphical modelers to its users enabling simulation and debugging at an early phase of the design.
This talk presents the approach, the technologies and demonstrate it through an example: providing Eclipse Debug integration and diagram animation capabilities for Arduino Designer (EPL) : setting breakpoints, stepping forward or backward in the execution, inspecting the variables states... We will walk you through the steps required to develop such features, the choices to make and the trade-offs involved. Expects live demos with simulated blinking leds and a virtual cat robot !
Compilers have been improving programmer productivity ever since IBM produced the first FORTRAN compiler in 1957. Today, we mostly take them for granted but even after more than 60 years, compiler researchers and practitioners continue to push the boundaries for what compilers can achieve as well as how easy it is to leverage the sophisticated code bases that encapsulate those six decades of learning in this field. In this talk, I want to highlight how industry trends like the migration to cloud infrastructures and data centers as well as the rise of flexibly licensed open source projects like LLVM and Eclipse OMR are paving the way towards even more effective and powerful compilation infrastructures than have ever existed: compilers with the opportunity to contribute to programmer productivity in even more ways than simply better hardware instruction sequences, and with simpler APIs so they can be readily used in scenarios where even today's most amazing Just In Time compilers are not really practical.
For this info-packed and hands-on workshop we cover:
📍 Introduction to Kubernetes & GitOps talk:
We cover the most popular path that has brought success to many users already - GitOps as a natural evolution of Kubernetes. We'll give an overview of how you can benefit from Kubernetes and GitOps: greater security, reliability, velocity and more. Importantly, we cover definitions and principles standardized by the CNCF's OpenGitOps group and what it means for you.
📍 Get Started with GitOps:
You'll have GitOps up and running in about 30 mins using our free and open source tools! We'll give a brief vision of where you want to be with those security, reliability, and velocity benefits, and then we'll support you while go through the getting started steps. During the workshop, you'll also experience in action and see demos for:
- an opinionated repo structure to minimize decision fatigue
- disaster recovery using GitOps
- Helm charts example
- Multi-cluster example
- all with free and open source tools mostly in the CNCF (eg. Flux and Helm).
If you have questions before or after the workshop, talk to us at #weave-gitops http://bit.ly/WeaveGitOpsSlack (If you need to invite yourself to the Slack, visit https://slack.weave.works/)
Uncover the mysteries of infrastructure as code (iac)!Prashant Kalkar
In the era of cloud and containerisation, infrastructure as code (IAC) is invaluable. In this talk, we will explore the evolution of Infrastructure practices and tools. We will further look at the practices and tools before the emergence of the clouds. Then we will explore how the rise of the cloud changed the infrastructure automation practices and made the IAC a mainstream practice.
We will also explore what it means to treat infrastructure as code. We will talk about Code vs Configuration, versioning, Configurability vs Standardisation, Modularity and code organisation for infrastructure code.
SiriusCon 2015 - Breathe Life into Your Designer!melbats
You have your shiny new DSL up and running thanks to the Eclipse Modeling Technologies and you built a powerful tooling with graphical modelers, textual syntaxes or dedicated editors to support it. But how can you see what is going on when a model is executed ? Don't you need to simulate your design in some way ? Wouldn't you want to see your editors being animated directly within your modeling environment based on execution traces or simulator results?
The GEMOC Research Project designed a methodology to bring animation and execution analysis to DSLs. The companion technologies required to put this in action are small dedicated components (all open-source) at a "proof of concept" maturity level extending proven components : Sirius, Eclipse Debug, Xtend making such features within the reach of Eclipse based tooling. The general intent regarding those OSS technologies is to leverage them within different contexts and contribute them to Eclipse once proven strong enough. The method covers a large spectrum of use cases from DSLs with a straightforward execution semantic to a combination of different DSLs with concurrent execution semantic. Any tool provider can leverage both the technologies and the method to provide an executable DSL and animated graphical modelers to its users enabling simulation and debugging at an early phase of the design.
This talk presents the approach, the technologies and demonstrate it through an example: providing Eclipse Debug integration and diagram animation capabilities for Arduino Designer (EPL) : setting breakpoints, stepping forward or backward in the execution, inspecting the variables states... We will walk you through the steps required to develop such features, the choices to make and the trade-offs involved. Expects live demos with simulated blinking leds and a virtual cat robot ! This talks presents also xCapella an industrial use case onwhich the Gemoc methodology was applied.
This talks was presented at SiriusCon 2015 in collaboration with Jérôme Le Noir from Thales.
The Arduino Designer documentation is available on : https://github.com/mbats/arduino/wiki/Documentation
Embracing GenAI - A Strategic ImperativePeter Windle
Artificial Intelligence (AI) technologies such as Generative AI, Image Generators and Large Language Models have had a dramatic impact on teaching, learning and assessment over the past 18 months. The most immediate threat AI posed was to Academic Integrity with Higher Education Institutes (HEIs) focusing their efforts on combating the use of GenAI in assessment. Guidelines were developed for staff and students, policies put in place too. Innovative educators have forged paths in the use of Generative AI for teaching, learning and assessments leading to pockets of transformation springing up across HEIs, often with little or no top-down guidance, support or direction.
This Gasta posits a strategic approach to integrating AI into HEIs to prepare staff, students and the curriculum for an evolving world and workplace. We will highlight the advantages of working with these technologies beyond the realm of teaching, learning and assessment by considering prompt engineering skills, industry impact, curriculum changes, and the need for staff upskilling. In contrast, not engaging strategically with Generative AI poses risks, including falling behind peers, missed opportunities and failing to ensure our graduates remain employable. The rapid evolution of AI technologies necessitates a proactive and strategic approach if we are to remain relevant.
Unit 8 - Information and Communication Technology (Paper I).pdfThiyagu K
This slides describes the basic concepts of ICT, basics of Email, Emerging Technology and Digital Initiatives in Education. This presentations aligns with the UGC Paper I syllabus.
Operation “Blue Star” is the only event in the history of Independent India where the state went into war with its own people. Even after about 40 years it is not clear if it was culmination of states anger over people of the region, a political game of power or start of dictatorial chapter in the democratic setup.
The people of Punjab felt alienated from main stream due to denial of their just demands during a long democratic struggle since independence. As it happen all over the word, it led to militant struggle with great loss of lives of military, police and civilian personnel. Killing of Indira Gandhi and massacre of innocent Sikhs in Delhi and other India cities was also associated with this movement.
Synthetic Fiber Construction in lab .pptxPavel ( NSTU)
Synthetic fiber production is a fascinating and complex field that blends chemistry, engineering, and environmental science. By understanding these aspects, students can gain a comprehensive view of synthetic fiber production, its impact on society and the environment, and the potential for future innovations. Synthetic fibers play a crucial role in modern society, impacting various aspects of daily life, industry, and the environment. ynthetic fibers are integral to modern life, offering a range of benefits from cost-effectiveness and versatility to innovative applications and performance characteristics. While they pose environmental challenges, ongoing research and development aim to create more sustainable and eco-friendly alternatives. Understanding the importance of synthetic fibers helps in appreciating their role in the economy, industry, and daily life, while also emphasizing the need for sustainable practices and innovation.
Honest Reviews of Tim Han LMA Course Program.pptxtimhan337
Personal development courses are widely available today, with each one promising life-changing outcomes. Tim Han’s Life Mastery Achievers (LMA) Course has drawn a lot of interest. In addition to offering my frank assessment of Success Insider’s LMA Course, this piece examines the course’s effects via a variety of Tim Han LMA course reviews and Success Insider comments.
Acetabularia Information For Class 9 .docxvaibhavrinwa19
Acetabularia acetabulum is a single-celled green alga that in its vegetative state is morphologically differentiated into a basal rhizoid and an axially elongated stalk, which bears whorls of branching hairs. The single diploid nucleus resides in the rhizoid.
Instructions for Submissions thorugh G- Classroom.pptxJheel Barad
This presentation provides a briefing on how to upload submissions and documents in Google Classroom. It was prepared as part of an orientation for new Sainik School in-service teacher trainees. As a training officer, my goal is to ensure that you are comfortable and proficient with this essential tool for managing assignments and fostering student engagement.
Palestine last event orientationfvgnh .pptxRaedMohamed3
An EFL lesson about the current events in Palestine. It is intended to be for intermediate students who wish to increase their listening skills through a short lesson in power point.
3. Part I: Generator Technology
What are Generators?
Technologies for Building Generators
Vertical, Horizontal, Oblique Transformations
Compositional vs. Transformational Generators
Kinds of Transformations
• Compiler Transformations
• Source-to-Source Transformations
Transformation Systems
3
4. What are Generators?
Generator: A program that takes a higher-
level specification of a piece of software and
produces its implementation.
• Check Specification
System System
• Complete Specification
Specification Implementation
• Perform Optimizations
• Generate Implementation
Generator
4
5. Three Issues
Raising the intentionality of system
descriptions
• Focus on “what is needed”
• Avoid implementation details
5
6. Three Issues
Raising the intentionality of system
descriptions
Computing an efficient implementation
• Performance Requirements (e.g. response time)
• Complex computation inside generators
6
7. Three Issues
Raising the intentionality of system descriptions
Computing an efficient implementation
Avoiding the library scaling problem
• Exponential growth
• Factoring libraries into components corresponding to
features + Composing using function calls
• Avoid “exponential growth”
• Poor performance
• Generators: factoring + eliminating calling overhead
7
8. Three Ways to Build Generators
Developing generators as stand-alone
programs from scratch
• Effort-intensive
Using the built-in metaprogramming
capabilities of a programming lang. (e.g. c++)
•Advantage: easier to write generators, generators could
be part of the library
•Disadvantage: limited by the host lang., debugging
8
9. Three Ways to Build Generators
Using a generator infrastructure
• The infrastructure provides basic facilities
• A common format for the internal source representation
• Operations for encoding transformations
• Input/output facilities
• Debugging facilities
• An example: Intentional Programming
9
13. Automating System Implementation
System
System System
Requirements
Requirements Requirements
Manually
Manually Manually
Implement
Implement Implement
High-level system
specification
Source-to-Source Interactive,
Transformations automated support
Compiler System source using System source using
Transformations domain-specific lang. domain-specific lang.
abstractions abstractions
Compile Compile
System source Could generate Could generate
in a general- code in C++ or code in C++ or
purpose lang. Java if needed Java if needed
Compile Compile Compile
System
System System
Implementation
Implementation Implementation
14. Compiler Transformations
Refinements(vertical) – adds implementation details
• Decomposition
• An abstract data type(ADT) -> A number of other ADTs
• Choice of representation
• Matrix -> Array? Vector? Hash Table?
• Choice of algorithm
• Performance
14
15. Compiler Transformations
Optimizations(horizontal) – improve performance
• Structural changes of the code -> code becomes
hard to understand
• Inlining – replace the symbol by its definition
• Loop fusion – combine two loops into one if two loops
have a similar structure and can be done in parallel
• Beyond conventional compilers
• Domain-specific optimizations (domain knowledge)
• Global optimizations (cross multiple locations)
15
16. Source-to-Source Transformations
Restructuring transformations
• Editing transformations
• Mechanize some simple editing operations
• Ex. converting a code section into a procedure
• Refactoring transformations
• Recognize code
• Ex. abstraction and generalization
16
18. Elements of transformation
systems
A common format for the internal program
representation
• Abstract syntax tree, data and control flow graph
Code analysis facilities
• Check the input program and guide transformation
A transformation engine
• Apply transformations
Input and output facilities for the internal
representation
18
19. An Example
Program text Transformed
AST
e.g., (y+1/y+1)+z 1+z
AST
Transformation
Parser Unparser
Engine
+ +
/ z z
1
+ +
/
y1y 1
1
x x
Rewrite Rule
19
20. Summary: Generator Technology
What are Generators?
Technologies for Building Generators
Vertical, Horizontal, Oblique Transformations
Compositional vs. Transformational Generators
Kinds of Transformations
• Compiler Transformations
• Source-to-Source Transformations
Transformation Systems
20
21. Part II: GenVoca
GenVoca Approach
GenVoca Model
Implementing GenVoca in C++
Composition Validation
21
22. GenVoca Approach
Build software system generators based
on composing object-oriented layers of
abstraction.
• Stacked layers
• Layer above refines the layer below it. Ex.
add new classes
OO framework v.s. GenVoca model
22
23. Transforming a framework into
a GenVoca model (step 1)
Identify layers of abstractions in a framework
C11 C13
C21 C22
Most
C31 C32 C33
Refined
23
24. Transforming a framework into
a GenVoca model (step 2)
Turn the hierarchy of layers upside down
Most
C31 C32 C33
Refined
C21 C22
C11 C13
24
25. Transforming a framework into
a GenVoca model (step 3)
Treat “the layer below” as a parameter of “the
layer” above
C31 C32 C33
C21 C22
C11 C13
25
26. Transforming a framework into
a GenVoca model (step 4)
Provide families of alternative, parameterized
layers
26
27. GenVoca Model
Components and Realms
• Component (or layer): an implementation of
abstract data type or feature
• Realm: all components that implement the
same abstract data type or feature
Example:
S = { a, b, c }
T = { d[S], e[S], f[S] }
W = { n[W], m[W], p, q[T,S] }
27
28. GenVoca Model
Parameters & Transformations
• A component has a realm parameter for every
realm that it imports.
Example:
S = { a, b, c }
T = { d[S], e[S], f[S] }
W = { n[W], m[W], p, q[T,S] }
Vertical v.s. Horizontal Parameters
• Vertical parameters: layer parameters
• Horizontal parameters: other parameters
28
29. GenVoca Model
Symmetric Components
• Exports the same interface as it imports
Example:
S = { a, b, c }
T = { d[S], e[S], f[S] }
W = { n[W], m[W], p, q[T,S] }
n[W], m[W]
29
30. GenVoca Model
Grammar
Example:
S = { a, b, c }
T = { d[S], e[S], f[S] }
W = { n[W], m[W], p, q[T,S] }
S := a | b | c
T := d[S] | e[S] | f[S]
W:= n[W] | m[W] | p | q[T,S]
30
31. GenVoca Model
Type Expressions
• describing layer composition, used to model
software system
Example:
S := a | b | c
T := d[S] | e[S] | f[S]
W:= n[W] | m[W] | p | q[T,S]
System_1 = d [b]
System_2 = q [d[a], c]
31
32. GenVoca Model
Families of Systems
• The set of all component compositions
Scalability
• Few components, large families of systems
Design Rules and Domain Models
S = { a, b, c }
T = { d[S], e[S], f[S] }
d[a], d[b], d[c], e[a], e[b], e[c], f[a], f[b], f[c]
• Type expression, syntax correct, semantics wrong
• Domain-specific constrains -> Design rules
• Domain model: Realms of components + Design rules
32
33. An Example – Booch Data Structure
Data Structure Families
• Bag: unordered collection of objects
• Queue: ordered sequence of objects with FIFO semantics
Data Structure Features for Every Family
• Unbounded: No upper bound on total number of objects
• Concurrent: A multithread environment, read/write serialized
• Managed: Free objects are stored on a list for subsequent
reuse.
Data Structure Features only for Queue
• Priority: Objects are sorted based on some priority function
33
34. An Example – Booch Data Structure
Bag[Concurrent[Size_of[Unbounded[Managed[heap]]]]]
Formal
Bag
parameter
Concurrent Multiple Parameters
Size_of
Unbounded
Managed
Used as a
heap
parameter of
34
35. Implementing GenVoca Layers
in C++
Implement GenVoca layers as class templates
containing member classes
Example: LayerA
35
36. Template <class LowerLayer> Forwarding Implementation
Class LayerA
{ public:
class ClassA
{ public:
void operationA() //refine operationA()
{ …//LayerA-specific work
lower.operationA();
…//LayerA-specific work
};
void operationB() { lower.operationB(); }; //forward operationB
private:
typedef typename LowerLayer::ClassA LowerLayerClassA;
LowerLayerClassA lower;
};
class ClassB {…};
}
37. Forwarding Static Wrapper
Template <class Component>
Class Wrapper
{ public:
void operationA() //refine operationA() Problem:
{ …//wrapper-specific work
propagation of operations
component.operationA();
Solution: Inheritance
…//wrapper-specific work
};
void operationB() { component.operationB(); }; //forward operationB
private:
Component component;
}
37
38. Inheritance-based Static Wrapper
Template <class Component>
Class Wrapper : public Component
{ public:
void operationA() //refine operationA()
{ …//wrapper-specific work
Component :: operationA();
…//wrapper-specific work
};
}
38
39. Template <class LowerLayer> Inheritance-based Implementation
Class LayerA
{ private:
typedef typename LowerLayer::ClassA LowerLayerClassA;
typedef typename LowerLayer::ClassB LowerLayerClassB;
public:
class ClassA : Public LowerLayerA
{ public:
void operationA() //refine operationA()
{ …//LayerA-specific work
LowerLayerClassA :: operationA();
…//LayerA-specific work
};
};
class ClassB : Public LowerLayerClassB
{…};
}
40. Upward Type Propagation
Scope operator, ::
typedef
Problem: the layer might have to explicitly
pass types they are not interested for
themselves.
Solution: configuration repository
• an “envelop” containing all the layers, types and
constants
40
41. An Example
Accessing R2
and R3 Possible R1: A
R1: A R2: B,C
Config
R2: B,C
export:
R3: D,E Global1, Global2
ConfigA::HorizA
Accessing R3 ConfigB::HorizB
Possible
41
42. Downward Type Propagation
Idea: put the whole layer hierarchy into the
configuration repository.
Access R1
R1: A
possible
R2: B
Config
export:
R1, R2
42
44. A model – Conditions & Restrictions
Upward and downward propagation of
attributes that represent constraints on layers or
properties of layers
Conditions: constraints propagated downwards
Restrictions: constraints propagated upwards
Postrestrictions Preconditions
Layer A
Prerestrictions Postconditions
44
45. Summary : GenVoca
GenVoca Approach
GenVoca Model
Implementing GenVoca in C++
Composition Validation
45
46. Part III: GenVoca vs. AOP
Richard Cardone
AOP: a meta-programming model that promotes
code reuse by localizing the implementation of
design features that cut across multiple functional
unit.
GenVoca: a model of hierarchical software
construction that enables customized applications to
be assembled from interchangeable and reusable
components.
46
49. Implementation
AOP
• Aspect language
• Weaver (preprocessor)
GenVoca
• Type expression
• Generator (preprocessor)
49
50. Focus
AOP
• For any existing code base
• Support code reuse by applying new features in a
controlled and localized way
Genvoca
• Require the definition of standardized realm
interfaces, domain analysis needed
• Provide techniques to decompose applications into
reusable and composable components
50
51. Conclusion
Generators
• Automate system implementation
• Various levels: compiler, source-to-source
• Depending on the needs
• Transformation systems
GenVoca
• A systematic approach
• Issues:
• composition validation (distance)
• how to get effective component composition
• component changes
51
52. Sources
“Generative Programming” textbook
Don Batory, http://www.cs.utexas.edu/users/dsb/
• “Composition Validation and Subjectivity in GenVoca
Generators”, 1997
“On the Relationship of Aspect-Oriented
Programming and GenVoca”, Richard Cardone
52