Table Of ContentAbstract
With the continual increase in size and complexity of modern software systems,
the evolution of software remains one of the big challenges of software
engineering. Model Driven Engineering (MDE) is one approach to meet this
challenge – by breaking down the description of software systems under
development into manageable abstractions, each embodied by a suitable kind of
artefact. Kinds of artefacts are models and metamodels, along with model
transformations, (modelling) languages, generators and others. Yet the benefits
expected from MDE can only be fully realised when the complexity of the MDE
artefacts and their relationships remain manageable themselves.
The challenge addressed in this context by this thesis is the co-evolution of
metamodels and model transformations; expressed as transformation
descriptions in common, dedicated transformation languages. Transformations
are used to produce output models conforming to a metamodel based on input
models conforming to another (or the same) metamodel and are expressed in
terms of the metamodels used. This enforces a tight coupling between
metamodels and transformation descriptions. In consequence, any change made
to one or more metamodel potentially invalidates existing transformations so that
every change requires the validation and adaptation of all dependent
transformations. This can lead to an exceeding amount of effort necessary to
keep metamodels and transformations consistent as the number of
transformations and metamodels increase.
This work presents an operator-based, stepwise approach to support software
architects in the co-evolution of metamodels and transformations. To this end we
propose a set of operators which, when applied to metamodels, perform an
evolution step on the metamodel. The impacts of such a change in the form of an
operator applied to a metamodel can be predicted for transformations that
depend on the metamodel. The approach further allows the resolution of the
impacts to restore consistency, either automatically or with minimal human input
– depending on the type of change and the kind and complexity of the
transformation. In the worst case, the use of operators at least indicates
potentially invalid transformation parts that need further validation to fulfil their
original intended purpose. Overall the approach reduces the effort needed for co-
evolution.
The approach is implemented and integrated into MDE tooling commonly used
for modelling and transformation creation to demonstrate its feasibility. The
operators are formalised on the basis of the Essential MOF (EMOF) and the
impact resolution is provided for the ATLAS Transformation Language (ATL).
Contents
Abstract
1. Introduction
1.1. Motivation
1.2. Application Scenario
1.3. Contribution
1.4. Outline
I Foundations
2. Model Driven Engineering
2.1. Model
2.2. Metamodel
2.3. The Meta Object Facility (MOF)
2.4. The Eclipse Modeling Framework (EMF) / Ecore
2.5. Model Transformations
3. Model Transformation Languages
3.1. Model Transformation Language Features
3.2. The ATLAS Transformation Language (ATL)
3.3. MOF Query/View/Transformation (QVT)
3.4. The Object Constraint Language (OCL)
4. Software Evolution and MDE
4.1. MDE and the Evolution of MDS
4.2. Model Refactoring
II Operator-based Co-Evolution of Metamodels and Model
Transformations
5. Supporting the Evolution of Model Driven Systems: A Stepwise
Approach
5.1. Problem Description
5.2. Goal: Providing Support for Co-Evolution
5.3. Requirements
5.4. Approach
5.5. Phase 1: Metamodel Adaptation
5.6. Phase 2: Operator Impact Detection
5.7. Phase 3: Impact Resolution
5.8. The Overall Co-Evolution Process
6. Operators for EMOF Metamodel Evolution
6.1. On the Usage of the QVT-R Graphical Notation for Operator
Definition
6.2. Operator Overview
6.3. Add / Remove Element
6.4. Move Property
6.5. Push Simple Property
6.6. Push Complex Property
6.7. Pull Simple Property
6.8. Pull Complex Property
6.9. Restrict (Unidirectional) Property
6.10. Generalise (Unidirectional) Property
6.11. Extract Class
6.12. Inline Class
6.13. Extract Superclass
6.14. Flatten Hierarchy
6.15. Association to Class
6.16. Generalization to Composition
6.17. Introduce Composite Pattern
7. Impact Resolution for ATL
7.1. Operator Impact Overview
7.2. Support Functions and Omissions
7.3. Add Element
7.4. Remove Element
7.5. Rename NamedElement
7.6. Move Property
7.7. Push Simple Property
7.8. Push Complex Property
7.9. Pull Simple Property
7.10. Pull Complex Property
7.11. Restrict (Unidirectional) Property
7.12. Generalise (Unidirectional) Property
7.13. Extract Class
7.14. Inline Class
7.15. Extract Superclass
7.16. Flatten Hierarchy
7.17. Association to Class
7.18. Generalization to Composition
7.19. Introduce Composite Pattern
8. Related Work
8.1. Co-Evolution of Metamodels and Models
8.2. Co-Evolution of Models and OCL Constraints
8.3. Co-Evolution of of Metamodels and Transformations
8.4. Comparison
III Validation and Conclusion
9. Evaluation
9.1. Completeness
9.2. Petri Net Evolution Scenario
9.3. Summary
10. Proof of Concept Prototype
10.1. Overview
10.2. Preliminary Considerations
10.3. ATL Concrete and Abstract Syntax Implementation
10.4. Graphical Model Editor
10.5. Operator Implementation
10.6. Impact Detection and Resolution
11. Conclusion
11.1. Summary
11.2. Benefits
11.3. Future Work
Appendix
A. Execution of Extract Superclass
B. ATL Implementation in Xtext
Glossary
Acronyms
List of Figures
List of Listings
Index
Bibliography
CHAPTER 1
Introduction
Complexity is an essential property of software systems that increases in a non-
linear fashion with the size of the software system [16]. Model Driven
Engineering (MDE) is a software engineering approach that aims to alleviate this
complexity in software development and maintenance by utilising models and
modelling activities to raise the level of abstraction and to automate the
production of artefacts. One specialised approach with this purpose is the model
transformation, which allows the automated creation and modification of output
models based on input models. Model transformations can be expressed in
specialised transformation languages to be executed by a transformation engine.
As models and model transformations are used in a productive capacity in
software engineering, they underlie the same evolutionary pressure that
conventionally build software systems do. Here the tight coupling between
model transformations and metamodels becomes problematic, as changing the
one often results in the need to check and adapt the other accordingly.
This thesis presents an approach to lessen this co-evolution problem by
providing a systematic method to software architects of describing changes done
to a metamodel and determining and resolving the impact on related model
transformations.
The remainder of this chapter motivates this approach. Section 1.1 describes the
co-evolution problem for metamodels and model transformations in more detail
and Section 1.2 provides a simple illustration as an application scenario. Section
1.3 lists the proposed scientific contributions of this work. An outline of this
thesis is provided in Section 1.4.
1.1. Motivation
During the MoDELS’08 conference a workshop was held to identify
‘Challenges in Model-Driven Software Engineering’ and to propose the ways in
which to best address these challenges in the next 10 or more years. Two of the
challenges brought forward by the participants were the lack of proper process
support for model driven engineering activities and specifically the lack of
support for model evolution and inconsistency management in large, multi-user
and distributed development settings. [105]
The participants argued that models can become inconsistent where
dependencies between them exist, especially if the models are developed in a
distributed fashion. As a first step to a solution, the need to identify the change
types possible and the possible ways to resolve their impact on dependencies
were identified. Furthermore, rapid prototyping for domain-specific modelling
languages would be needed, as rapid prototyping provides the advantage of
‘continuous, incremental feedback’ for development in MDE. Yet rapid
prototyping can only be achieved if handling the dependencies between
modelling artefacts can be done as rapidly as evolving the prototype. The focus
here was mainly on the relationship between models and metamodels, but the
argument is also valid for model transformations that depend on the metamodels
they are build on. [105]
In 2011, Hans Vangheluwe identified the evolution of development artefacts
used in MDE, specifically models and modelling languages as a major challenge
for the community, as the evolution of models has repercussions on all related
artefacts, amongst them model transformations. He suggest for MDE and the
related Domain Specific Modelling (DSM):
‘If MDE and DSM are to be usable at an industrial scale, modeling
language evolution has to be dealt with, ideally by (semi-)
automatically co-evolving artifacts.’ [106]
