Theory and Practice of Model Transformations

Bidirectional transformations (bx) constitute an emerging mechanism for maintaining the consistency of interdependent sources of information in software systems. Researchers from many different communities have recently investigated the use of bxto solve a large variety of problems, including relational view update, schema evolution, data exchange, database migration, and model co-evolution, just to name a few. Each community leveraged and extended different theoretical frameworks and tailored their use for specific sub-problems. Unfortunately, the question of how these approaches actually relate to and differ from each other remains unanswered. This question should be addressed to reduce replicated efforts among and even within communities, enabling more effective collaboration and fostering cross-fertilization. To effectively move forward, a systematization of these many theories and systems is now required. This paper constitutes a first, humble yet concrete step towards a unified theoretical framework for a tractable and relevant subset of bx approaches and tools. It identifies, characterizes, and compares tools that allow the incremental definition of bidirectional mappings between software artifacts. Identifying similarities between such tools yields the possibility of developing practical tools with wide-ranging applicability; identifying differences allows for potential new research directions, applying the strengths of one tool to another whose strengths lie elsewhere.

Testers often use partial knowledge to build test models. This knowledge comes from sources such as requirements, known faults, existing inputs, and execution traces. In Model-Driven Engineering, test inputs are models executed by model transformations. Modelers build them using partial knowledge while meticulously satisfying several well-formedness rules imposed by the modelling language. This manual process is tedious and language constraints can force users to create complex models even for representing simple knowledge. In this paper, we want to simplify the development of test models by presenting an integrated methodology and semi-automated tool that allow users to build only small partial test models directly representing their testing intent. We argue that partial models are more readable and maintainable and can be automatically completed to full input models while considering language constraints. We validate this approach by evaluating the size and fault-detecting effectiveness of partial models compared to traditionally-built test models. We show that they can detect the same bugs/faults with a greatly reduced development effort.

Testing model transformations poses several challenges, among them the automatic generation of appropriate input test models and the specification of oracle functions. Most approaches to the generation of input models ensure a certain level of source meta-model coverage, whereas the oracle functions are frequently defined using query or graph languages. Both tasks are usually performed independently regardless their common purpose, and sometimes there is a gap between the properties exhibited by the generated input models and those demanded to the transformations (as given by the oracles).

Correctness of model transformations is a prerequisite for generating correct implementations from models. Given refining model transformations that preserve desirable properties, models can be transformed into correct-by-construction implementations. However, proving that model transformations preserve properties is far from trivial. Therefore, we aim for simple correctness proofs by designing model transformations that are as fine-grained as possible. Furthermore, we advocate the reuse of model transformations to reduce the number of proofs. For a simple domain-specific language, SLCO, we define a formal framework to reason about the correctness, reusability, and composition of the fine-grained model transformations used to transform a given model to three target languages: NQC, Promela and POOSL. The correctness criterion induces that the original model and the resulting model obtained after a proper sequence of transformations have the same observable behavior.

Lenses are one of the most popular approaches to define bidirectional transformations between data models. However, writing a lens transformation typically implies describing the concrete steps that convert values in a source schema to values in a target schema. In contrast, many XML-based languages allow writing structure-shy programs that manipulate only specific parts of XML documents without having to specify the behavior for the remaining structure. In this paper, we propose a structure-shy bidirectional two-level transformation language for XML Schemas, that describes generic type-level transformations over schema representations coupled with value-level bidirectional lenses for document migration. When applying these two-level programs to particular schemas, we employ an existing algebraic rewrite system to optimize the automatically-generated lens transformations, and compile them into Haskell bidirectional executables. We discuss particular examples involving the generic evolution of recursive XML Schemas, and compare their performance gains over non-optimized definitions.

Spreadsheets play an important role in software organizations. Indeed, in large software organizations, spreadsheets are not only used to define sheets containing data and formulas, but also to collect information from different systems, to adapt data coming from one system to the format required by another, to perform operations to enrich or simplify data, etc. In fact, over time many spreadsheets turn out to be used for storing and processing increasing amounts of data and supporting increasing numbers of users. Unfortunately, spreadsheet systems provide poor support for modularity, abstraction, and transformation, thus, making the maintenance, update and evolution of spreadsheets a very complex and error-prone task.

