Gergely Mezei

A Systematic Approach to Metamodeling Environments and Model Transformation Systems in VMTS

Highly configurable metamodeling environments and graph transformation techniques have been applied successfully in software system modeling and other areas. In this paper a uniform treatment of these two methods is illustrated by a tool called Visual Modeling and Transformation System. The concepts of an n-layer metamodeling environment is outlined with the related topological and attribute issues. Built on metamodeling techniques two alternatives for model transformation are elaborated, namely, the traversal and the graph-rewriting approaches. In our implementation all of the aforementioned mechanisms use metamodel as a common formalism, which can be considered as a uniform basis for storing, creating and transforming visual languages. The feasibility of the approach is illustrated by a transformation which generates C/C++ code from UML statecharts.

Explicit transformation modeling

Despite the pivotal significance of transformations for model-driven approaches, there have not been any attempts to explicitly model transformation languages yet. This paper presents a novel approach for the specification of transformations by modeling model transformation languages as domain-specific languages. For each pair of domain, the metamodel of the rules are (quasi-)automatically generated to create a language tailored to the transformation. Moreover, this method is very efficient when the transformation domains are the transformation rules themselves, which facilitates the design of higher-order transformations.

Manual and automated performance optimization of model transformation systems

Model-based development is one of the most promising solutions for several problems of industrial software engineering. Graph transformation is a proven method for processing domain-specific models. However, in order to be used by domain experts without graph transformation experts, it must be fast even if not tweaked for speed manually based on knowledge available only to the implementers of the transformation system. In this paper, we compare the performance of such manual optimizations with a solution using automated optimization based on sharing of matches between overlapping left-hand-sides of sequentially independent rules. This yields a 11% improvement in our scenario, although our prototypical implementation only exploits overlapping between, at most, two rules, and the analyzed benchmark does not contain many cases where the optimization is applicable.

Metamodel-Based Model Transformation with Aspect-Oriented Constraints

Model transformation means converting an input model available at the beginning of the transformation process to an output model. A widely used approach to model transformation uses graph rewriting as the underlying transformation technique. In case of diagrammatic languages, such as the Unified Modeling Language (UML), the exclusive topological matching is found to be not enough. To define precisely the transformation steps beyond the topology of the visual models, additional constraints must be specified which ensures the correctness of the attributes, or other properties to be enforced. Dealing with OCL constraints provides a solution for these unsolved issues, because topological and attribute transformation methods cannot perform and express the problems which can be addressed by constraint validation. The use of OCL as a constraint and query language in modeling is essential. We have shown that it can be applied to model transformations as well. Often, the same constraint is repetitiously applied in many different places in a transformation. It would be beneficial to describe a common constraint in a modular manner, and to designate the places where it is to be applied. This paper presents the problem of crosscutting constraints in transformation rules, and provides an aspect-oriented solution for it. Our approach makes it possible to define constraints separately from the transformation steps, and facilitates specifying their propagation assignment to graph transformation rules. To illustrate the conceptual results, a case study is also provided, which introduces (i) how our approach generates user interface handler source code for mobile platform from a resource model and a statechart diagram, and (ii) how it validates specific properties during the transformation steps using aspect-oriented constraints.

Systematic Transformation Development

Despite the pivotal significance of transformations for model-driven approaches, there have not been any attempts to explicitly model transformation languages yet although a number of benefits are to be gained. First, transformation developers may change the design of their transformation languages by modeling, rather than programming. Second, they may use environments to create transformations that are customized with respect to the input and output languages involved. In this paper, we use a running example to identify, discuss, and demonstrate some of the above advantages. In particular, we explore and suggest ways to systematically support developers in creating transformation languages by means of semi-automated metamodeling.

Parallel graph transformations on multicore systems

Graph transformations are frequently used for describing and manipulating models in model driven software development. There are several frameworks and solutions for graph transformations but in case of large, industrial-sized models, performance still remains a key issue. We are working on a transformation algorithm that can efficiently use the computational capabilities of the multicore processor architectures. By applying the transformations in parallel, our aim is to create a method useful in research and industrial projects as well. The introduced algorithm is not only a theoretical result; we have implemented and applied it on real-world industrial-sized models. The paper elaborates the test results and compares the performance of the parallel and the sequential execution. The results of the measurements are analyzed as well as future research directions are given.

Control Flow Support in Metamodel-Based Model Transformation Frameworks

This paper presents the visual control flow support of Visual Modeling and Transformation System (VMTS), which facilitates composing complex model transformations out of simple transformation steps and executing them. The VMTS control flow language (VCFL) uses stereotyped activity diagrams to specify control flow structures and OCL constraints to choose between different control flow branches. In general, a control structure language needs are the sequence, the conditional branch, hierarchism, parallel executions and the iteration. VCFL has all these control structures in a deterministic version

An optimizing OCL Compiler for Metamodeling and Model Transformation Environments

Constraint specification and validation lie at the heart of modeling and model transformation. The Object Constraint Language (OCL) is a wide-spread formalism to express constraints in modeling environments. There are several interpreters and compilers that handle OCL constraints in modeling, but these tools do not support constraint optimization, therefore, the model validation can be slow. This paper presents algorithms to optimize OCL compilers to reduce the number of database queries during the validation process by eliminating the unnecessary traversing steps and caching the database queries. Proofs are also given to show that the optimized and the unoptimized code are functionally equivalent. The optimized compiler has been integrated into the Visual Modeling and Transformation System tool and applied to constraints appearing in both metamodels and graph rewriting-based model transformation rules.

Automatic NoSQL Schema Development: A Case Study

Cloud service providers offer a huge variety of schema-less NoSQL data storage solutions. The flexibility of these data stores offer greater freedom in structuring the data than relational databases. However, it would be desirable to make use of the strong mathematical background of relational data structures. In this paper, we introduce an automatic NoSQL schema optimization that uses a normalized data schema as starting point. We analyze the predefined set of queries, and compile the schema that can serve the queries with minimal cost at a certain query load. The introduced process is performed on a conceptual model of the database, and the queries are defined in Object Constraint Language to simplify the analysis. The optimization algorithm is introduced through a case study.

Incremental Model Synchronization by Bi-Directional Model Transformations

Model transformation is a focused area in model-driven software development. With the help of model transformations we can generate source code, other models and documentation from the source models. During the development, a recurring problem is that the source and target artifacts coexist and they evolve independently. This means that after the transformation the target artifacts can be changed by the developer. The problem in this case is that the target artifact will not be consistent with the source model. One option to maintain consistency is by synchronizing our artifacts with model transformation. With the help of synchronization, the developer can work on each artifact, because they are consistent. However the synchronization can be quite complex and cannot be applied in many cases. Usually the inverse transformation does not exist, or it cannot be determined uniquely. This paper presents how we can track the modifications of the transformation, and how we can use this information in the synchronization process.