logo

You are here

Warning message

Attention! This event has already passed.

A non-invasive approach for evolving Model Transformation Chains

Wednesday, 2 February, 2011 - 14:30
Campus: Brussels Humanities, Sciences & Engineering campus
Faculty: Science and Bio-engineering Sciences
Andrés Yie Garzón
phd defence

Model-Driven Engineering (MDE) approaches promote the use of models expressed in terms of problem domain concepts (e.g. Entities, Services, etc) as prime artifacts to develop software. These models, to which we refer as high-level models, can be used as input for a Model Transformation Chain (MTC). This chain is a sequence of transformation steps that converts the high-level model, which is rooted in the problem domain, into a low-level model that is rooted in the solution domain (e.g., Java, C\#). In addition to the translation from problem domain concepts to solution domain concepts (e.g., Java Class, Java Annotation), the transformation chain adds implementation details in every transformation step. In the last step of the chain, there is a model-to-text transformation that produces the code of the software system.

% For high-level models, the metamodels are rooted in the problem domain. These metamodels define the abstract syntax of a Domain-Specific Modeling Language (DSML) that is suitable to be used by domain experts. For the low-level models, the metamodels are rooted in the solution domain. These metamodels are typically closer to the definition of General-Purpose Languages (GPLs).

Evolution is an inherent characteristic of software systems. For instance, a software system must evolve if it is required to include new functionality, new non-functional properties, or the migration of the technology platform. Similar to this, MTCs are also susceptible to evolution. The evolution of an MTC confronts us with several problems mainly related to the strong dependencies between metamodels and models, metamodels and transformations, and between each transformation step and the following.

The particular problem we address is the addition of a new concern (e.g., security, monitoring) that was not anticipated in an existing MDE implementation. No real problem arises if the new concern can be cleanly expressed using the existing high-level metamodel. However, if this is not the case, the addition of the new concern will lead to a number of maintenance problems, such as metamodels that are polluted with alien concepts, models which no longer conform to the metamodels, transformations that are no longer compatible with the new metamodels, or broken dependencies between transformations. All of these problems are a detriment to the evolution of an existing MTC and a single change can cause a ripple effect through every transformation step.

We present a strategy that consists of modularizing the new concern in a new concern-specific MTC. First, we specify the new concern in a separate high-level model. This leaves the original model unaltered and unaware of the added concern. The concern-specific model can thus be specified using concepts close to its domain which are expressed in a separate metamodel. Therefore, we have two high-level models that conform to two different metamodels. We align the high-level models using a Correspondence Model (CM), which explicitly describes correspondence relationships among the elements of different models. Next, both models are transformed by the MTCs (i.e., the existing MTC and the new concern-specific MTC) that produce two complementary low-level models that conform to the same metamodel. We use the CM between the high-level models to derive a new CM between the lowest level models. We use these correspondence relationships to identify the elements to compose. Finally, we perform a composition between homogeneous concepts that conform to the same metamodel. Furthermore, when the lowest level models conform to different metamodels (i.e., different technological platforms) it is possible to use the correspondence relationships to check consistency between the models or to generate code-level composition specifications (e.g., the XML descriptors between a Java application and a database).

We have developed a mechanism to automatically derive the CM through the various steps in the MTCs. This mechanism allows us to reuse the presented approach to add additional concern-specific MTCs to an existing MTC reducing the impact to the existing MTC artifacts and modularizing the changes.

In this dissertation we present an approach that reduces the complexity of evolving a model transformation chain. Our approach offers several advantages: 1) it reuses the existing assets (metamodels, models and transformations), 2) it modularizes the changes in a new set of metamodels, models and transformations, 3) it facilitates the modeling of different concerns in separated models and close to the problem domain, 4) it offers an automatic derivation mechanism to identify the elements to compose in the low-level models based on relationships defined in the high-level, and 5) it eases the use of a reusable mechanism to integrate the changes.