Present position: Temporary Researcher
|Thesis title:||Model-to-Model Transformations for Artifact Generation in Model-Driven Environments|
|Research area:||Advanced Software Architectures and Methodologies|
Model-Driven Engineering (MDE) is the approach to constructing software systems that advocates the use of models as the fundamental artifact of the development process. In MDE, models are used to design software systems, to document them, and to automatically generate part of the implementation code. They are expressed using modeling languages, whose syntactic rules are themselves encoded as models, the so-called metamodels. Models are manipulated using model transformations, defined by a set of transformation rules that together describe how a model in the source language can be transformed to a model in the target language. Each transformation rule is a (usually declarative) expression of the correspondence between one or more constructs in the source language and one or more constructs in the target language. Model transformations are themselves represented as models, called transformation models, and consequently they can be manipulated by other transformations. These transformations are indicated as higher-order transformations (HOTs). While the principal use of models and transformations is that of guiding the forward engineering of systems, MDE is extending its reach beyond the generation of code from Platform-Independent Models, to all the phases of the software life-cycle. Once the modeling phase is a stable part of the development process, there is no reason not to exploit the same infrastructure with the purpose to automatize other activities in the software engineering process. Beside the main code-generation transformations, a vast library of generative approaches can be developed to address the automatic creation of several artifacts, necessary in development. Some examples of such artifacts are test sets, mutations, metrics and quantitative analysis, software documentation.
This thesis focuses on the generation of software engineering artifacts from the elements of a model-driven environment, by means of model transformations. The space of the possible transformations for artifact generation is partitioned in four classes, namely: model-to-model transformations (M2M), metamodel-to-metamodel transformations (MM2MM), cross-level transformations (M2MM and MM2M), higher-order transformations (HOT). For each class of model transformations this thesis provides: 1) a description of the transformation patterns that are possible in that class, 2) a review of the most important related work, 3) a discussion about the best practices for using the transformation class in the generation of artifacts for software engineering, 4) a deeply investigated use case for the transformation class, implemented and evaluated in the chosen specific domain of the thesis, model-driven development of Web applications. This categorization and discussion of the transformational approaches to artifact generation in model-driven environments is the most general contribution of this thesis. In this discussion, each considered use case is both a proof-of-concept of the practical applicability of the general ideas, and a source of other original results related to the specific correspondent task. These application-dependent contributions include: 1) a validated transformation tool to generate a Function Point Analysis starting from Web application models, the first tool to generate a FPA from an implementation model (in the M2M class); 2) a HOT framework to automatically synchronize, consequently to a change in the M3 level (the metametamodel), both the M2 level (the metamodels) and the M1 level (the models) (in the MM2MM class); 3) the first HOT framework for cross-level transformations applied to test case generation (in the MM2M class); 4) the first HOT framework for mutation analysis of model transformations (in the HOT class). Finally this thesis outlines a set of pointers for future work in the model transformation field, in a general effort to unify methods and tools for software engineering under the same model-driven paradigm.