Romina Eramo

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.

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.

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.

Digging into UML models to remove performance antipatterns

Performance antipatterns have been informally defined and characterized as bad practices in software design that can originate performance problems. Such special type of patterns can involve static and dynamic aspects of software as well as deployment features. It has been shown that quite often the inability to meet performance requirements is due to the presence of antipatterns in the software design. However the problem of formally defining antipatterns and automatically detect them within a design model has not been investigated yet. In this paper we examine this problem within the UML context and show how performance antipatterns can be defined and detected in UML models by mean of OCL. A case study in UML annotated with the MARTE profile is presented where, after a performance analysis that shows unsatisfactory results, performance antipatterns are detected through an OCL engine. The identification of an antipattern suggests the architectural alternatives that can remove that specific problem. We show in our example that the removal of a certain antipattern actually allows to overcome a specific performance problem.

Change Management in Multi-Viewpoint System Using ASP

Viewpoint modeling is an effective technique for specifying complex software systems in terms of a set of independent viewpoints and correspondences between them. Each viewpoint focuses on a particular aspect of the system, abstracting away from the rest of the concerns. Correspondences specify the relationships between the elements in different views, together with the constraints that guarantee the consistency among these elements. However, most Enterprise Architectural Frameworks, which follow a multi-viewpoint approach, either do not consider the explicit specification of correspondences, or do it in a very simplistic way. In this paper we examine the representation of correspondences in the context of the RM-ODP, identify some of its related issues, and propose some improvements to the way in which correspondences are modeled. In particular, we claim that multi-viewpoint modeling approaches need to specify not only the correspondences between the system views, but also some well-formed rules on such set of correspondence specifications.

Managing uncertainty in bidirectional model transformations

In Model-Driven Engineering bidirectionality in transformations is regarded as a key mechanism. Recent approaches to non-deterministic transformations have been proposed for dealing with non-bijectivity. Among them, the JTL language is based on a relational model transformation engine which restores consistency by returning all admissible models. This can be regarded as an uncertainty reducing process: the unknown uncertainty at design-time is translated into known uncertainty at run-time by generating multiple choices. Unfortunately, little changes in a model usually correspond to a combinatorial explosion of the solution space. In this paper, we propose to represent the multiple solutions in a intensional manner by adopting a model for uncertainty. The technique is applied to JTL demonstrating the advantages of the proposal.

Model transformations

In recent years, Model-Driven Engineering has taken a leading role in advancing a new paradigm shift in software development. Leveraging models to a first-class status is at the core of this methodology. Shifting the focus of software development from coding to modeling permits programs to transform models in order to generate other models which are amenable for a wide range of purposes, including code generation. This paper introduces a classification of model transformation approaches and languages, illustrating the characteristics of the most prominent ones. Moreover, two specific application scenarios are proposed to highlight bidirectionality and higher-order transformations in the change propagation and coupled evolution domains, respectively.

Uncertainty in bidirectional transformations

In Model-Driven Engineering, models are primary artifact manipulated by means of automated transformations. Recently, a notion of uncertainty has been introduced in models permitting modelers to postpone design decisions in case of lack of information. Interestingly, other forms of model uncertainty are induced by bidirectional transformations. In fact, in certain situations more than one admissible solution is in principle possible, despite most of the current languages generate only one model at time, possibly not the desired one. In this paper, the uncertainty due to the solution multiplicity in bidirectional transformations is discussed. In particular, we propose to represent the models in the solution space as concretizations of an uncertain model because there are cases where the responsibility of identifying the solution must be left to the modeler. The problem is illustrated by a round-tripping scenario realized with the JTL transformation language.

Approaching the Model-Driven Generation of Feedback to Remove Software Performance Flaws

The problem of interpreting results of performance analysis and providing feedback on software models to overcome performance flaws is probably the most critical open issue in the field of software performance engineering. Automation in this step would help to introduce performance validation as an integrated activity in the software lifecycle, without dramatically affecting the daily practices of software developers. In this paper we approach the problem with model-driven techniques, on which we build a general solution. Basing on the concept of performance antipatterns, that are bad practices in software modeling leading to performance flaws, we introduce metamodels and transformations that can support the whole process of flaw detection and solution. The approach that we propose is notation-independent and can be embedded in any (existing or future) concrete modeling notation by using weaving models and automatically generated model transformations. Finally, we discuss the issues opened from this work and the future achievements that are at the hand in this domain thanks to model-driven techniques.

Performance-driven architectural refactoring through bidirectional model transformations

The generation of performance models from architectural models has been tackled with well-founded approaches in the last decade, whereas there is a clear lack of automation in the backward path that brings the analysis results back to the software architecture. It is common to iteratively modify a (generated) performance model until performance indices meet the requirements. However, propagating the performance model modifications back to the original architectural model is a complex problem. In this paper we make a first step in this direction, in that we use the JTL language for specifying a bidirectional model transformation between UML models and Queueing Networks, so working towards an automated round-trip process between software architectural models and performance models.