Steffen Kruse - Co-Evolution of Metamodels and Model Transformations: An operator-based, stepwise approach for the impact resolution of metamodel evolution on model transformations.

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).

Complexity is an essential property of software systems that increases in a non-linear fashion with the size of the software system []. 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..

During the MoDELS08 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. []

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. []

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. []

Figure 1.1.: The impact on metamodel evolution on dependent artefacts

Co-evolution is the model engineering task of changing dependent artefacts together to maintain consistency []. What constitutes consistency depends on the artefacts involved, for metamodels and models it is given in part by the conformance of the models to their metamodels. For metamodels and transformations, it is for one the suitability of the metamodel to represent the input and output models of the model transformation. But the expected function of the transformation also needs to be taken into account; an evolutionary change can introduce inconsistencies that cause a transformation to produce the wrong output, although it is still executable.

by the execution or it can simply be the concrete pair of models a and b that are linked by the transformation.

Evolution occurs in the form of some change done to metamodel A, represented by the curved arrow at . An important part of handling the evolution of dependent artefacts is determining or recording what kind of change has taken place in a metamodel. A variety of different approaches dedicated to this problem exist for different purposes and technologies. These are discussed in introduces an operator-based approach to describe possible changes made to a metamodel that is suited to resolving co-evolution issues with dependent transformations written in ATL.

After the metamodel is changed, the relationships to the other artefacts involved in the transformation may no longer hold and need to be evaluated and updated accordingly for the transformation to be consistent. This is represented in the figure by the flash symbol. The first relation is that of all the models