File carvers are forensic software tools used to recover data from storage devices in order to find evidence. Every legal case requires different trade-offs between precision and runtime performance. The resulting required changes to the software tools are performed manually and under the strictest deadlines.

In this paper we present a model-driven approach to file carver development that enables these trade-offs to be automated. By transforming high-level file format specifications into approximations that are more permissive, forensic investigators can trade precision for performance, without having to change source.

Our study shows that performance gains up to a factor of three can be achieved, at the expense of up to 8% in precision and 5% in recall.

Business processes are recognized by organizations as one of the most important intangible assets, since they let organizations improve their competitiveness. Business processes are supported by enterprise information systems, which can evolve over time and embed particular business rules that are not present anywhere else. Thus, there are many organizations with inaccurate business processes, which prevent the modernization of enterprise information systems in line with the business processes that they support. Therefore, business process mining techniques are often used to retrieve reliable business processes from the event logs recorded during the execution of enterprise systems. Unfortunately, such event logs are represented with purpose-specific notations such as Mining XML and still don’t apply the recent software modernization standard: ISO 19506 (KDM, Knowledge Discovery Metamodel). This paper presents an exogenous model transformation between these two notations. The main advantage is that process mining techniques can be effectively reused within software modernization projects according to the standard notation. This paper is particularly focused on the empirical evaluation of this transformation by simulating different kinds of business process models and several event logs with different sizes and configurations from such models. After analyzing all the model transformation executions, the study demonstrates that the transformation can provide suitable KDM models in a linear time in accordance with the size of the input models.

Model transformations are commonly used to transform models suited for one purpose (e.g., describing a solution in a particular domain) to models suited for a related but different purpose (e.g., simulation or execution). The disadvantage of a transformational approach, however, is that feedback acquired from analyzing transformed models is not reported on the level of the problem domain but on the level of the transformed model. Expressing the feedback on the level of the problem domain requires improving traceability in model transformations.

We propose to visualize traceability links in (chains of) model transformations, thus making traceability amenable for analysis.

Although there are powerful model transformation languages (MTLs) like ATL, model-to-model transformations still are often implemented in general-purpose languages (GPLs) like Java, especially in EMF-based projects. Developers might hesitate to learn another language, use new tools, or they feel limited by the specific but less versatile constructs an MTL provides. However, model transformation code written in a GPL is less readable, contains redundancies or verbose expressions, and there are fewer possibilities for formal reasoning. Our approach combines some benefits of MTLs with GPL programming. We use the GPL Scala to realize MTLs similar to ATL as internal domain-specific languages. The benefits are seamless integration with EMF and state-of-the-art tool support as well as the possibility to extend MTLs and to mix MTL and GPL code. In contrast to similar approaches with dynamically typed languages like Ruby, Scala allows for static type-safety without adding syntactic clutter.

Many model transformation languages of different nature have been proposed during the last years, each one of them suitable for a certain kind of transformation task. However, a complex transformation problem may not fall into a single transformation category, making the solution written in the chosen transformation language suboptimal, as some concerns cannot be handled naturally.

To tackle this issue, we propose to define a model transformation tool as a family of model transformation languages. Each member of the family is a simple language intended to deal with a particular kind of transformation task. In this paper we discuss the different issues involved, such as design decisions, interoperability among languages, and composability. We illustrate the paper with a transformation from UML and OCL to Java, in which languages for pattern matching, mapping, attribution and target-oriented transformations are used. Finally, the approach is validated with a proof-of-concept implementation.

Model-to-model transformations are often employed to establish translational semantics of Domain-Specific Languages (DSLs) by mapping high-level models into more concrete ones. Such semantics are also executable when there exists a target platform able to execute the target models. Conceiving a transformation that targets a low-level language still remains arduous due to the large semantic gap between the DSL and the corresponding target language. In this respect, depending on the domain of the DSL, this task can be made easier by reusing an existing platform and bytecode language for that domain, as for instance the EMF Transformation Virtual Machine (EMFTVM) for the domain of model transformation. This paper defines executable semantics for EMFMigrate, a model transformation language specifically designed for managing the coupled evolution in model-driven development. To this end, the approach considers EMFTVM as the runtime engine targeted by the proposed semantic mappings.

