- In model-driven development, models are primary artifacts that capture information at different lifecycle stages and development activities like requirements, design, implementation, and testing.
- Model transformations provide a mechanism to automatically create or update target models based on information in source models. This allows for the systematic reuse of information.
- Models can represent different views of a system at varying levels of abstraction, and model transformations translate between these representations.
Metamodels can be considered one of the cardinal concepts of
Model-Driven Engineering and a number of coordinated entities,
suchasmodels, transformationsandtools, isdependingonit. Anal-
ogously to any software artifact, metamodels are equally prone to
evolution during their lifetime. As a consequence, whenever a
metamodelchanges, any related entity must be consistently adapted
for preserving its wellformedness, consistency, or intrinsic correct-
ness.
This work discusses the problem of co-adapting models, trans-
formations, and tools. Different aspects are taken into account and
a prospective and unifying characterization is given with the intend
ofclarifyingthemaindifficultiesandoutlinethebasicrequirements
for possible solutions. In this respect, EMFMigrate a comprehen-
sive approach to the metamodel co-evolution problem is proposed.
PYFML- A TEXTUAL LANGUAGE FOR FEATURE MODELINGijseajournal
The Feature model is a typical approach to capture variability in a software product line design and implementation. For that, most works automate feature model using a limited graphical notation represented by propositional logic and implemented by Prolog or Java programming languages. These works do not properly combine the extensions of classical feature models and do not provide scalability to implement large size problem issues. In this work, we propose a textual feature modeling language based on Python programming language (PyFML), that generalizes the classical feature models with instance feature cardinalities and attributes which be extended with highlight of replication and complex logical and mathematical cross-tree constraints. textX Meta-language is used for building PyFML to describe and organize feature model dependencies, and PyConstraint Problem Solver is used to implement feature model variability and its constraints validation. The work provides a textual human-readable language to represent feature model and maps the feature model descriptions directly into the object-oriented representation to be used by Constraint Problem Solver for computation. Furthermore, the proposed PyFML makes the notation of feature modeling more expressive to deal with complex software product line representations and using PyConstraint Problem Solver.
MODIGEN: MODEL-DRIVEN GENERATION OF GRAPHICAL EDITORS IN ECLIPSEijcsit
Domain-specific modeling is more and more understood as a comparable solution compared to classical software development. Textual domain-specific languages (DSLs) already have a massive impactin contrast
tographical DSLs, they still have to show their full potential. The established textual DSLs are normally generated from a domain specific grammar or maybe other specific textual descriptions. And advantage of textual DSLs is thatthey can be development cost-efficient. In this paper, we describe asimilar approach for the creation of graphical DSLs from textual descriptions. We present a set of speciallydeveloped textual
DSLs to fully describe graphical DSLs based on node and edge diagrams. These are, together with an EMF
meta-model, the input for a generator that produces an eclipse-based graphical Editor. The entire project
is available as open source under the name MoDiGen.
Metamodels can be considered one of the cardinal concepts of
Model-Driven Engineering and a number of coordinated entities,
suchasmodels, transformationsandtools, isdependingonit. Anal-
ogously to any software artifact, metamodels are equally prone to
evolution during their lifetime. As a consequence, whenever a
metamodelchanges, any related entity must be consistently adapted
for preserving its wellformedness, consistency, or intrinsic correct-
ness.
This work discusses the problem of co-adapting models, trans-
formations, and tools. Different aspects are taken into account and
a prospective and unifying characterization is given with the intend
ofclarifyingthemaindifficultiesandoutlinethebasicrequirements
for possible solutions. In this respect, EMFMigrate a comprehen-
sive approach to the metamodel co-evolution problem is proposed.
PYFML- A TEXTUAL LANGUAGE FOR FEATURE MODELINGijseajournal
The Feature model is a typical approach to capture variability in a software product line design and implementation. For that, most works automate feature model using a limited graphical notation represented by propositional logic and implemented by Prolog or Java programming languages. These works do not properly combine the extensions of classical feature models and do not provide scalability to implement large size problem issues. In this work, we propose a textual feature modeling language based on Python programming language (PyFML), that generalizes the classical feature models with instance feature cardinalities and attributes which be extended with highlight of replication and complex logical and mathematical cross-tree constraints. textX Meta-language is used for building PyFML to describe and organize feature model dependencies, and PyConstraint Problem Solver is used to implement feature model variability and its constraints validation. The work provides a textual human-readable language to represent feature model and maps the feature model descriptions directly into the object-oriented representation to be used by Constraint Problem Solver for computation. Furthermore, the proposed PyFML makes the notation of feature modeling more expressive to deal with complex software product line representations and using PyConstraint Problem Solver.
MODIGEN: MODEL-DRIVEN GENERATION OF GRAPHICAL EDITORS IN ECLIPSEijcsit
Domain-specific modeling is more and more understood as a comparable solution compared to classical software development. Textual domain-specific languages (DSLs) already have a massive impactin contrast
tographical DSLs, they still have to show their full potential. The established textual DSLs are normally generated from a domain specific grammar or maybe other specific textual descriptions. And advantage of textual DSLs is thatthey can be development cost-efficient. In this paper, we describe asimilar approach for the creation of graphical DSLs from textual descriptions. We present a set of speciallydeveloped textual
DSLs to fully describe graphical DSLs based on node and edge diagrams. These are, together with an EMF
meta-model, the input for a generator that produces an eclipse-based graphical Editor. The entire project
is available as open source under the name MoDiGen.
3 reasons why channel partnerships need love to lastDel Heles
Who said business partnerships didn't possess the same trails and tribulations of romantic relationships? Find out how implementing love into a b2b rapport is the single most important ingredient for a fruitful, long-living business relationship.
In this paper we present an approach of Model Versioning and Model Repository in context of Living
Models view. The idea of Living Models is a step forward from Model Based Software Development
(MBSD) in a sense that there is tight coupling between various artifacts of software development process.
These artifacts include System Models, Test Models, Executable artifacts etc. We explore the issues of
storage (import/export) of model elements into repository, inputs of cross link information, version
management and system analysis. The modeling environment in which these issues will be discussed is a
heterogeneous modeling environment, where different models types and different modeling tools are used
in the development process. An overview of the tool architecture is also presented..
This is a ppt about Software Engineering in CSE/IT.
This is only for educational purpose , not for sale.
This will help to clear all topics of that subject.
A NATURAL LANGUAGE REQUIREMENTS ENGINEERING APPROACH FOR MDA IJCSEA Journal
A software system for any information system can be developed following a model driven paradigm, in particular MDA (Model Driven Architecture). In this way, models that represent the organizational work are used to produce models that represent the information system. Current software development methods are starting to provide guidelines for the construction of conceptual models, taking as input requirements models. In MDA the CIM (Computation Independent Model) can be used to define the business process model. Though a complete automatic construction of the CIM is not possible, we have proposed in other papers the integration of some natural language requirements models and we have defined a strategy to derive a CIM from these models. In this paper, we present an improved version of our ATL transformation that implements a strategy to obtain a UML class diagram representing a preliminary CIM from requirements models allowing traceability between the source and the target models.
A natural language requirements engineering approach for mdaIJCSEA Journal
A software system for any information system can be developed following a model driven paradigm, in particular MDA (Model Driven Architecture). In this way, models that represent the organizational work are used to produce models that represent the information system. Current software development methods are starting to provide guidelines for the construction of conceptual models, taking as input requirements models. In MDA the CIM (Computation Independent Model) can be used to define the business process model. Though a complete automatic construction of the CIM is not possible, we have proposed in other papers the integration of some natural language requirements models and we have defined a strategy to
derive a CIM from these models. In this paper, we present an improved version of our ATL transformation
that implements a strategy to obtain a UML class diagram representing a preliminary CIM from requirements models allowing traceability between the source and the target models.
A NATURAL LANGUAGE REQUIREMENTS ENGINEERING APPROACH FOR MDA IJCSEA Journal
A software system for any information system can be developed following a model driven paradigm, in particular MDA (Model Driven Architecture). In this way, models that represent the organizational work are used to produce models that represent the information system. Current software development methods are starting to provide guidelines for the construction of conceptual models, taking as input requirements models. In MDA the CIM (Computation Independent Model) can be used to define the business process model. Though a complete automatic construction of the CIM is not possible, we have proposed in other papers the integration of some natural language requirements models and we have defined a strategy to derive a CIM from these models. In this paper, we present an improved version of our ATL transformation that implements a strategy to obtain a UML class diagram representing a preliminary CIM from requirements models allowing traceability between the source and the target models.
A Natural Language Requirements Engineering Approach for MDAIJCSEA Journal
A software system for any information system can be developed following a model driven paradigm, in particular MDA (Model Driven Architecture). In this way, models that represent the organizational work are used to produce models that represent the information system. Current software development methods are starting to provide guidelines for the construction of conceptual models, taking as input requirements models. In MDA the CIM (Computation Independent Model) can be used to define the business process model. Though a complete automatic construction of the CIM is not possible, we have proposed in other papers the integration of some natural language requirements models and we have defined a strategy to derive a CIM from these models. In this paper, we present an improved version of our ATL transformation that implements a strategy to obtain a UML class diagram representing a preliminary CIM from requirements models allowing traceability between the source and the target models
A NATURAL LANGUAGE REQUIREMENTS ENGINEERING APPROACH FOR MDA IJCSEA Journal
A software system for any information system can be developed following a model driven paradigm, in
particular MDA (Model Driven Architecture). In this way, models that represent the organizational work
are used to produce models that represent the information system. Current software development methods
are starting to provide guidelines for the construction of conceptual models, taking as input requirements
models. In MDA the CIM (Computation Independent Model) can be used to define the business process
model. Though a complete automatic construction of the CIM is not possible, we have proposed in other
papers the integration of some natural language requirements models and we have defined a strategy to
derive a CIM from these models. In this paper, we present an improved version of our ATL transformation
that implements a strategy to obtain a UML class diagram representing a preliminary CIM from
requirements models allowing traceability between the source and the target models.
Evolution in the Large and in the Small in Model-Driven DevelopmentAlfonso Pierantonio
Model Driven Engineering (MDE) is increasingly gaining acceptance in the development of software systems as a mean to leverage abstraction and render business logic resilient to technological changes. Coordinated collections of models and modeling languages are used to describe
applications on different abstraction levels and from different perspectives. In general, both models and metamodels are not preserved from the evolutionary pressure which inevitably affects almost any artifacts, possibly causing a cascade of adaptations which severely affects the modeling languages or the model population.
This talk analyzes the different kinds of co-adaptations which are required, distinguishing among co-evolution in the large and in the small. In particular, the coupling between models and metamodels implies that when a metamodel undergoes a modification, the conforming models require to be accordingly co-adapted. Analogously, whenever a new version of a model is produced, the generated application may require an explicit adaptation of the generated artifacts, especially when specific
assets are not directly reflected by the models and transformations, as for instance when dealing with serialized objects or with page content which is persistently stored in a database.
DESIGN AND DEVELOPMENT OF BUSINESS RULES MANAGEMENT SYSTEM (BRMS) USING ATLAN...ijcsit
Nowadays, in the world of industry end-users of business rules inside huge or small companies claims that
it’s so hard to understand the rules either because they are hand written by a specific structural or
procedural languages used only inside their organizations or because they require a certain understanding
of the back-end process. As a result, a high need for a better management system that is easy to use, easy to
maintain during the evolution process has increased. In this paper, the emphasis is put on building a
business rule management system (BRMS) as a graphical editor for editing the models in a flexible agile
manner with the assistant of ATL and Sirius frameworks within Eclipse platform. Thus, the proposed
solution, on one hand, solves the problem of wasting resources dedicated for updating the rules and on the
other hand it guarantees a great visibility and reusability of the rules.
Implementing an HL7 version 3 modeling tool from an Ecore modelSnow Owl
One of the main challenges of achieving interoperability using the HL7 V3 healthcare standard is the lack of clear definition and supporting tools for modeling, testing, and conformance checking. Currently, the knowledge defining the modeling is scattered around in MIF schemas, tools and specifications or simply with the domain experts. Modeling core HL7 concepts, constraints, and semantic relationships in Ecore/EMF encapsulates the domain-specific knowledge in a transparent way while unifying Java, XML, and UML in an abstract, high-level representation. Moreover, persisting and versioning the core HL7 concepts as a single Ecore context allows modelers and implementers to create, edit and validate message models against a single modeling context. The solution discussed in this paper is implemented in the new HL7 Static Model Designer as an extensible toolset integrated as a standalone Eclipse RCP application.
Please see our website http://b2i.sg for further information.
Using Model-Driven Engineering for Decision Support Systems Modelling, Implem...CSCJournals
Following the principle of everything is object, software development engineering has moved towards the principle of everything is model, through Model Driven Engineering (MDE). Its implementation is based on models and their successive transformations, which allow starting from the requirements specification to the code’s implementation. This engineering is used in the development of information systems, including Decision-Support Systems (DSS). Here we use MDE to propose an DSS development approach, using the Multidimensional Canonical Partitioning (MCP) design approach and a design pattern. We also use model’s transformation in order to obtain not only implementation codes, but also data warehouse feeds.
3 reasons why channel partnerships need love to lastDel Heles
Who said business partnerships didn't possess the same trails and tribulations of romantic relationships? Find out how implementing love into a b2b rapport is the single most important ingredient for a fruitful, long-living business relationship.
In this paper we present an approach of Model Versioning and Model Repository in context of Living
Models view. The idea of Living Models is a step forward from Model Based Software Development
(MBSD) in a sense that there is tight coupling between various artifacts of software development process.
These artifacts include System Models, Test Models, Executable artifacts etc. We explore the issues of
storage (import/export) of model elements into repository, inputs of cross link information, version
management and system analysis. The modeling environment in which these issues will be discussed is a
heterogeneous modeling environment, where different models types and different modeling tools are used
in the development process. An overview of the tool architecture is also presented..
This is a ppt about Software Engineering in CSE/IT.
This is only for educational purpose , not for sale.
This will help to clear all topics of that subject.
A NATURAL LANGUAGE REQUIREMENTS ENGINEERING APPROACH FOR MDA IJCSEA Journal
A software system for any information system can be developed following a model driven paradigm, in particular MDA (Model Driven Architecture). In this way, models that represent the organizational work are used to produce models that represent the information system. Current software development methods are starting to provide guidelines for the construction of conceptual models, taking as input requirements models. In MDA the CIM (Computation Independent Model) can be used to define the business process model. Though a complete automatic construction of the CIM is not possible, we have proposed in other papers the integration of some natural language requirements models and we have defined a strategy to derive a CIM from these models. In this paper, we present an improved version of our ATL transformation that implements a strategy to obtain a UML class diagram representing a preliminary CIM from requirements models allowing traceability between the source and the target models.
A natural language requirements engineering approach for mdaIJCSEA Journal
A software system for any information system can be developed following a model driven paradigm, in particular MDA (Model Driven Architecture). In this way, models that represent the organizational work are used to produce models that represent the information system. Current software development methods are starting to provide guidelines for the construction of conceptual models, taking as input requirements models. In MDA the CIM (Computation Independent Model) can be used to define the business process model. Though a complete automatic construction of the CIM is not possible, we have proposed in other papers the integration of some natural language requirements models and we have defined a strategy to
derive a CIM from these models. In this paper, we present an improved version of our ATL transformation
that implements a strategy to obtain a UML class diagram representing a preliminary CIM from requirements models allowing traceability between the source and the target models.
A NATURAL LANGUAGE REQUIREMENTS ENGINEERING APPROACH FOR MDA IJCSEA Journal
A software system for any information system can be developed following a model driven paradigm, in particular MDA (Model Driven Architecture). In this way, models that represent the organizational work are used to produce models that represent the information system. Current software development methods are starting to provide guidelines for the construction of conceptual models, taking as input requirements models. In MDA the CIM (Computation Independent Model) can be used to define the business process model. Though a complete automatic construction of the CIM is not possible, we have proposed in other papers the integration of some natural language requirements models and we have defined a strategy to derive a CIM from these models. In this paper, we present an improved version of our ATL transformation that implements a strategy to obtain a UML class diagram representing a preliminary CIM from requirements models allowing traceability between the source and the target models.
A Natural Language Requirements Engineering Approach for MDAIJCSEA Journal
A software system for any information system can be developed following a model driven paradigm, in particular MDA (Model Driven Architecture). In this way, models that represent the organizational work are used to produce models that represent the information system. Current software development methods are starting to provide guidelines for the construction of conceptual models, taking as input requirements models. In MDA the CIM (Computation Independent Model) can be used to define the business process model. Though a complete automatic construction of the CIM is not possible, we have proposed in other papers the integration of some natural language requirements models and we have defined a strategy to derive a CIM from these models. In this paper, we present an improved version of our ATL transformation that implements a strategy to obtain a UML class diagram representing a preliminary CIM from requirements models allowing traceability between the source and the target models
A NATURAL LANGUAGE REQUIREMENTS ENGINEERING APPROACH FOR MDA IJCSEA Journal
A software system for any information system can be developed following a model driven paradigm, in
particular MDA (Model Driven Architecture). In this way, models that represent the organizational work
are used to produce models that represent the information system. Current software development methods
are starting to provide guidelines for the construction of conceptual models, taking as input requirements
models. In MDA the CIM (Computation Independent Model) can be used to define the business process
model. Though a complete automatic construction of the CIM is not possible, we have proposed in other
papers the integration of some natural language requirements models and we have defined a strategy to
derive a CIM from these models. In this paper, we present an improved version of our ATL transformation
that implements a strategy to obtain a UML class diagram representing a preliminary CIM from
requirements models allowing traceability between the source and the target models.
Evolution in the Large and in the Small in Model-Driven DevelopmentAlfonso Pierantonio
Model Driven Engineering (MDE) is increasingly gaining acceptance in the development of software systems as a mean to leverage abstraction and render business logic resilient to technological changes. Coordinated collections of models and modeling languages are used to describe
applications on different abstraction levels and from different perspectives. In general, both models and metamodels are not preserved from the evolutionary pressure which inevitably affects almost any artifacts, possibly causing a cascade of adaptations which severely affects the modeling languages or the model population.
This talk analyzes the different kinds of co-adaptations which are required, distinguishing among co-evolution in the large and in the small. In particular, the coupling between models and metamodels implies that when a metamodel undergoes a modification, the conforming models require to be accordingly co-adapted. Analogously, whenever a new version of a model is produced, the generated application may require an explicit adaptation of the generated artifacts, especially when specific
assets are not directly reflected by the models and transformations, as for instance when dealing with serialized objects or with page content which is persistently stored in a database.
DESIGN AND DEVELOPMENT OF BUSINESS RULES MANAGEMENT SYSTEM (BRMS) USING ATLAN...ijcsit
Nowadays, in the world of industry end-users of business rules inside huge or small companies claims that
it’s so hard to understand the rules either because they are hand written by a specific structural or
procedural languages used only inside their organizations or because they require a certain understanding
of the back-end process. As a result, a high need for a better management system that is easy to use, easy to
maintain during the evolution process has increased. In this paper, the emphasis is put on building a
business rule management system (BRMS) as a graphical editor for editing the models in a flexible agile
manner with the assistant of ATL and Sirius frameworks within Eclipse platform. Thus, the proposed
solution, on one hand, solves the problem of wasting resources dedicated for updating the rules and on the
other hand it guarantees a great visibility and reusability of the rules.
Implementing an HL7 version 3 modeling tool from an Ecore modelSnow Owl
One of the main challenges of achieving interoperability using the HL7 V3 healthcare standard is the lack of clear definition and supporting tools for modeling, testing, and conformance checking. Currently, the knowledge defining the modeling is scattered around in MIF schemas, tools and specifications or simply with the domain experts. Modeling core HL7 concepts, constraints, and semantic relationships in Ecore/EMF encapsulates the domain-specific knowledge in a transparent way while unifying Java, XML, and UML in an abstract, high-level representation. Moreover, persisting and versioning the core HL7 concepts as a single Ecore context allows modelers and implementers to create, edit and validate message models against a single modeling context. The solution discussed in this paper is implemented in the new HL7 Static Model Designer as an extensible toolset integrated as a standalone Eclipse RCP application.
Please see our website http://b2i.sg for further information.
Using Model-Driven Engineering for Decision Support Systems Modelling, Implem...CSCJournals
Following the principle of everything is object, software development engineering has moved towards the principle of everything is model, through Model Driven Engineering (MDE). Its implementation is based on models and their successive transformations, which allow starting from the requirements specification to the code’s implementation. This engineering is used in the development of information systems, including Decision-Support Systems (DSS). Here we use MDE to propose an DSS development approach, using the Multidimensional Canonical Partitioning (MCP) design approach and a design pattern. We also use model’s transformation in order to obtain not only implementation codes, but also data warehouse feeds.
Advanced Software Engineering course - Guest Lecture
Weaving Models
This presentation has been developed in the context of the Advanced Software Engineering course at the DISIM Department of the University of L’Aquila (Italy).
http://www.di.univaq.it/malavolta
Systems variability modeling a textual model mixing class and feature conceptsijcsit
System’s reusability and cost are very important in software product line design area. Developers’ goal is
to increase system reusability and decreasing cost and efforts for building components from scratch for
each software configuration. This can be reached by developing software product line (SPL). To handle
SPL engineering process, several approaches with several techniques were developed. One of these
approaches is called separated approach. It requires separating the commonalities and variability for
system’s components to allow configuration selection based on user defined features. Textual notationbased
approaches have been used for their formal syntax and semantics to represent system features and
implementations. But these approaches are still weak in mixing features (conceptual level) and classes
(physical level) that guarantee smooth and automatic configuration generation for software releases. The
absence of methodology supporting the mixing process is a real weakness. In this paper, we enhanced
SPL’s reusability by introducing some meta-features, classified according to their functionalities. As a first
consequence, mixing class and feature concepts is supported in a simple way using class interfaces and
inherent features for smooth move from feature model to class model. And as a second consequence, the
mixing process is supported by a textual design and implementation methodology, mixing class and feature
models by combining their concepts in a single language. The supported configuration generation process
is simple, coherent, and complete.
SAP ABAP Latest Interview Questions with Answers by Garuda TrainingsGaruda Trainings
SAP ABAP Latest Interview Questions with Answers by Garuda Trainings
We, Garuda Trainings are provide SAP ABAP Online Training over globe.
For More:
http://garudatrainings.com/
Mail: garudatrainings@gmail.com
Phone: +1(508)841-6144
2. In model-driven development a series of models is created,
refined and maintained. Models are the primary artifacts of the
development and contain information that supports the various
stages of the development process. Models can capture
information of different lifecycle stages and development
activities, such as requirements, design, implementation,
testing, quality analysis, simulation, verification. In addition,
models can represent different views of the system and
represent the system on different levels of abstraction. Model
transformations provide a mechanism for automatically creating
or updating target models based on information contained in
existing source models, e.g. the creation of code from a design
model or the translation of a UML Class Diagram into an Entity
Relationship Diagram. The automatic creation of models
through model transformations provides a mechanism for the
system- attic reuse of information.
1/8/2013 2
3. Model transformations can be represented as
text or as a model.
1/8/2013 3
4. The practical foundations of model transformation techniques
are laid by compiler construction. Compilers translate programs
written in a higher programming language (such as C++) to
assembly language or representations that are close to the
executable instructions of the processor. Model transformations
solve a wider range of problems, including integration, analysis
and simulation. Thus model transformation techniques are more
universally applicable than a compiler. A compiler can even be
viewed as a special application of a model transformation. Many
of the techniques used in model transformation have a
corresponding technique in compiler construction, with a
slightly different name. For example the metamodel of model
transformation corresponds to a grammar in compiler
construction. Compilers typically have a pipeline architecture of
lexical analysis, syntax analysis, semantic analysis, intermediate
code generation and code generation. The same steps are
performed by a model transformation engine.
1/8/2013 4
5. Model transformation is a young field and there are several competings
”a program that mutates one model into another”.
The Object Management Group (OMG), an industry association for
standardization within software engineering, defines model transformation in
the context of the model-driven architecture (MDA) as
”the process of converting a model into another model of the same system”.
Kleppe et al. [32] define model transformation as the
”automatic generation of a target model from a source model, according to a
transformation description”.
Mens et al. [39] extend this definition by also allowing several models as input
or output and define model transformation as the
”automatic generation of one or multiple target models from one or multiple
source models, according to a transformation description”.
1/8/2013 5
6. A model is a simplified representation of a system
that helps to gain a better understanding of the
system. Models are often expressed in dedicated
domain-specific languages or general purpose
modeling languages such as UML. Models are
often represented graphically.
1/8/2013 6
7. A metamodel of a model X describes the
structure that model X must follow to be
valid. A metamodel can be compared to a
grammar in language design.
1/8/2013 7
8. A metametamodel of model X is the metamodel
used to describe the metamodel of model X. It can
be compared to the grammar of the language that is
used to describe the grammar of the language X.
Standards and well established frameworks for
metametamodels exist, such as MOF or Ecore. MOF
is a standard for defining metamodels that is
defined by the OMG [45]. MOF comes in two
versions: Complete MOF (CMOF) and Essential
MOF (EMOF). A commonly used implementation
of EMOF is Ecore, defined by the Eclipse Modeling
Framework (EMF) [52].
1/8/2013 8
9. A model transformation paradigm or
approach is the design principle on which the
model transformation language is built, e.g.
imperative, operational, functional,
declarative or relational.
1/8/2013 9
10. A model transformation language is a
vocabulary and a grammar with well-defined
semantics for performing model
transformations. The language is based on a
certain model transformation paradigm.
1/8/2013 10
11. A model transformation description
expresses how one or more source models are
transformed into one or more target models. It
is written in a model transformation
language. If the language of a transformation
description is rule-based, the transformation
description is a set of model transformation
rules [33]. A model transformation
description is sometimes also called model
transformation definition, model
transformation code or model transformation
program.
1/8/2013 11
12. A model transformation rule in a description is
the smallest entity within a model
transformation. It describes how a fragment of
the source model can be transformed into a
fragment of the target model [33]. A rule contains
a source pattern and a target pattern. For each
occurrence of the source pattern in the source
model, a target pattern is created in the target
model. In the context of graph transformation the
source pattern is also called the left-hand side
(LHS) and the target pattern is called right hand-
side (RHS).
1/8/2013 12
13. A model transformation engine or tool
executes or interprets the model
transformation description. It applies the
model transformation description on the
source model to produce the target model.
Transformation engines are also called
rewrite engines.
1/8/2013 13
14. SmartQVT (cf. section 6.4) or ATL (cf. section
6.2). For executing a model transformation an
engine/tool typically needs to perform the
following steps [55].
• identify elements in the source model that
need to be transformed
• for each of the identified elements produce
the associated target elements
• produce tracing information that links the
source and target elements affected by this rule
1/8/2013 14
15. In the context of a model transformation, a
model can take on the role of a source model,
if it is an input to the transformation. The
source model conforms to the source
metamodel. One or more source models are
the input of a model transformation.
1/8/2013 15
16. In the context of a model transformation, a
model can take on the role of a target model, if
it is an output of the transformation. The target
model conforms to the target metamodel. A
model transformation can have one or more
target models. The term target model is only
used for transformations that are model-to-
model transformations.
1/8/2013 16
17. The transformation description can be
represented using a model [6]. This allows the
transformation model to be the source model
or target model of another model
transformation.
1/8/2013 17
18. A model transformation description having a
transformation model as source or target
model.
1/8/2013 18
19. The term technical space or technological space
is the technology used to represent models. The
technology includes file formats, data
structures, parsers, and facilities to manipulate
the data.
Examples for technical spaces are
XML (Extensible Markup Language)
XMI (XML for Metadata Interchange)
EMF (Eclipse Modeling Frame- work)
1/8/2013 19
20. Model transformations can be used for various
tasks in model driven development, e.g. for
modifying, creating, adapting, merging,
weaving or filtering models. The reuse of
information captured in models is common to
all of these tasks. Instead of creating artifacts
from scratch, model transformations enable the
use of information that was once captured as a
model and build on it.
1/8/2013 20
21. Information from two or more models might
need to be merged into a common model. In
the simplest case, all involved models
correspond to the same metamodel. Even
merging models corresponding to different
metamodels is possible.
1/8/2013 21
22. Model transformation languages follow
different language paradigms. We introduce
the different paradigms in the following
sections.
1/8/2013 22
23. Imperative languages specify a sequential control
flow and provide means to describe how the
transformation language is supposed to be
executed. The constructs and language concepts of
imperative model transformation languages are
similar to those of general purpose programming
languages such as Java or C/C++. The languages
offer a high level of control to the programmer.
This provides flexibility and allows for efficient
implementations. The transformation is described
as a sequence of actions, which is especially useful
if the order of a set of transformation rules needs
to be controlled explicitly.
1/8/2013 23
24. Declarative languages do not offer explicit control
flow. Instead of how the transformation should be
executed, the focus is on what should be mapped
by the transformation. Declarative model
transformations describe the relationship between
the source and the target metamodels and this
relationship can be interpreted bidirectional.
For a declarative transformation between the
models A and B, the transformation description
can be executed in both directions: A 7→ B and B
7→ A. Graph transformation is a subcategory of
declarative languages, see section.
1/8/2013 24
25. Hybrid transformation languages offer both
imperative language constructs and declarative
language constructs. They leave it up to the
user whether to use imperative or declarative
language constructs.
1/8/2013 25
26. Triple Graph Grammars (TGG) are a way of
describing graph transformations.
Left-hand side graph: subgraph of the source graph
Right-hand side graph: subgraph of the target graph
Correspondence graph: describes the mapping
between elements of the left-hand side graph and
elements of the right-hand side graph.
The left-hand side describes the precondition for the
application of the rule, the right-hand side describes
the postcondition of the rule.
1/8/2013 26
27. Template-based languages are used for model-
to-text transformations. Templates contain
fragments of the target text and a meta
program that can access the source model.
Usually template based languages are
combined with the visitor pattern [25] to
traverse the internal structure of a model.
1/8/2013 27
28. General purpose programming languages can
be used to implement model transformations.
Libraries to read and write model data can be
used. As an advantage, programmers do not
need to learn a new language.
1/8/2013 28
29. 1) EMF Henshin
2) ATL
3) Query/View/Transformation (QVT)
4) Smart QVT
5) Model Morf
6) Open Architecture Ware (OAW)
7) Kermeta
8) ETL
9) XML Style sheet Language Transformations
(XSLT)
10) More ......................
1/8/2013 29