Davide Di Ruscio

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.

Coupled Evolution in Model-Driven Engineering

Model-driven engineering bases a wide range of artifacts on metamodels. When such metamodels evolve, such as a new version of Unified Modeling Language or Business Process Execution Notation or a company-specific metamodel, underlying artifacts often become invalid. In this article, the authors provide an overview of coupled evolution methods and tools to handle such dependencies. I look forward to hearing from both readers and prospective authors about this column and the technologies you want to know more about.

Evolutionary togetherness: how to manage coupled evolution in metamodeling ecosystems

In Model-Driven Engineering (MDE) metamodels are cornerstones for defining a wide range of related artifacts interlaced with explicit or implicit correspondences. According to this view, models, transformations, editors, and supporting tools can be regarded as a whole pursuing a common scope and therefore constituting an ecosystem. Analogously to software, metamodels are subject to evolutionary pressures too. However, changing a metamodel might compromise the validity of the artifacts in the ecosystem which therefore require to co-evolve as well in order to restore their validity. Different approaches have been proposed to support at different extent the adaptation of artifacts according to the changes operated on the corresponding metamodels. Each technique is specialized in the adaptation of specific kind of artifact (e.g., models, or transformations) by forcing modelers to learn different technologies and languages. This paper discusses the different relations occurring in a typical metamodeling ecosystem among the metamodel and the related artifacts, and identifies the commonalities which can be leveraged to define a unifying and comprehensive adaptation process. A language and corresponding supporting tools are also proposed for the management of metamodel evolution and the corresponding togetherness with the related artifacts.