Marcos Didonet Del Fabro

Towards the efficient development of model transformations using model weaving and matching transformations

Model transformations can be used in many different application scenarios, for instance, to provide interoperability between models of different size and complexity. As a consequence, they are becoming more and more complex. However, model transformations are typically developed manually. Several code patterns are implemented repetitively, thus increasing the probability of programming errors and reducing code reusability. There is not yet a complete solution that automates the development of model transformations. In this paper, we present a novel approach that uses matching transformations and weaving models to semi-automate the development of transformations. Weaving models are models that contain different kinds of relationships between model elements. These relationships capture different transformation patterns. Matching transformations are a special kind of transformations that implement methods that create weaving models. We present a practical solution that enables the creation and the customization of different creation methods in an efficient way. We combine different methods, and present a metamodel-based method that exploits metamodel data to automatically produce weaving models. The weaving models are derived into model integration transformations. To validate our approach, we present an experiment using metamodels with distinct size and complexity, which show the feasibility and scalability of our solution.

A canonical scheme for model composition

There is little agreement on terminology in model composition, and even less on key characteristics of a model composition solution. We present three composition frameworks: the Atlas Model Weaver, the Epsilon Merging Language, and the Glue Generator Tool, and from them derive a core set of common definitions. We use this to outline the key requirements of a model composition solution, in terms of language and tool support.

Semi-automatic model integration using matching transformations and weaving models

Model transformations are at the heart of model driven engineering (MDE) and can be used in many different application scenarios. For instance, model transformations are used to integrate very large models. As a consequence, they are becoming more and more complex. However, these transformations are still developed manually. Several code patterns are implemented repetitively, increasing the probability of programming errors and reducing code reusability. There is not yet a complete solution that automates the development of model transformations. In this paper we propose a novel approach that uses matching transformations and weaving models to semi-automate the development of transformations. Matching transformations are a special kind of transformations that implement heuristics and algorithms to create weaving models. Weaving models are models that capture different kinds of relationships between models. Our solution enables to rapidly implement and to customize these heuristics. We combine different heuristics, and we propose a new metamodel-based heuristic that exploits metamodel data to automatically produce weaving models. The weaving models are derived into model integration transformations.

Model-Driven tool interoperability: an application in bug tracking

Interoperability of heterogeneous data sources has been extensively studied in data integration applications However, the increasing number of tools that produce data with very different formats, such as bug tracking, version control, etc., produces many different kinds of semantic heterogeneities These semantic heterogeneities can be expressed as mappings between the tools metadata which describe the data manipulated by the tools However, the semantics of complex mappings (n:1, 1:m and n:m relationships) is hard to support These mappings are usually directly coded in executable transformations using arithmetic expressions And there is no mechanism to create and reuse complex mappings In this paper we propose a novel approach to capture different kinds of complex mappings using correspondence models The main advantage is to use high level specifications for the correspondence models that enable representing different kinds of mappings The correspondence models may be used to automatically produce executable transformations To validate our approach, we provide an experimentation with a real world scenario using bug tracking tools.

A Survey on SDN Programming Languages: Toward a Taxonomy

Network devices have always been considered as configurable black boxes until the emergence of software-defined networking (SDN). SDN enables the networks to be programmed according to the user requirements; furthermore, it allows the network to be easily modified to suit transient demands. However, how do we program the network? SDN-compliant switches offer a low-level interface that makes programming error-prone. The controllers provide application programming interfaces, but still low-level, limited, and inflexible. High-level languages have the potential to be a better alternative to program the network. There exist several SDN programming languages implementing different sets of functionalities, and focusing on solving various issues. In face of all this diversity, no published paper outlines a pragmatic view allowing to compare the SDN languages. This paper presents a systematic survey of up-to-date OpenFlow-based SDN programming languages. Our approach relies on a taxonomy comprising all prominent features found in those languages. A detailed review of the existing works is carried out investigating the foundational parts of the languages with their contributions. Examples are discussed to illustrate the fundamental abstractions. Last, all gathered information is summarized, discussing the main ongoing research efforts and challenges. Future abstractions and features to be incorporated into the next generations of SDN programming languages are also considered.

Achieving Rule Interoperability Using Chains of Model Transformations

Model Driven Engineering (MDE) is rapidly maturing and is being deployed in several situations. We report here on an experiment conducted in the context of ILOG, a leader in the development of Business Rule Management Systems (BRMS). BRMSs aim at enabling business users automating their business policies. There is a growing number of BRMS supporting different languages, but also a lack of tools for bridging them. In this paper, we present an approach based on MDE techniques for bridging rule languages; the solution has been fully implemented and tested on different BRMS. The success of the experiment has led to the development and chaining of a significant number of model transformations --- no less than twenty. At the same time, this deployment has shown new problems arising from the management of a high number of artifacts. We discuss the positive assessment of MDE in this field, but also the need to address the complexity generated.

Model search: formalizing and automating constraint solving in MDE platforms

Model Driven Engineering (MDE) and constraint programming (CP) have been widely used and combined in different applications. However, existing results are either ad-hoc, not fully integrated or manually executed. In this article, we present a formalization and an approach for automating constraint-based solving in a MDE platform. Our approach generalizes existing work by combining known MDE concepts with CP techniques into a single operation called model search. We present the theoretical basis for model search, as well as an automated process that details the involved operations. We validate our approach by comparing two implemented solutions (one based on Alloy/SAT, the other on OPL/CP), and by executing them over an academic use-case.

Using weaving models to automate model-driven web engineering proposals

Model-Driven Web Engineering is a new approach for Web Information Systems development whose basic assumption is the consideration of models as first-class entities. Basically, each step of the process consists of a model transformation that generates one or more target models from one or more source models. However, the special nature of the behavioural models implied at the early stages of a Model-Driven Web Engineering process complicates the specification of a model transformation that works for any input model. In such situations, it is not feasible to automate the whole development process since some design decisions have to be considered before executing each transformation. This work shows how we solve this problem in SOD-M, a model-driven approach for the development of Service-Oriented Web applications. The technique proposed is based on the use of weaving models as annotation models and it can be easily generalised to other domains and contexts.

On the necessity of model checking NoSQL database schemas when building SaaS applications

The design of the NoSQL schema has a direct impact on the scalability of web applications. Especially for developers with little experience in NoSQL stores, the risks inherent in poor schema design can be incalculable. Worse yet, the issues will only manifest once the application has been deployed, and the growing user base causes highly concurrent writes. In this paper, we present a model checking approach to reveal scalability bottlenecks in NoSQL schemas. Our approach draws on formal methods from tree automata theory to perform a conservative static analysis on both the schema and the expected write-behavior of users. We demonstrate the impact of schema-inherent bottlenecks for a popular NoSQL store, and show how concurrent writes can ultimately lead to a considerable share of failed transactions.

From software defined network to network defined for software

Nowadays, Big Data applications exchange huge amounts of data, highly demanding network guarantees for bandwidth and low latency. However, network equipments did not provide a standard interface to control dynamically the resources. Software-Defined Network (SDN) has emerged to support network programmability, but it provides a programming model devoted to network operators. This paper presents the Network Overlay Framework (NoF), which enables networks to be defined based on application requirements. NoF provides a programming language which allows the application specialists to program the network. A compiler translates NoF programs into instructions according to the underlying network technology. To prove the effectiveness of NoF, programs were implemented to express bandwidth guarantees on Hadoop traffic and also to route Hadoop flows through overlay networks.