Massimo Tisi

Neo4EMF, A Scalable Persistence Layer for EMF Models

Several industrial contexts require software engineering methods and tools able to handle large-size artifacts. The central idea of abstraction makes model-driven engineering (MDE) a promising approach in such contexts, but current tools do not scale to very large models (VLMs): already the task of storing and accessing VLMs from a persisting support is currently inefficient. In this paper we propose a scalable persistence layer for the de-facto standard MDE framework EMF. The layer exploits the efficiency of graph databases in storing and accessing graph structures, as EMF models are. A preliminary experimentation shows that typical queries in reverse-engineering EMF models have good performance on such persistence layer, compared to file-based backends.

Feature-based classification of bidirectional transformation approaches

Bidirectional model transformation is a key technology in model-driven engineering (MDE), when two models that can change over time have to be kept constantly consistent with each other. While several model transformation tools include at least a partial support to bidirectionality, it is not clear how these bidirectional capabilities relate to each other and to similar classical problems in computer science, from the view update problem in databases to bidirectional graph transformations. This paper tries to clarify and visualize the space of design choices for bidirectional transformations from an MDE point of view, in the form of a feature model. The selected list of existing approaches are characterized by mapping them to the feature model. Then, the feature model is used to highlight some unexplored research lines in bidirectional transformations.

Map-Based Transparent Persistence for Very Large Models

The progressive industrial adoption of Model-Driven Engineering MDE is fostering the development of large tool ecosystems like the Eclipse Modeling project. These tools are built on top of a set of base technologies that have been primarily designed for small-scale scenarios, where models are manually developed. In particular, efficient runtime manipulation for large-scale models is an under-studied problem and this is hampering the application of MDE to several industrial scenarios. n nIn this paper we introduce and evaluate a map-based persistence model for MDE tools. We use this model to build a transparent persistence layer for modeling tools, on top of a map-based database engine. The layer can be plugged into the Eclipse Modeling Framework, lowering execution times and memory consumption levels of other existing approaches. Empirical tests are performed based on a typical industrial scenario, model-driven reverse engineering, where very large software models originate from the analysis of massive code bases. The layer is freely distributed and can be immediately used for enhancing the scalability of any existing Eclipse Modeling tool.

EMF-REST: generation of RESTful APIs from models

In the last years, there has been an increasing interest for Model-Driven Engineering (MDE) solutions in the Web. Web-based modeling solutions can leverage on better support for distributed management (i.e., the Cloud) and collaboration. However, current modeling environments and frameworks are usually restricted to desktop-based scenarios and therefore their capabilities to move to the Web are still very limited. In this paper we present an approach to generate Web APIs out of models, thus paving the way for managing models and collaborating on them online. The approach, called EMF-REST, takes Eclipse Modeling Framework (EMF) data models as input and generates Web APIs following the REST principles and relying on well-known libraries and standards, thus facilitating its comprehension and maintainability. Also, EMF-REST integrates model and Web-specific features to provide model validation and security capabilities, respectively, to the generated API.

NeoEMF: A Multi-database Model Persistence Framework for Very Large Models

The growing use of Model Driven Engineering (MDE) techniques in nindustry has emphasized scalability of existing model persistence solutions as na major issue. Specifically, there is a need to store, query, and transform very nlarge models in an efficient way. Several persistence solutions based on relational nand NoSQL databases have been proposed to achieve scalability. However, existing nsolutions often rely on a single data store, which suits a specific modeling nactivity, but may not be optimized for other use cases. In this article we present nNEOEMF, a multi-database model persistence framework able to store very large nmodels in key-value stores, graph databases, and wide column databases. We introduce nNEOEMF core features, and present the different data stores and their napplications. NEOEMF is open source and available online.

A Deductive Approach for Fault Localization in ATL Model Transformations

In model-driven engineering, correct model transformation is essential for reliably producing the artifacts that drive software development. While the correctness of a model transformation can be specified and checked via contracts, debugging unverified contracts imposes a heavy cognitive load on transformation developers. To improve this situation, we present an automatic fault localization approach, based on natural deduction, for the ATL model transformation language. We start by designing sound natural deduction rules for the ATL language. Then, we propose an automated proof strategy that applies the designed deduction rules on the postconditions of the model transformation to generate sub-goals: successfully proving the sub-goals implies the satisfaction of the postconditions. When a sub-goal is not verified, we present the user with sliced ATL model transformation and predicates deduced from the postcondition as debugging clues. We provide an automated tool that implements this process. We evaluate its practical applicability using mutation analysis, and identify its limitations.

Reactive model transformation with ATL

Model-driven applications may maintain large networks of structured data models and transformations among them. The development of such applications is complicated by the need to reflect on the whole network any runtime update performed on models or transformation logic. If not carefully designed, the execution of such updates may be computationally expensive. In this paper we propose a reactive paradigm for programming model transformations, and we implement a reactive model-transformation engine. We argue that this paradigm facilitates the development of autonomous model-driven systems that react to update and request events from the host application by identifying and performing only the needed computation. We implement such approach by providing a reactive engine for the ATL transformation language. We evaluate the usage scenarios that this paradigm supports and we experimentally measure its ability to reduce computation time in transformation-based applications. We propose a reactive paradigm for programming model transformations.We implement a reactive model-transformation language by providing a reactive engine for the ATL transformation language.We evaluate the usage scenarios that this paradigm supports.We experimentally measure its ability to reduce computation time in transformation-based applications.

fUML as an Assembly Language for Model Transformation

Within a given modeling platform, modeling tools, such as model editors and transformation engines, interoperate efficiently. They are generally written in the same general-purpose language, and use a single modeling framework (i.e., an API to access models). However, interoperability between tools from different modeling platforms is much more problematic.

Enabling OCL and fUML Integration byźTransformation

Until the recent adoption of fUML, UML has lacked standard execution semantics. However, parts of UML models have always been executable: OCL expressions. They may notably be used to express contracts i.e., invariants, pre- and post-conditions, to define side-effect free operations, and to specify how to compute derived features. Nonetheless, although fUML is partly inspired by OCL notably for primitive behaviors, its specification does not consider interoperability with OCL expressions. Moreover, the semantics of OCL is specified independently of fUML, and their implementations are separate execution engines, hampering all global activities e.g., analysis, optimization, debugging. This paper explores a possible integration approach of OCL and fUML: by transforming i.e., compiling OCL expressions into fUML activities we obtain a unified executable model. With this approach, operations specified in OCL can be called, and getters can be generated for derived features. Preconditions resp. postconditions can be automatically executed before resp. after the execution of their contextual operations. A precise semantics for invariant evaluation can be specified in fUML. Thanks to this work, OCL may also be seen as a functional counterpart to Alf.

Injecting Execution Traces into a Model-Driven Framework for Program Analysis

Model-Driven Engineering (MDE) has been successfully used in static program analysis. Frameworks like MoDisco inject the program structure into a model, available for further processing by query and transformation tools, e.g., for program understanding, reverse-engineering, modernization. In this paper we present our first steps towards extending MoDisco with capabilities for dynamic program analysis.