As practical tools for disciplined multi-level modeling have begun to emerge, the problem of supporting simple and efficient transformations to-and-from multi-level model content has started to assume growing importance. The problem is not only to support efficient transformations between multi-level models, but also between multi-level and traditional two-level model content represented in traditional modeling infrastructures such as the UML and programming languages. This is not only important to facilitate interoperability between multi-level modeling tools and traditional tools, but also to extend the benefits of multi-level modeling to transformations. Multi-level model content can already be accessed by traditional transformation languages such as ATL and QVT, but in a way that is blind to the ontological classification information they contain. In this paper we present an approach for making rule-based transformation languages “multi-level aware” so that the semantics of ontological instantiation can be exploited when writing transformations.

In this paper, we propose a new model-sensitive search plan generation algorithm to speed up the process of graph pattern matching. This dynamic programming based algorithm, which is able to handle general n-ary constraints in an integrated manner, collects statistical data from the underlying EMF model, and uses this information for optimization purposes. Additionally, runtime performance measurements have been carried out to quantitatively evaluate the effects of the search plan generation algorithm on the pattern matching engine.

Professional development of software dealing with structured models requires more systematic approach and semantic foundations than standard practice in general-purpose programming languages affords. One remedy is to move to domain-specific environments. Here, instead, we present a tool for the implementation of pattern matching as fundamental means of automated data extraction from complex models in a general-purpose programming language. The interface is simple but, thanks to elaborate and rigorous design, is also light-weight, portable, non-invasive, type-safe, modular and extensible. It is compatible with object-oriented data abstraction and has full support for nondeterminism by backtracking. The tool comes as a library consisting of two levels: elementary pattern constructs (generic, highly reusable) and pattern bindings for particular data models (specific, fairly reusable, user-definable). Applications use the library code in a small number of idiomatic ways, making pattern-matching code declarative in style (yet retaining richer host-language semantics), easily writable, readable and maintainable. Library and idiom together form a tightly embedded domain-specific language; no extension of the host language is required. The current implementation is in Java, but assumes only standard object-oriented features, and can hence be ported to other mainstream languages.

In model-driven software engineering, model transformations play a key role since they are used to automatically generate and update models from existing information. However, defining concrete transformation rules is a complex task because the designer has to cope with incompleteness, ambiguity, bidirectionality, and rule dependencies. In this paper, we propose a vision of Constraint-driven Modeling in which transformation is used to automate the generation of model constraints instead of generating entire models. Three illustrative scenarios show how this approach addresses common transformation issues and how designers can benefit from using model constraints and guidance. We developed a proof-of-concept implementation that covers an important part of this vision and thus demonstrates its feasibility. The implementation also suggests that a constraint-driven transformation is efficient and scales even with increasing numbers of involved models.

This paper examines the effect of class diagram transformation on state machines, a subject which has not been properly investigated. It is demonstrated that structural relations between states can be interpreted as a logical relation between the corresponding formulas and the preservation of the latter corresponds to the preservation of state machine structure. A sufficient condition, based on the form of the underlying transformation and proofs, is provided which guarantees that class structure transformation preserves the structure of state machines. The goal is to automatically transform state-invariants and to identify those state machines which need to be manually transformed after class model redesign.

Model transformations are mostly developed from scratch. For increasing development productivity as well as quality of model transformations, reuse mechanisms are indispensable. Although numerous mechanisms have been proposed, no systematic comparison exists making it unclear, which reuse mechanisms may be best employed in a certain situation. Therefore, this paper provides an in-depth comparison of reuse mechanisms in rule-based model-to-model transformation languages and categorizes them along their intended scope of application. For this, a systematic comparison framework for reuse mechanisms is proposed to highlight commonalities as well as differences. Finally, current barriers to model transformation reuse are outlined.