Evolving metamodels are in the center of Model-Driven Engineering, necessitating the co-evolution of dependent artifacts like models and transformations. While model co-evolution has been extensively studied, transformation co-evolution has received less attention up to now. Current approaches for transformation co-evolution provide a fixed, restricted set of metamodel (MM) changes, only. Furthermore, composite changes are treated as monolithic units, which may lead to inconsistent co-evolution for overlapping atomic changes and prohibits extensibility. Finally, transformation co-evolution is considered in isolation, possibly inducing inconsistencies between model and transformation co-evolution. To overcome these limitations, we propose a complete set of atomic MM changes being able to describe arbitrary MM evolutions. Reusability and extensibility are supported by means of change composition, ensuring an intra-artifact consistent co-evolution. Furthermore, each change provides resolution actions for both, models and transformations, ensuring an inter-artifact consistent co-evolution. Based on our conceptual approach, a prototypical implementation is presented.

Model transformations play a vital role in Model-Driven Engineering. Due to their increasing complexity, proper means for ensuring their quality are needed. Although numerous approaches for testing of model transformations have been proposed, their focus is rather on formal verification than on execution-based testing. Additionally, existing approaches do not consider the actual transformation definition, rarely provide hints for debugging in case of an error and are specific to a certain transformation language. Therefore we propose TETRA Box as a generic framework for execution-based white-box testing of transformation languages. For this, we base on symbolic execution of model transformations. Additionally, by employing our Pattern-based Modeling Language for Model Transformations (PaMoMo), we are able to provide dedicated failure traces that are aligned to the actual transformation definition as a hint for debugging.

Model-Driven Engineering places models as first-class artifacts throughout the software lifecycle requiring the availability of proper model transformation languages. Although numerous languages are available, they lack convenient facilities for debugging and supporting understanding of the transformation logic. This is not least because the underlying transformation engines operate on a low level of abstraction, hiding the operational semantics of a high-level language. Consequently, low-level debugging information is available only, e.g., variable values. To tackle these limitations, we propose a DSL on top of Colored Petri Nets (CPNs) - called Transformation Nets (TNs) - for the execution and debugging of model transformations. By integrating all artifacts of a transformation, i.e., metamodel elements, model elements, and transformation logic, a runtime model for model transformations is provided, making the afore hidden operational semantics explicit. Based on this runtime model we present various means for debugging by means of an example showing how a QVT-Relations (QVT-R) specification may be debugged using TNs.

Model transformations play a key role in the vision of Model-Driven Engineering. Thereby, the resolution of structural heterogeneities between metamodels (MMs) represents the key challenge. For this task, current approaches require the definition of partly tricky, low-level recurring transformation logic but neglect to offer reusable components. Moreover, little attention has been paid to heterogeneities caused by the concept of inheritance, although extensively used in MMs. Therefore, we propose to specify model transformations in a plug & and play manner by a set of pre-defined mapping operators (MOps) representing a DSL to resolve structural heterogeneities. For coping with inheritance in MMs, we introduce an inheritance mechanism between MOps allowing to reuse parts of the mapping definitions. Moreover, dedicated MOps for resolving heterogeneities when one MM comprises inheritance hierarchies whereas the other one does not are presented, which are well-known problems in object-relational transformations and object-oriented refactorings.

OMG's model-driven architecture (MDA) has emerged as a new approach for the development of software. For this, the query/view/transformation (QVT) standard plays a central role, since it allows for the specification of model transformations. Nevertheless, until now, QVT-tool support in general and debugging support in particular in the context of MDA are rather limited, supposable being a reason, that the adoption of QVT in practice has not yet been achieved. We therefore propose graphical debugging for the QVT Relations language based on TROPIC - a model transformation approach on the basis of coloured Petri nets. By enabling debugging on the TROPIC level, one gains several advantages when developing transformations. Firstly, debugging can take place at a high level of abstraction. Secondly, it serves for explicating the operational semantics of a transformation. Thirdly, it provides a homogenous representation of all transformation artifacts. As a first step towards QVT debugging, this paper aims at a deeper understanding of the operational semantics of QVT, classifying common pitfalls by using QVT and discussing how they may be identified at the TROPIC level.

In the Model-Driven Architecture (MDA) paradigm the Query/View/Transformation (QVT) standard plays a vital role for model transformations. Especially the high-level declarative QVT Relations language, however, has not yet gained widespread use in practice. This is not least due to missing tool support in general and inadequate debugging support in particular. Transformation engines interpreting QVT Relations operate on a low level of abstraction, hide the operational semantics of a transformation and scatter metamodels, models, QVT code, and trace information across different artifacts. We therefore propose a model-based debugger representing QVT Relations on bases of TROPIC, a model transformation language utilizing a variant of Colored Petri Nets (CPNs). As a prerequisite for convenient debugging, TROPIC provides a homogeneous view on all artifacts of a transformation on basis of a single formalism. Besides that, this formalism also provides a runtime model, thus making the afore hidden operational semantics of the transformation explicit. Using an explicit runtime model allows to employ model-based techniques for debugging, e.g., using the Object Constraint Language (OCL) for simply defining breakpoints and querying the execution state of a transformation.