View on GitHub

Transformation Cluster Analysis

Remodularizing QVT-O and Xtend Model Transformations with Bunch

Download this project as a .zip file Download this project as a tar.gz file

It is vital to decompose large model transformation programs into manageable modules in order to keep them in a maintainable state. Transformation Cluster Analysis (TCA) is our endeavor to alleviate the effort that is required to reengineer the modular structure of model transformation programs. It does so by automatically extracting dependence information from transformation programs that can be automatically clustered with the Bunch tool. The approach currently supports the model-to-model transformation language QVT-Operational, and the Xtend language employable as an Ecore-based model-to-text transformation language.


In model-driven engineering, model transformations play a critical role as they transform models into other models and finally into executable code. Whereas models are typically structured into packages, transformation programs can be structured into modules to cope with their inherent code complexity. As the models evolve, the structure of transformations steadily deteriorates, and eventually leads to adverse effects on the productivity during maintenance. At the present time, discovering concern-/based structures of transformation programs to help in understanding and refactoring them remains a manual process.

This approach makes it possible to apply clustering algorithms to find decompositions of transformation programs at the method level. In contrast to clustering techniques for general-purpose languages, we integrate not only method calls but also class and package dependencies of the models into the process. The approach relies on the Bunch tool for finding decompositions with minimal coupling and maximal cohesion.

Our approach had been validated in two case studies, one model-to-model and one model-to-code transformation, where we compare an expert clustering with automatically derived clusterings. We are able to demonstrate that by incorporating model dependencies we gain results that reflect the intended structure significantly better than when incorporating call dependencies alone.


TCA runs on the Eclipse Modeling Tools. The following steps assume a fresh installation of Eclipse.

You are ready to use the code-to-model transformations to produce Bunch-compatible module dependence graphs (MDG) from QVT-O and Xtend programs. The extant module configuration is extracted as well from the sources and stored as a SIL definition. To do so, configure the workflow definition (either Qvto2Mdg.mwe or Xtend2Mdg.mwe) to refer to the transformation code and the models involved. Additionally, setup the weight configuration (Constants.xtend or Constants.xtend). Use the run configuration Generate QVTo Dependency Graph, or Generate Xtend Dependency Graph. Resulting MDG and SIL file are placed into the src-gen folder of the respective Eclipse project.

The MDG file can serve as input to the Bunch tool built at Drexel University, and the output can be compared with the preexisting partition stored in the SIL file using Bunch's built-in metrics.

Case Studies

We already used the approach to extract dependence information from two larger transformations from the Palladio project,

Results of these studies are stored in a separate Eclipse project, edu.kit.ipd.sdq.mdsd.bunch-casestudy.

See Also


Work has partly been funded by the German Research Foundation (DFG) under under the Priority Programme SPP 1593: Design For Future -- Managed Software Evolution.