Javier Troya

Modular DSLs for Flexible Analysis: An e-Motions Reimplementation of Palladio

We address some of the limitations for extending and validating MDE-based implementations of NFP analysis tools by presenting a modular, model-based partial reimplementation of one well-known analysis framework, namely the Palladio Architecture Simulator. We specify the key DSLs from Palladio in the e-Motions system, describing the basic simulation semantics as a set of graph transformation rules. Different properties to be analysed are then encoded as separate, parametrised DSLs, independent of the definition of Palladio. These can then be composed with the base Palladio DSL to generate specific simulation environments. Models created in the Palladio IDE can be fed directly into this simulation environment for analysis. We demonstrate two main benefits of our approach: 1) The semantics of the simulation and the non-functional properties to be analysed are made explicit in the respective DSL specifications, and 2) because of the compositional definition, we can add definitions of new non-functional properties and their analyses.

A Rewriting Logic Semantics for ATL

As the complexity of model transformation (MT) grows, the need to rely on formal semantics of MT languages becomes a critical issue. Formal semantics provide precise specications of the expected behavior of transformations, allowing users to understand them and to use them properly, and MT tool builders to develop correct MT engines, compilers, etc. In addition, formal semantics allow modelers to reason about the MTs and to prove their correctness, something specially important in case of large and complex MTs (with, e.g., hundreds or thousands of rules) for which manual debugging is no longer possible. In this paper we give a formal semantics of the ATL 3.0 model transformation language using rewriting logic and Maude, which allows addressing these issues. Such formalization provides additional benets, such as enabling the simulation of the specications or giving access to the Maude toolkit to reason about them.

Static Fault Localization in Model Transformations

As the complexity of model transformations grows, there is an increasing need to count on methods, mechanisms, and tools for checking their correctness, i.e., the alignment between specifications and implementations. In this paper we present a light-weight and static approach for locating the faulty rules in model transformations, based on matching functions that automatically establish these alignments using the metamodel footprints, i.e., the metamodel elements used. The approach is implemented for the combination of Tracts and ATL, both residing in the Eclipse Modeling Framework, and is supported by the corresponding toolkit. An evaluation discussing the accuracy and the limitations of the approach is also provided. Furthermore, we identify the kinds of transformations which are most suitable for validation with the proposed approach and use mutation techniques to evaluate its effectiveness.

Matching business process workflows across abstraction levels

In Business Process Modeling, several models are defined for the same system, supporting the transition from business requirements to IT implementations. Each of these models targets a different abstraction level and stakeholder perspective. In order to maintain consistency among these models, which has become a major challenge not only in this field, the correspondence between them has to be identified. A correspondence between process models establishes which activities in one model correspond to which activities in another model. This paper presents an algorithm for determining such correspondences. The algorithm is based on an empirical study of process models at a large company in the banking sector, which revealed frequent correspondence patterns between models spanning multiple abstraction levels. The algorithm has two phases, first establishing correspondences based on similarity of model element attributes such as types and names and then refining the result based on the structure of the models. Compared to previous work, our algorithm can recover complex correspondences relating whole process fragments rather than just individual activities. We evaluate the algorithm on 26 pairs of business-technical and technical-IT level models from four real-world projects, achieving overall precision of 93% and recall of 70%. Given the substantial recall and the high precision, the algorithm helps automating significant part of the correspondence recovery for such models.

Towards a rewriting logic semantics for ATL

As the complexity of model transformation (MT) grows, the need to count on formal semantics of MT languages also increases. Firstly, formal semantics provide precise specifications of the expected behavior of transformations, which are crucial for both MT users (to be able to understand them and to use them properly) and MT tool builders (to develop correct MT engines, optimizers, etc.). Secondly, we need to be able to reason about the MTs to prove their correctness. This is specially important in case of large and complex MTs (with, e.g., hundreds or thousands of rules) for which manual debugging is no longer possible. In this paper we present a formal semantics to the ATL model transformation language using rewriting logic and Maude, which allows addressing these issues. This formalization provides additional benefits, such as enabling the simulation of the specifications or giving access to the Maude toolkit to reason about them.

Model-driven performance analysis of rule-based domain specific visual models

