Alfonso Pierantonio

Automating Co-evolution in Model-Driven Engineering

Software development is witnessing the increasing need of version management techniques for supporting the evolution of model-based artefacts. In this respect, metamodels can be considered one of the basic concepts of model-driven engineering and are expected to evolve during their life-cycle. As a consequence, models conforming to changed metamodels have to be updated for preserving their well-formedness. This paper deals with the co-adaptation problems by proposing higher-order model transformations which take a difference model recording the metamodel evolution and produce a model transformation able to co-evolve the involved models.

A Metamodel Independent Approach to Difference Representation

It is of critical relevance that designers are able to comprehend the various kinds of design-level modifications that a system undergoes throughout its entire lifecycle. In this respect, an interesting and useful operation between subsequent system versions is the model difference calculation and representation. In this paper, a metamodel independent approach to the representation of model differences which is agnostic of the calculation method is presented. Given two models which conform to a metamodel, their difference is conforming to another metamodel derived from the former by an automated transformation. Difference models are first-class entities which induce transformations able to apply the modifications they specify. Finally, difference models can be composed sequentially and in parallel giving place to more complex modifications.

Different models for model matching: An analysis of approaches to support model differencing

Calculating differences between models is an important and challenging task in Model Driven Engineering. Model differencing involves a number of steps starting with identifying matching model elements, calculating and representing their differences, and finally visualizing them in an appropriate way. In this paper, we provide an overview of the fundamental steps involved in the model differencing process and summarize the advantages and shortcomings of existing approaches for identifying matching model elements. To assist potential users in selecting one of the existing methods for the problem at stake, we investigate the trade-offs these methods impose in terms of accuracy and effort required to implement each one of them.

JTL: a bidirectional and change propagating transformation language

In Model Driven Engineering bidirectional transformations are considered a core ingredient for managing both the consistency and synchronization of two or more related models. However, while non-bijectivity in bidirectional transformations is considered relevant, current languages still lack of a common understanding of its semantic implications hampering their applicability in practice. In this paper, the Janus Transformation Language (JTL) is presented, a bidirectional model transformation language specifically designed to support nonbijective transformations and change propagation. In particular, the language propagates changes occurring in a model to one or more related models according to the specified transformation regardless of the transformation direction. Additionally, whenever manual modifications let a model be non reachable anymore by a transformation, the closest model which approximate the ideal source one is inferred. The language semantics is also presented and its expressivity and applicability are validated against a reference benchmark. JTL is embedded in a framework available on the Eclipse platform which aims to facilitate the use of the approach, especially in the definition of model transformations.

Managing Model Conflicts in Distributed Development

The growing complexity of current software systems naturally conveyed their development toward incremental and distributed approaches to speed up the process. Several developers update the same artefact operating concurrent manipulations which need to be coherently combined. The interaction among those changes inevitably involves conflicts which must be detected and reconciled. This paper proposes a domain specific language able to define and manage conflicts caused by cooperative updates over the same model elements. The approach relies on a model-based representation of model differences and enables the specification and the detection of both syntactical and semantic conflicts.

Managing Dependent Changes in Coupled Evolution

In Model-Driven Engineering models and metamodels are not preserved from the evolutionary pressure which inevitably affects almost any artefacts. Moreover, the coupling between models and metamodels implies that when a metamodel undergoes a modification, the conforming models require to be accordingly co-adapted. One of the main obstacles to the complete automation of the adaptation process is represented by the dependencies which occur among the different kinds of modifications. The paper illustrates a dependency analysis, classifies such dependencies, and proposes a metamodeling language driven resolution which is independent from the evolving metamodel and its underlying semantics. The resolution enables a decomposition and consequent scheduling of the adaptation steps allowing the full automation of the process.

What is needed for managing co-evolution in MDE?

Metamodels can be considered one of the cardinal concepts of Model-Driven Engineering, one which a number of coordinated entities such as models, transformations and tools, are dependent on. Analogously to any software artifact, metamodels are equally prone to evolution during their lifetime. As a consequence, whenever a metamodel changes, any related entity must be consistently adapted for preserving its wellformedness, consistency, or intrinsic correctness. This paper discusses the problem of co-adapting models, transformations, and tools. Different aspects are taken into account and a prospective and unifying characterization is given with the intent of clarifying the main difficulties and outline the basic requirements for possible solutions. In this respect, EMFMigrate a comprehensive approach to the metamodel co-evolution problem is proposed.

Developing next generation ADLs through MDE techniques

Despite the flourishing of languages to describe software architectures, existing Architecture Description Languages (ADLs) are still far away from what it is actually needed. In fact, while they support a traditional perception of a Software Architecture (SA) as a set of constituting elements (such as components, connectors and interfaces), they mostly fail to capture multiple stakeholders concerns and their design decisions that represent a broader view of SA being accepted today. Next generation ADLs must cope with various and ever evolving stakeholder concerns by employing semantic extension mechanisms. In this paper we present a framework, called byADL - Build Your ADL, for developing a new generation of ADLs. byADL exploits model-driven techniques that provide the needed technologies to allow a software architect, starting from existing ADLs, to define its own new generation ADL by: i) adding domain specificities, new architectural views, or analysis aspects, ii) integrating ADLs with development processes and methodologies, and iii) customizing ADLs by fine tuning them. The framework is put in practice in different scenarios showing the incremental extension and customization of the Darwin ADL.

On the Impact Significance of Metamodel Evolution in MDE.

Harnessing metamodels to engineer application domains is at the core of Model-Driven Engineering. A large number of artifacts pursuing a common scope are defined starting from metamodels which represent the nucleus of an ecosystem. Analogously to any software artifact, metamodels are equally prone to evolution. However, changing a metamodel might affect the components of the ecosystem. In fact, when a metamodel undergoes modifications, the related artifacts might require to be consistently adapted in order to recovery their validity. This is an intrinsically difficult process. It requires different techniques for each specific kind of artifact and can easily lead to inconsistencies and irremediable information erosion, if based on spontaneous and individual skills. This paper discusses the problem of identifying, predicting and evaluating the significance of the metamodel change impact over the existing artifacts. The approach is agnostic of the adaptation technique and formalizes the whole ecosystem and the relatedness of the involved artifacts in terms of megamodels. This allows developers i) to establish relationships between the metamodel and its related artifacts, and ii) to automatically identify those elements within the various artifacts affected by the metamodel changes. The approach can be considered as preparatory to any systematic adaptation process.

A model-driven approach to automate the propagation of changes among Architecture Description Languages

As it is widely recognized, a universal notation accepted by any software architect cannot exist. This caused a proliferation of architecture description languages (ADLs) each focussing on a specific application domain, analysis type, or modelling environment, and with its own specific notations and tools. Therefore, the production of a software architecture description often requires the use of multiple ADLs, each satisfying some stakeholder’s concerns. When dealing with multiple notations, suitable techniques are required in order to keep models in a consistent state. Several solutions have been proposed so far but they lack in convergence and scalability. In this paper, we propose a convergent change propagation approach between multiple architectural languages. The approach is generic since it depends neither on the notations to synchronize nor on their corresponding models. It is implemented within the Eclipse modelling framework and we demonstrate its usability and scalability by experimenting it on well known architectural languages.