1
Model Compiler Construction Based on Aspect-oriented Mechanisms
Naoyasu Ubayashi (Kyushu Institute of Technology)Tetsuo Tamai (University of Tokyo)Shinji Sano, Yusaku Maeno, Satoshi Murakami (Kyushu Institute of Technology)
29 September 2005
GPCE 2005Generative Programming and Component Engineering
2
Overview
1. Motivation2. AspectM 3. Model compiler construction using
AspectM4. Discussion5. Related work6. Conclusion
3
1. Motivation
4
Issues to be tackled Model-based development is a software
development method in which models are created before source code is written.
Although the method is effective, we have to modify models when we face evolution such as change of platforms.
These modifications crosscut over many places in the models, and tend to cause unexpected errors.
New platformsNew requirements
Optimization
Multiple concerns!
5
How does MDA deal with this problem ?
Analysis
Design
Coding
CIM
PIM
PSM
Source code
MDA: Model-Driven Architecture PIM: Platform Independent ModelCIM: Computation Independent Model PSM: Platform Specific Model
OOSD MDA
model compilerWe can regard PIMs as new kinds of reusable software components because they can be reused even if a platform is changed.
6
But, …
Although MDA is effective for software development, it mainly focuses on platform-specific concerns.
We have to modify models when we face evolution related to other kinds of concerns including application-specific optimization, security policies, and deployment.
It is necessary to allow a modeler to customize transformation rules because model modifications for dealing with these concerns may be specific to an application.
Multiple concernsMultiple concerns
ExtensibilityExtensibility
7
Motivating example -- A simple bulletin board system
8
ExampleOriginal Platform
ConcernOptimization
Concern
make a product that is executable on the Struts platform
optimize memory usage
logging
add a logging function for debugging
logging
modifications crosscut over many places
LoggingConcern
delete
application-specific
9
Our Approach We propose a method for constructing an extensible
model compiler based on aspect-orientation. Aspect-orientation is useful for platform descriptions
because they crosscut over many model elements. A modeler can extend model transformation rules by
defining new aspects in the process of modeling.
AspectAspect
UML modelUML model weaveweave
Extensible model compilerExtensible model compiler
UML modelUML model
AspectAspect
UML modelUML model
UML modelUML model
PIM PSM
AspectM
10
2. AspectM
11
Aspect orientation
AOP is based on the JPM (Join Point Model).
Join pointJoin point
PointcutPointcut
AdviceAdvice
program execution points including method invocations and field access points
a means of extracting a set of join points related to a specific crosscutting concern from all join points
a means of raising effects at the join points
12
Aspect orientationat the modeling-level (example)
classA
attributes
operationsclassB
attributes
operationsclassC
attributes
operations
join point
(class) classA || classB(extract join point whose name is classA or classB)
pointcut classA
attributesnew attributes
operationsnew
operations
adviceadd new attributesadd new operations
Extension of JPMs (Join Point Models) in AOP
classB
attributesnew attributes
operationsnew
operations
join point
(class) join point
(class)
13
JPMs for model transformationsJPM Join point Pointcut Advice
PA operation
Example 1) setX || setY 2) set* 3) classA ||
classB 4) class*
before,after,around
CM class merge-by-name
NE class-diagram add-classdelete-class
OC class add-operation,delete-operation,add-attribute,delete-attribute
RN class, operation, attribute
rename
RL class add-inheritance,delete-inheritance,add-aggregation,delete-
aggregation,add-relationship,delete-relationship
PA ( pointcut & advice ), CM ( composition ), NE ( new element ), OC ( open class ), RN ( rename ),RL ( relation )
14
AspectM
AspectM is an aspect-oriented modeling language that supports six kinds of JPMs.
In AspectM, an aspect can be described in either a diagram or an XML format.
AspectM provides the two kinds of aspects: ordinary aspect and component aspect. A component aspect is a special aspect for composing aspects.
An aspect can have parameters for supporting generic facilities. By filling parameters, an aspect for a specific purpose is generated.
15
Example of AspectM descriptions
<< OC >>addAttributeX
classeAandB : class { pointcut-body=“cname(classA) || cname(classB)” }
merge [classAandB] : add-attribute { advice-body=“attributeX” }
aspect
<aspect name=“addAttributeX” type=“ordinary” jpm=“OC" > <pointcut name=“classeAandB” type=“class”> <pointcut-body> cname(classA) || cname(classB) </pointcut-body> </pointcut> <advice name=“add-attributeX” type=“add-attribute” ref-
pointcut=“classAandB”> <advice-body> attributeX </advice-body> </advice></aspect>
classA
classB
classC
classA
newattributes
advice
add newattributes
pointcutclassA || classB
classB
newattributes
16
AspectM Tools
UML diagrams
Aspect diagrams
Model Editor (Eclipse UML)
AspectMmetamodel
(EMF)
XMI (PIM)
XMIXSLT style sheet
XMI (PSM)
XSLT style sheet
Java code
Model Compiler
17
AspectM metamodel
18
Implementation of model compilerAspect diagram
(XML)
XSLT processorXSLT style sheet
forconverting aspect (XML)
to XSLT style sheetXSLT style sheet
forconverting UML (XML) to UML (XML)
UML diagram (XML)
XSLT processor(Weaver)
UML diagram (XML)
The firsttransformation phase
The secondtransformation phase
Model Compiler
19
3. Model compiler construction using AspectM
20
Application-specific model compiler
UML modelUML model
Weaver(XSLT processor)
Weaver(XSLT processor)
UML modelUML model
UML modelUML model
UML modelUML model
AspectAspect
Aspect Aspect
Aspect
Aspect
Extended application-specificmodel compiler
21
ExampleOriginal Platform
ConcernOptimization
Concern
make a product that is executable on the Struts platform
optimize memory usage
logging
add a logging function for debugging
logging
LoggingConcern
delete
application-specific
22
Aspect for platform concern
<< CM >>MergeClasses
inputClasses : class { pointcut-body=“cname(Message) || cname(MessageProfile)” }
merge [inputClasses] : merge-by-name { advice-body=“PostMessage” }
aspectStep1: merge PIMsStep1: merge PIMs
Step 2: transform the merged classto an action form bean class
Step 2: transform the merged classto an action form bean class
1) merge PIM classes
2) change the name of merged class3) inherit ActionForm4) add setter/getter
Platform: Struts
23
Component, Generics<aspect name="Generic-Classes2ActionFormBean" type="component">
<params> <param> @input-classes@ </param> <param> @merged-class@ </param> </params>
<aspect name="MergeClasses" template="Generic-MergeClasses"> <set-param name="@input-classes@"> @input-classes@ </set-param> <set-param name="@merged-class@"> @merged-class@ </set-param> </aspect>
<aspect name="SetActionFormBeanName" template="Generic-SetActionFormBeanName"> <set-param name="@class@"> @merged-class@ </set-param> </aspect>
<aspect name="InheritActionForm" template="Generic-InheritActionForm"> <set-param name="@sub-class@">concat( @merged-class@ ,"Form")</set-param> </aspect>
<aspect name="AddAccessors" template="Generic-AddAccessors"> <set-param name="@class@">concat( @merged-class@ ,"Form")</set-param> </aspect>
</aspect>
Step1
Step2
component
generics
24
Aspect for optimization concern
<aspect name="DeleteAttribute" type="ordinary" jpm="OC"> <pointcut name="postMessageClass" type="class"> <pointcut-body> cname(PostMessage) </pointcut-body> </pointcut> <advice name="deleteDate" adviceType="delete-attribute" ref-pointcut="postMessageClass"> <advice-body> date </advice-body> </advice></aspect>
<< OC >>DeleteAttribute
postMessageClasse : class { pointcut-body=“cname(PostMessage)” }
merge [postMessageClasse] :delete-attribute { advice-body=“date” }
aspect
25
Aspect for logging concern
<aspect name="LoggingSetter" type="ordinary" jpm="PA"> <pointcut name="allSetter" type="method"> <pointcut-body> oname(set*)</pointcut-body> </pointcut> <advice name="logSetter" adviceType="before" ref-pointcut="allSetter"> <advice-body> Log.write() </advice-body> </advice></aspect>
<< PA >>LoggingSetter
allSetter : method { pointcut-body=“oname(set*)” }
merge [allSetter] : before { advice-body=“Log.write()” }
aspect
26
Towards product-line engineering
Aspects are useful for product-line engineering in which avariety of PSMs are generated from a single set of PIMs.
Aspect library
for .NETAspect libraryfor J2EE
Aspect libraryfor other platforms
:
Aspect libraryfor product-
line BAspect libraryfor product-
line A
Aspect libraryfor other product-lines
:
Application-specificaspects
UML diagrams
defined by modelers
Application-specificaspects
UML diagrams
Product X
Product Y
weave
weave
27
4. Discussion
28
Scalability ?
Aspect libraries that support de facto standard platforms such as J2EE and .NET.
Aspect libraries that support platform-independent model transformations commonly applied to many applications.
It is not realistic for a modeler to define all of the aspects needed to construct a model compiler from scratch.
① fusion of classes having certain kinds of patterns
② generation of setter/getter methods③ change of naming conventions
29
Are six JPMs enough ?
It is still not clear whether all kinds of model transformations can be described by the six JPMs.
We think that there are situations for which new kinds of JPMs must be introduced.
It would be better if a modeler can modify the AspectM metamodel using the model editor.
This function can be considered as a modeling-level reflection, a kind of compile-time reflection.
30
Is AspectM really AOP language ?
AspectM can describe not only model transformation concerns but also ordinary crosscutting concerns such as logging.
AspectM unifies (lightweight) meta-programming with ordinary aspect-orientation by extending the idea of JPMs.
aspect-orientation
lightweightmeta-programming
JPMs
Someone might claim that AspectM is not an aspect-oriented language but a meta language for model transformations.
31
5. Related work
32
Related workAspect-oriented domain modeling (AODM) [J. Gray et. al. 2003]
AODM introduced a language called ECL that provides facilities for adding model elements such as attributes and relations.
In Draco, software development processes were considered as a series of transformations.
Draco [J. Neighbors 1984]
Persistence as an Aspect [A.Rashid and R.Chitchyan 2003]Aspect-oriented mechanisms (+ reflection) for describing database concerns are proposed.
QVT [OMG]QVT (Queries, Views, and Transformations) is a model transformation language.
33
6. Conclusion
34
Conclusion
We proposed a method for constructing an extensible model compiler that can deal with application-specific model transformations.
A modeler can extend model transformation rules by defining new aspects in the process of modeling.