=Paper=
{{Paper
|id=Vol-154/paper-9
|storemode=property
|title=Automated Model Transformation in MDA
|pdfUrl=https://ceur-ws.org/Vol-154/kuznetsov.pdf
|volume=Vol-154
}}
==Automated Model Transformation in MDA==
https://ceur-ws.org/Vol-154/kuznetsov.pdf
Automated Model Transformation in MDA
© Mikhail Kuznetsov
Computational Mathematics and Cybernetics Faculty,
Moscow M.V.Lomonosov State University
mikle.kuz@mtu-net.ru
Ph.D. Advisor S.D. Kuznetsov
Abstract First during development a PIM is created. PIM is a
model of a system that contains its business-logic,
Model Driven Architecture is a new and usecases and view of a system from end user’s point of
promising approach to software development. view without details of its actual implementation. The
But its spread is hindered by the fact that one fact that PIM is not bind to any platform or technology
of its parts - automated transformation of is most innovative and most important. When using
software models – is not sufficiently MDA it is recommended to develop platform-
developed. In this paper a language is independent model with a relatively high level of
presented that can be used to define such details, up to using a high-level platform-independent
transformations and a tool to automatically programming language to code system’s functionality
execute them. and creating an executable prototype.
Once PIM has sufficient details, a transition to
1 Introduction Platform-Specific Model is performed. This model
describes not only user-level system functionality, but
Programmers use many different middleware platforms also details of implementation of the system on the
and technologies, and in the future their number will middleware platform chosen for a current project. More
only increase because new technologies are being
details are being added to the model by developers, and
developed constantly but old ones become obsolete very necessary changes are performed, until the model is
slowly. All attempts to create a universal platform that ready to be passed to the stage of code generation. Just
could replace all existing ones resulted only in
as in a common development process, a code can be
increased variety of technologies. The problem of partially generated automatically from the model, and
choosing a platform for a particular project becomes then finalized manually and compiled.
more and more important, as well as problems of Of course, actual development process is not so
interaction and integration of heterogeneous systems straightforward. It is nearly impossible for a complex
and migration of existing systems to a new platform
project to make a platform-independent model that
when old platform becomes outdated and no longer would not require any modifications on later stages of
satisfies customer’s needs. The solution may be usage development. During development of platform-specific
of a new methodology of software development.
model and even of code changes can be made in any
Object Management Group (OMG) offers a new higher-level models. It does not contradict MDA
approach to software development called Model Driven development process, but when making such changes
Architecture (MDA) [9]. MDA offers several
one should keep correspondence between models: a
advantages compared to existing methodologies: change to one model should be properly reflected in all
simplification of development of multi-platform others. So, when using MDA three models of the
systems, ease of switching of a middleware platform,
systems are being developed simultaneously: PIM,
increased speed of development and quality of products PSM and code, each reflecting its own level of
and much more. But all of it is possible only when abstraction.
development tools will support the MDA technology
The idea that is placed in the core of MDA is
and help to fully realize its potential. Unfortunately independent from modeling language and tools. But the
currently most of commercial products, even those that developer of technology, OMG consortium, assumes
claim to support MDA, do not offer proper tools and
that modeling will be done with UML (Unified
technologies, thus efficiency of MDA in real projects is Modeling Language) [6]. Last changes and additions to
limited. UML standard made this language much more
MDA is based on concepts of Platform-Independent convenient for use with MDA. UML Action Semantics
and Platform-Specific Models (PIMs and PSMs) [12]. [13] allows to describe system’s functionality on
platform-independent level, and UML Profiles make
Proceedings of the Spring Young Researcher's creation of PSMs for specific middleware platforms
Colloquium on Database and Information Systems easier.
SYRCoDIS, St.-Petersburg, Russia, 2005
Separation of platform-independent and platform- model using a pre-defined transformation definition
specific models offers major benefits for developers. (that contains formal description of details of a specific
First of all, the process of transition between technology or platform) [8]. This paper is dedicated to
middleware platforms and technologies becomes easier, development of a language and tool for defining and
because PIM can be reused and only PSM has to be executing such transformations.
created anew. A risk of early development mistakes There are several requirements that a transformation
decreases, because it is much easier to find and correct language has to satisfy to be efficient when used in
such mistakes on relatively simple model that is fully MDA:
based on customer’s requirements, then on sophisticated - Formalism of transformation description.
low-level model that contains huge number of Transformation should be defined in a formal
implementation-specific details. Separation of the language that has a good grammatical model, so
models is also useful for fast creation of documentation, that the transformation tool could interpret this
integration, creation of heterogeneous systems and so language and automatically execute it.
on. - Universality. Transformation language should
But the main advantage of MDA is its ability to permit creation of a wide range of transformations
increase development speed, despite the fact that two that can cover a variety of middleware platform,
models are being made instead of one. This is achieved including those that will appear in the future. Then
by using automated generation of platform-specific it will always be possible to pick a standard
model by platform-independent one. The process of transformation definition and transform a PIM of a
transition from PIM to PSM that is based on a certain project to a modern platform, even if the PIM was
technological platform is highly formalized. UML made 10 years ago and the platform was developed
Profiles that are developed for all popular middleware recently. It is desirable that the language contains
platforms contain recommendations about mapping means for model parameterisation and tuning, so
various UML elements to forms that are specific to a that a single transformation definition can be used
chosen technology – but those are recommendations for in many different projects.
a developer and not instructions for automated - Integrity preservation. During development all
execution. With a bit more efforts and more models can be changed, even after transition from
formalization it is possible to convert loose form of PIM to PSM, meaning that there should be a way to
Profiles into exact instructions. Then it is no longer automatically keep conformity between
needed to manually create PSMs, and development transformed models that has been achieved during
speed will increase significantly, because many details transformation. This means that information should
required by a certain technology will be added to the be kept about a course of transformation and about
model automatically. Besides, the number of mistakes mapping that was established between different
that are inevitable with manual modeling will decrease elements of the models. Then UML editing tool can
as well. Description of automatic transition to a PSM use this information to automatically map changes
can be made once and thoroughly tested, and then used done to one model to another one, or at least to
in all projects that use this technology. So, when using notify a programmer what elements are no longer
MDA and automatic transition to platform-specific consistent.
model, the development process consists of the - Intelligibility for a human reader. One
following stages: transformation definition can be used in many
- creation of the task, usecases, requirements and projects, but all projects are different. This means
other initial documents; that it should be relatively easy to understand and
- creation of platform-independent model; modify it to suit specific needs. The transformation
- automatic transition from PIM to platform-specific should be clear not only to the person who wrote it,
model, using a standard transformation definition but also to other people who may have to alter it. It
developed earlier (and probably by other company) is also desirable that the transformation is well-
for a chosen middleware platform and/or structured, so that it is easier to understand what
implementation technologies; effect a particular change will have on
- manual modification of both PIM and PSM, transformation globally.
addition of various details; - Interconnected transformations. It is possible that
- automated code generation; during MDA-based development multiple models
- manual coding of parts that could not be generated of one type exist in a project. In particular, if the
automatically, compilation. project uses multiple platforms, a separate PSM is
Transition from PSM to code is fairly well generated for each of them. Transformation
developed. Before MDA it was called “code language should be able to operate with more then
generation” and to a certain degree can be performed by one source and generated model, it should be
almost any modeling tool for majority of programming possible to transform multiple models within a
languages and technologies. But automated transition to single transformation definition. It is much more
PSM is a new concept. Since PIM and PSM are both convenient than usage of a separate transformation
models written on UML (at least with classic MDA for each pair of models, since such approach allows
approach), transition is just a transformation of a UML-
to easily track relation between model elements and to define transformations (not UML model
generate any necessary mediators and bridges. transformations, but transformations in general). In
particular CWM (Common Warehouse Metamodel)
2 Various approaches to model standard has such functionality [2]. The idea to use
transformation UML language to define UML transformations, just as
UML defines it’s own syntax, looks promising, but not
There are multiple approaches to definition and very practical. Unfortunately UML is just a modeling
execution of transformation of UML models [3]. The language, it can be used to show the fact that there is a
simplest solution is to imperatively define the procedure mapping between certain model elements, but not to
of transformation using any algorithmic language. A define details of such a mapping in general with enough
UML modeling toolset may contain modules that precision to allow automated execution. Another
contain predefined transformations that can later be standard from UML family – QVT (Query, View,
used when necessary. Unfortunately such an approach Transformation) [7] – is meant to fill this niche and
is badly suited for MDA-style development. First of all, looks much more promising for use in MDA.
users cannot add their own transformation definitions or Unfortunately, currently this standard is in early stages
modify those provided by creators of a toolset. Also of development, and it is not possible to say when it
each toolset will handle transformations differently will be ready or what exactly it will contain. The
even for the same middleware platforms, meaning that standard should do several big tasks at the same time,
models created by different toolsets will likely be and is mostly targeted not on practical use but on
incompatible with each other. Instead of being restricted development of theoretical concept of
by choice of a middleware platform, a programmer will metametamodeling as part of MOF (Meta Object
be restricted by choice of a modeling toolset. Finally, Facility, the standard for representation of metamodels)
such an approach means that for each toolset a full [11]. It is likely that this standard will be inefficient in
number of transformations should be developed for practice, and will not satisfy requirements of MDA.
each middleware technology. This is a huge work One more solution is development of a specialized
compared to using a single set of transformation created high-level language for defining model transformations
and thoroughly tested by a third party. and a tool for execution of such a language that would
Another approach to transformation is usage of be efficient for application in MDA. Probably such a
well-developed concepts and ideas from other areas of tool will be more convenient then an adaptation of a
science. In particular, it is possible to present a UML certain generic standard. Below we’ll review one of
model as a graph and use graph transformation such languages that is developed by the author.
technologies. The main disadvantage of this approach is
the fact that it uses its own terms and definitions that are 3 Fundamental scheme of the
not related to modeling. User of such transformation
transformation tool
tool will have to know not only UML modeling, but
also graph theory. And every time he wants to make a Transformation tool can be a separate program or a part
change in transformation definition he will have to of a larger software development toolkit. During MDA
make mental transition to graphs, and then back to development it is used for partial automation of
UML. generation of a platform-specific model [4]. It receives
Another solution is to use transformations of XML the following input data:
and XMI standard. XMI [10] (XML Metadata - one or more source models;
Interchange) is a standard that allows to present UML - metamodel for each model that takes part in the
as an XML document, its main purpose is storage of transformation;
UML models and exchange of models between different - transformation definition on a special
tools. There are several reliable technologies for XML transformation definition language; the definition
transformation, such as XSLT [14] and XQuery [1]. A depends on the metamodels and on number of
UML model can be converted to XML using XMI, then models that participate in the transformation, but is
this XML document can be transformed and converted independent from specific models.
back to UML. But such double conversion makes the The output data is:
transformation definition unclear for a human reader. - a set of source models with modifications added
Also since we need to convert transformed XML during transformation;
document back to UML, it has to comply with XMI. On - one or more (depending on transformation
practice this means that nearly 90% of definition of definition, possibly zero) newly generated models
XML transformation is targeted not at actual model that were created during a transformation; each
transformation, but at ensuring that the result is a valid generated model has to comply to one of the
XMI representation of a model. Of course it is very hard metamodels supplied as input data;
to make and understand such transformations. Even a - information about dependencies and mappings
relatively simple model transformation is defined by a between elements of models that was established
very large and bulky XML transformation. during transformation; it is needed to preserve
UML language is considered to be a universal conformity of models after the transformation.
modeling tool, and of course it contains its own means
For the transformation tool there is no major Computation of a navigation expression consists of
difference between source and generated models: both a sequential transition from one model element to
can be modified during transformation, the difference is another using specified directions, starting from the
only that generated model starts as empty model. So in element that the base variable points at. If a cardinality
the future we’ll talk about set of models meaning source of a direction is greater then one, all corresponding
and generated models combined. model elements are considered to be the result. This
means that the result of execution of a navigation
4 Transformation definition language expression is a list of all model elements that can be
reached from the element indicated by base variable by
Transformation definition consists of one or more the specified set of directions. Navigation expression
modules. Each module has a unique name and consists has the following properties:
of a set of transformation rules. Header of the module - Type: metamodel element that corresponds to
can also specify the sequence of execution of rules in elements contained in the result. Since navigation is
the module; this option will be explained later. Below performed via metamodel, all elements of the result
we can see a part of formal definition of the language will always have the same type. Type can be
using extended Backus-Naur form (eBNF). determined statically, it depends on the metamodel
but not to the actual model.
transformation::= *; - Cardinality: maximum number of elements in the
stage::= stage [] result. Cardinality is determined statically.
{ * }; - Value: a set of elements that were received as a
sequence::= [reversed] result during computation of the expression. Value
(linear | loop | rollback | rulebyrule); of an expression is calculated during its execution
at an actual model.
Each rule has a unique (in the scope of the module) Navigation expression can begin with any local or
name and consists of select section that defines when global variable declared earlier. Local variable is a
the rule can be applied, and generation section, that variable that is declared in one of operators of the same
specifies actions to execute when applying the rule. rule. Global variables are names of models that
participate in the transformation. Obviosly navigation
transformation_rule::= rule expression of the first select operator of a rule always
{ }; begins with a global variable, since no local variables
are initialized yet.
Select section contains a sequence of selection Generation section is a sequence of operators that
operators. Each operator defines a new variable that is modify models. Create operator allows to add a new
called “selection variable”. The name of this variable model element where a set of elements is possible
should be unique in the scope of the current rule, and (where multiplicity of a corresponding metamodel
domain is a set of elements of a model specified by association is greater then one). Navigation expression
navigation expression. Besides, select section can in this operator should point at the set, and its type
contain qualifying conditions - logical expressions that determines the type of created element. Delete operator
can contain selection variables declared by operators excludes a model element from a set. Modification
that stand earlier in the rule. operator allows changing value of element’s attribute.
Two more operators allow adding existing element to a
select_section::= (|)*; set of elements or removing it from a set without
select_operator::=forall deleting it from the model; those operators are
from ; necessary if metamodel contains loops or if the same
constraint::= where ; element is accessible via multiple associations.
Navigation expression is a sequence of directions generate_section::=(
that begins with a name of an existing variable (we’ll |
call it a base variable of the expression), symbol ‘/’ is |
used as a separator. Direction is a name of association |
on a metamodel that corresponds to the model that is |
being transformed (if more then one model participates )*;
in the transformation, the metamodel can be determined create_operator::=make
by a type of the base variable). Cardinality of a in ; ;
direction is multiplicity of the corresponding update_operator::= =
metamodel association. ; ;
delete_operator::= delete ; ;
nav_expression::= include_operator::=include
iteration_pair(/, ); in ; ;
exclude_operator::=exclude
in ; ;
keep it in mind when defining and executing a
transformation.
5 Execution of a transformation
6 Transformation bond and its usage in
Once a transformation tool receives a source model (or
models) and transformation definition, as well as transformation definition
description of used metamodels, it can execute the Every time a rule is applied a special data structure
transformation. It consists of a sequential execution of called ‘transformation bond’ is created in addition to
modules from the definition. Execution of a module is any actions contained in the generation section. A name
sequential repetition of two steps: finding a rule that can of this structure is the same as rule’s name, and its
be applied and applying this rule. attributes have the same names and types as rule’s local
Application of a rule is determined by its select variables. Values of those attributes are equal to values
section. Each operator of that section declares a new of corresponding variables calculated during application
variable and defines a set of its possible values. The rule of the rule.
can be applied to a set of model elements, where each Transformation bonds are stored during entire
element is in the appropriate value set, and where all process of a transformation, and possibly even after the
conditions of the select section are true. This means that transformation is finished. They contain information
if a select section has three selection operators and no about a course of the transformation, about application
conditions, and the operators define variables v1,v2 and of any rule and about relations between model elements
v3 that can take on N1,N2 and N3 different values, then established by the transformation. This information can
the rule can be applied to N1*N2*N3 different value be used to maintain consistency between models in the
sets; if the rule has any conditions then it can be applied process of transformation and after it. Besides,
only to those value sets where all conditions are true. A transformation bonds may be used by a transformation
rule can be applied only to the same value set only tool so that it can warrant that any rule is applied only
once. once to any set of values of selection variables.
Application of a rule to a value set is execution of It is possible to use transformation bonds explicitly
all operators in the generation section. in the transformation definition to establish
The order of application of rules is determined by a dependencies between rules. Just as navigation
special parameter in the module’s header. If its value is expressions are used to select elements from models,
‘linear’ then rules are applied sequentially from first in they can be used to select bonds created by rules that
module’s definition to the last; search for the next rule were applied before the current rule. Such special
to apply starts from the last applied rule. The module is navigation expressions begin not with a local variable
considered to be finished once the last rule in the or a name of a model, but with a name of a
module is executed for all possible value sets. If the transformation module, followed by a name of a rule
value of the parameter is ‘loop’, the transformation and then a name of a variable in that rule. Since any rule
works in the same way, but upon reaching the last rule can be applied more then one time during a
the search for applicable rules continues from the first transformation, creating more then one instance of a
rule. The module is finished if no more rules can be corresponding bond, cardinality of such navigation
applied. If the value of parameter is expression is always ‘many’. Just as with an ordinary
‘rollback’, then after each application of a rule the navigation expression, it returns a set of model elements
search starts from the first rule in the module; the as a result – a set of elements that were values of a
transformation is over if no more rules can be applied. specified variable in all applications of a specified rule.
If the value is ‘rulebyrule’, then search is also
performed from the first rule in the module, but once an ::=/
applicable rule Is found it is applied to all possible /;
value sets – and only then the search starts anew from
the top. All values of parameters mentioned above can Instead of the name of a module a keyword ‘rules’
also be used with a keyword ‘reversed’, meaning that may be used that is equal to the name of a current
the order of rules in the module is reversed and all module.
searches are performed from the last element from Explicit use of transformation bonds in
module definition to the first. If no value of transformation definition gives a powerful tool for a
parameter is specified, it is considered to be ‘rulebyrule’ programmer. It allows to define very complex rules in a
by default, since it allows fastest execution of the short and easy to understand way.
transformation. Transformation is over once the last
module is finished. 7 Rule extension and templates
It should be noted that it is not possible to warrant
that a transformation will ever be finished for any It is possible to define a new rule as an extension of
model. In some transformations infinite loops may existing rule. To do so one has to write a name of the
appear, especially when using ‘create element’ operator. rule that is being extended after the name of extending
Users of the transformation definition language should rule in that rule’s header. It is possible to extend
extensions and to make several extensions of the same
base rule, creating multi-layer hierarchy. Operators in Association
Model
the extending rule can use all variables from base rule name : Name 1
+associations name : Name
stereotype : Stereotype
along with their own variables (select operators can use 0..n
Association_type
1
variables only from select section and not from +classes0..n 1
+base
generation section). Class
name : Name +ends 2
stereotype : Stereotype+class
AssociationEnd
transformation_rule::= rule [ : ] { 1
1
0..n name : Name
1
; }; +associations cardinality : Cardinality 1
Association_end_type
+attributes +operations visibility : Visibility
0..n 0..n
Extension rule is applicable to a certain value set if: Attribute Operation 1
1
- base rule is applicable to this value set (actually for name : Name name : Name 0..n Parameter +otherEnd
type : Type type : Type name : Name
its corresponding subset); type : Type
- value set satisfies the select section of extending +parameters
rule; Simplified metamodel of UML class diagram.
- the extending rule was not applied to this value set
before. block example_transform {
Execution of an extending rule is execution of its
generation section. But unlike an ordinary rule it does rule class_mapping {
not create a new transformation bond; instead it extends forall src from source/classes
the bond created by application of the base rule with make trgt in target/classes;
variables declared in the extension. It works similarly to trgt/name=src/name;
inheritance in common programming languages: old }
attributes remain intact and new ones are added. Such
bonds will be shown as results of calculation of This is module’s header and its first rule. The rule
navigation expressions that scan for applications of the ‘class_mapping’ for each class of source model creates
base rule as well as applications of extending rule. a class in the target model with the same name. Each
The concept of rule extension allows to structure the application of this rule creates an instance of a
set of rules as well as the set of transformation bonds transformation bond with name ‘class_mapping’ and
created by those rules. It allows easier development, attributes ‘src’ and ‘trgt’ that point to a class in source
modification and understanding of complex model and newly generated class correspondingly.
transformations.
Template is a special rule that begins with a key rule private_to_private {
word ‘abstract’. Such rule is never applicable, no matter forall a from source/classes
the select section. But it can be used as a base rule to forall b from a/attributes
create extensions that can be applied as normal rules. A where b/visibility="private"
template can extend another template but not an forall c from target/classes
ordinary rule. Just as normal extensions, templates forall d from rules/class_mapping
allow to structure transformation bonds and then use where (d.src=a) and (d.trg=c)
navigation expressions that query those bonds to define make e in c/attributes;
complex transformations. e/name=b/name;
e/type=b/type;
8 Example of transformation definition e/visibility="private";}
A simple transformation module with several rules is
shown below. This transformation definition is meant to This rule copies private attributes from source to
be used for transformation of a pair of models (‘source’ target model. The select section of this rule uses
and ‘target’), both of which use UML class diagram transformation bond created by application of previous
metamodel. First model is a source data, and second is rule. Because of this bond an attribute is copied exactly
generated during the transformation. A simplified to the class that is generated by the class that contains
metamodel of UML class diagram used in this this attribute, without the bond we would not know
transformation definition is shown on the scheme: what class of target model to choose.
rule public_to_private {
forall a from source/classes
forall b from a/attributes
where b/visibility="public"
forall c from target/classes
forall d from rules/class_mapping
where (d.src=a) and (d.trgt=c)
make e in c/operations; // "get_elt()"
e/name="get_"+b/name;
e/type=b/type;
e/visibility="public"; c/base=assoc;
make f in c/operations; // "set_elt(type)" }
f/name="set_"+b/name; } //example_transform
f/type="void";
f/visibility="public"; The last brace marks an end of the module
make g in f/parameters; “example_transform”.
g/name=make_unique_name(b/name);
g/type=b/type; 9 Conclusion.
make h in c/attributes; // "private elt"
h/name=b/name; MDA technology has a potential to become a new
h/type=b/type; stage in evolution of software development toolkits and
h/visibility="private"; methods. But it is possible only if tools are created that
} are specially developed to support this technology and
utilize its full potential. Existing tools that claim to
This rule maps public attributes to private and support MDA are mostly minor modification of old
creates corresponding ‘get’ and ‘set’ pairs of operations. tools that do not provide necessary functionality. One of
A function “make_unique_name” that is used in this the main problems that slow down appearance of new
rule is a built-in function with a relatively simple generation of tools is automated model transformation.
functionality: it returns a string-name that is warranted Existing approaches from other areas of mathematics
to be unique in the scope of a model. Exact and informatics are inefficient for practical tasks of
implementation of this function may differ in different MDA-based development. That’s why development of a
transformation tools. new system and language is important.
This work offers a transformation definition
abstract rule all_inherited { language that is mostly meant to be used for automated
forall inherit_trgt from source/classes transformation of UML models. During development of
forall inherit_src from source/classes; this language a special attention was paid to make it
} suitable for MDA tasks, and to make it easier to
rule directly_inherited:all_inherited { understand for a human. A prototype tool is being
forall assoc from inherit_trgt/associations developed that supports this language and executes
where ((assoc/stereotype=”generalization”) and model transformations.
(assoc/otherend=inherit_src))
} References:
rule indirectly_inherited:all_inherited {
[1] D. Chamberlin. XQuery: An XML query language.
forall r1 from rules/directly_inherited
IBM systems journal, no 4, 2002.
where r1/inherit_trgt=inherit_trgt
[2] Common Warehouse Metamodel (CWM)
forall r from rules/all_inherited
Specification. OMG Documents, Feb. 2001.
where ((r/inherit_trgt=r1/inherit_src) and
http://www.omg.org/cgi-bin/apps/doc?formal/03-
(r/inherit_src=inherit_src))
03-02.pdf
}
[3] Krzysztof Czarnecki, Simon Helsen. Classification
of Model Transformation Approaches. University
This set of a template and two rules defines the
of Waterloo, Canada, 2003.
concept of “indirect inheritance” (if by inheritance we
[4] Keith Duddy, Anna Gerber. Declarative
mean generalization association). The rules themselves
Transformation for Object-Oriented Models.
do not modify the model, but they create transformation
Transformation of Knowledge, Information, and
bonds that can be used by other rules. For example, here
Data: Theory and Applications, 2003.
is a rule that generates a generalization association
[5] M. Kuznetsov. Model Driven Architecture and
between a class and all its direct and indirect ancestors:
Transformation of UML Models. In SYRCoDIS,
pages 82-86. May 2004.
rule inheritance {
[6] Martin Flower. UML Distilled: A Brief Guide to
forall a from rules/indirectly_inherited
the Standard Object Modeling Language, Third
make b in a/inherit_src/associations;
Edition. Addison Wesley, 2003.
b/cardinality=”1”;
[7] Tracy Gardner, Catherine Griffin A review of
make c in a/inherit_trgt/associations;
OMG MOF 2.0 Query / Views / Transformations
c/cardinality=”1”;
Submissions and Recommendations towards the
c/stereotype=”generalization”;
final Standard. http://www.omg.org/docs/ad/03-08-
b/other_end=c;
02.pdf
c/other_end=b;
[8] Anna Gerber, Michael Lawley, Kerry Raymond,
make assoc in target/associations;
Jim Steel, Andrew Wood. Transformation: The
include b in assoc/ends;
Missing Link of MDA. Proceedings 1st
include c in assoc/ends;
b/base=assoc;
International Conference on Graph Transformation
(ICGT 2002), 2002.
[9] Anneke Kleppe, Jos Warmer, Wim Bast. MDA
Explained. The Model Driven Architecture:
Practice and Promise. Pearson Education, 2003.
[10] Jernej Kovse, Theo Härder. Generic XMI-Based
UML Model Transformations. ZDNet UK
Whitepapers, 2002.
[11] Meta-Object Facility (MOF) specification, version
1.4 . OMG Documents, Apr. 2002.
http://www.omg.org/cgi-bin/apps/doc?formal/02-
04-03.pdf
[12] Joaquin Miller and Jishnu Mukerji(eds.). MDA
Guide Version 1.0. OMG document, 2003.
http://www.omg.org/mda/mda_files/MDA_Guide_
Version1-0.pdf
[13] Daniel Varro, Andras Pataricza. UML Action
Semantics For Model Transformation Systems.
Periodica Polytechnica, no. 3-4, 2003.
[14] XSL Transformations (XSLT) v1.0. W3C
Recommendation, Nov. 1999.
http://www.w3.org/TR/xslt