Tassilo Horn

Graph and model transformation tools for model migration

We describe the results of the Transformation Tool Contest 2010 workshop, in which nine graph and model transformation tools were compared for specifying model migration. The model migration problem—migration of UML activity diagrams from version 1.4 to version 2.2—is non-trivial and practically relevant. The solutions have been compared with respect to several criteria: correctness, conciseness, understandability, appropriateness, maturity and support for extensions to the core migration task. We describe in detail the comparison method, and discuss the strengths and weaknesses of the solutions with a special focus on the differences between graph and model transformation for model migration. The comparison results demonstrate tool and language features that strongly impact the efficacy of solutions, such as support for retyping of model elements. The results are used to motivate an agenda for future model migration research (including suggestions for areas in which the tools need to be further improved).

The GReTL transformation language

This paper introduces the graph-based transformation language GReTL. GReTL is an operational transformation language whose operations are either specified in plain Java using the GReTL API or in a simple domain-specific language. GReTL follows the conception of incrementally constructing the target metamodel together with the target graph. When creating a new metamodel element, a set-based semantic expression is specified that describes the set of instances that have to be created in the target graph. This expression is described by a query on the source graph. After a description of the foundations of GReTL, its most important elements are introduced along with a simple example.

A survey and comparison of transformation tools based on the transformation tool contest

Model transformation is one of the key tasks in model-driven engineering and relies on the efficient matching and modification of graph-based data structures; its sibling graph rewriting has been used to successfully model problems in a variety of domains. Over the last years, a wide range of graph and model transformation tools have been developed - all of them with their own particular strengths and typical application domains. In this paper, we give a survey and a comparison of the model and graph transformation tools that participated at the Transformation Tool Contest 2011. The reader gains an overview of the field and its tools, based on the illustrative solutions submitted to a Hello World task, and a comparison alongside a detailed taxonomy. The article is of interest to researchers in the field of model and graph transformation, as well as to software engineers with a transformation task at hand who have to choose a tool fitting to their needs. All solutions referenced in this article provide a SHARE demo. It supported the peer-review process for the contest, and now allows the reader to test the tools online.

Model-driven software migration into service-oriented architectures

This paper proposes model-driven techniques to extend IBM’s SOMA method towards migrating legacy systems into Service-Oriented Architectures (SOA). The proposal explores how graph-based querying and transformation techniques enable the integration of legacy assets into a new SOA and how these techniques can be integrated into the overall migration process. The presented approach is applied to the identification and migration of services in an open source Java software system.

The SOAMIG Process Model in Industrial Applications

The SOAMIG Project aims at a general migration process model with an emphasis on transformation-based conversion. The SOAMIG Process Model is divided into several phases and disciplines, which describe and organize general migration activities. The process is applied in two industrial software migration projects addressing architecture and code migration.

Program Understanding: A Reengineering Case for the Transformation Tool Contest

In Software Reengineering, one of the central artifacts is the source code of the legacy system in question. In fact, in most cases it is the only definitive artifact, because over the time the code has diverged from the original architecture and design documents. The first task of any reengineering project is to gather an understanding of the systems architecture. Therefore, a common approach is to use parsers to translate the source code into a model conforming to the abstract syntax of the programming language the system is implemented in which can then be subject to querying. Despite querying, transformations can be used to generate more abstract views on the systems architecture. This transformation case deals with the creation of a state machine model out of a Java syntax graph. It is derived from a task that originates from a real reengineering project.

Similarity-driven software reuse

The case-based approach to software reuse in the ReDSeeDS project is based on similarity of requirement specifications. This paper describes the approach for similarity computation and its application in the ReDSeeDS engine. Similarity is determined by a combined approach which uses methods from information retrieval as well as graph similarity measures.

Model Querying with FunnyQT

FunnyQT is a new model querying and transformation approach. It is designed as an extensible API in the functional, JVM-based Lisp dialect Clojure. FunnyQT targets the modeling frameworks JGraLab and EMF, and it is extensible to other frameworks as well. Its querying parts are already stable while its transformation parts are still in early stages of development, so this paper focuses on the former.

The TTC 2013 Flowgraphs Case.

This case for the Transformation Tool Contest 2013 is about evaluating the scope and usability of transformation languages and tools for a set of four tasks requiring very different capabilities. One task deals with typical model-to-model transformation problem, theres a model-to-text problem, there are two in-place transformation problems, and finally theres a task dealing with validation of models resulting from the transformations. The tasks build upon each other, but the transformation case project also provides all intermediate models, thus making it possible to skip tasks that are not suited for a particular tool, or for parallelizing the work among members of participating teams.

Graph Pattern Matching as an Embedded Clojure DSL

FunnyQT is a Clojure library supplying a comprehensive set of model querying and transformation services to the user. These are provided as APIs and embedded DSLs. This paper introduces FunnyQT’s embedded graph pattern matching DSL which allows users to define patterns using a convenient textual notation that can be applied to graphs. The result of applying a pattern to a graph is the lazy sequence of all matches of the pattern in the graph. FunnyQT’s pattern matching DSL is quite expressive. It supports positive and negative application conditions, arbitrary constraints, patterns with alternatives, nested patterns, and more. In case a pattern is defined to be evaluated eagerly instead of lazily, the search induced by the pattern is automatically parallelized on multi-core machines for improved performance.