Context: Domain-Specific Visual Languages (DSVLs) play a crucial role in Model-Driven Engineering (MDE). Most DSVLs already allow the specification of the structure and behavior of systems. However, there is also an increasing need to model, simulate and reason about their non-functional properties. In particular, QoS usage and management constraints (performance, reliability, etc.) are essential characteristics of any non-trivial system. Objective: Very few DSVLs currently offer support for modeling these kinds of properties. And those which do, tend to require skilled knowledge of specialized notations, which clashes with the intuitive nature of DSVLs. In this paper we present an alternative approach to specify QoS properties in a high-level and platform-independent manner. Method: We propose the use of special objects (observers) that can be added to the graphical specification of a system for describing and monitoring some of its non-functional properties. Results: Observers allow extending the global state of the system with the variables that the designer wants to analyze, being able to capture the performance properties of interest. A performance evaluation tool has also been developed as a proof of concept for the proposal. Conclusion: The results show how non-functional properties can be specified in DSVLs using observers, and how the performance of systems specified in this way can be evaluated in a flexible and effective way.

Simulating domain specific visual models by observation

Domain Specific Visual Languages (DSVLs) are essential elements in Model-Driven Engineering (MDE) for representing models and metamodels. In-place model transformations provide an intuitive way to complement metamodels with behavioral specifications. Besides, they can be extended with quantitative models of time and with mechanisms that facilitate the design of real-time complex systems. In this paper we present an approach to simulate and analyze the behavior of systems described by DSVLs using observers, which are objects that can monitor both the state of the rest of the objects of the system, and the execution of the system actions. Our proposal is supported by e-Motions, a graphical framework and tool for defining timed behavioral specifications of models. We also show how this approach enables the specification and simulation of other important features of systems, such as the automatic reconfiguration of the system when the value of some of the observed properties change.

On the concurrent execution of model transformations with Linda

Nowadays there exists a wide variety of model transformation languages. However, all of them present limitations, mainly performance issues, when the complexity and size of model transformations and models grow. The problems arise due to the in-memory allocation of large models as well as the time taken by the execution engines for producing the output models. This restricts the benefits of using model transformations in different application fields of model engineering where the complexity of the transformation tasks exceeds the capabilities of sequential execution engines. In this paper we tackle these limitations by introducing concurrency for model transformations to effectively improve the execution performance. Instead of reinventing the wheel, we base our approach on Linda, a mature coordination language for parallel processes. We explore how model transformations fit into Linda and show a set of basic mechanisms to enable concurrent model transformations. Initial results of applying our approach show a great potential of using Linda to improve the execution performance with respect to existing approaches.

Model Transformation Modularization as a Many-Objective Optimization Problem

Model transformation programs are iteratively refined, restructured, and evolved due to many reasons such as fixing bugs and adapting existing transformation rules to new metamodels version. Thus, modular design is a desirable property for model transformations as it can significantly improve their evolution, comprehensibility, maintainability, reusability, and thus, their overall quality. Although language support for modularization of model transformations is emerging, model transformations are created as monolithic artifacts containing a huge number of rules. To the best of our knowledge, the problem of automatically modularizing model transformation programs was not addressed before in the current literature. These programs written in transformation languages, such as ATL, are implemented as one main module including a huge number of rules. To tackle this problem and improve the quality and maintainability of model transformation programs, we propose an automated search-based approach to modularize model transformations based on higher-order transformations. Their application and execution is guided by our search framework which combines an in-place transformation engine and a search-based algorithm framework. We demonstrate the feasibility of our approach by using ATL as concrete transformation language and NSGA-III as search algorithm to find a trade-off between different well-known conflicting design metrics for the fitness functions to evaluate the generated modularized solutions. To validate our approach, we apply it to a comprehensive dataset of model transformations. As the study shows, ATL transformations can be modularized automatically, efficiently, and effectively by our approach. We found that, on average, the majority of recommended modules, for all the ATL programs, by NSGA-III are considered correct with more than 84 percent of precision and 86 percent of recall when compared to manual solutions provided by active developers. The statistical analysis of our experiments over several runs shows that NSGA-III performed significantly better than multi-objective algorithms and random search. We were not able to compare with existing model transformations modularization approaches since our study is the first to address this problem. The software developers considered in our experiments confirm the relevance of the recommended modularization solutions for several maintenance activities based on different scenarios and interviews.

Search-Based Model Transformations with MOMoT

Many scenarios require flexible model transformations as their execution should of course produce models with the best possible quality. At the same time, transformation problems often span a very large search space with respect to possible transformation results. Thus, guidance for transformation executions to find good solutions without enumerating the complete search space is a must. This paper presents MOMoT, a tool combining the power of model transformation engines and meta-heuristics search algorithms. This allows to develop model transformation rules as known from existing approaches, but for guiding their execution, the transformation engineers only have to specify transformation goals, and then the search algorithms take care of orchestrating the set of transformation rules to find models best fulfilling the stated, potentially conflicting transformation goals. For this, MOMoT allows to use a variety of different search algorithms. MOMoT is available as an open-source Eclipse plug-in providing a non-intrusive integration of the Henshin graph transformation framework and the MOEA search algorithm framework.