Sabine Winetzhammer

The added value of programmed graph transformations --- a case study from software configuration management

Model-driven software engineering intends to increase the productivity of software engineers by replacing conventional programming with the development of executable models at a high level of abstraction. It is claimed that graph transformation rules contribute towards this goal since they provide a declarative, usually graphical specification of complex model transformations. Frequently, graph transformation rules are organized into even more complex model transformations with the help of control structures, resulting in full-fledged support for executable behavioral models. This paper examines the added value of programmed graph transformations with the help of a case study from software configuration management. To this end, a large model is analyzed which was developed in the MOD2-SCM project over a period of several years. The model was developed in Fujaba, which provides story diagrams for programming with graph transformations. Our analysis shows that the model exhibits a strongly procedural flavor. Graph transformation rules are heavily used, but typically consist of very small patterns. Furthermore, story diagrams provide fairly low level control structures. Altogether, these findings challenge the claim that programming with graph transformations is performed at a significantly higher level of abstraction than conventional programming.

Integrating Graph Transformations and Modal Sequence Diagrams for Specifying Structurally Dynamic Reactive Systems

Software-intensive systems, for example service robot systems in industry, often consist of multiple reactive components that interact with each other and the environment. Often, the behavior depends on structural properties and relationships among the system and environment components, and reactions of the components in turn may change this structure. Modal Sequence Diagrams (MSDs) are an intuitive and precise formalism for specifying the interaction behavior among reactive components. However, they are not sufficient for specifying structural dynamics. Graph transformation rules (GTRs) provide a powerful approach for specifying structural dynamics. We describe an approach for integrating GTRs with MSDs such that requirements and assumptions on structural changes of system resp. environment objects can be specified. We prototypically implemented this approach by integrating ModGraph with ScenarioTools. This allows us not only to specify MSDs and GTRs in Eclipse, but also to simulate the specified behavior via play-out.

Compiling graph transformation rules into a procedural language for behavioral modeling

Graph transformation rules provide an opportunity to specify model transformations in a declarative way at a high level of abstraction. So far, compilers have translated graph transformation rules into conventional programming languages such as Java, C, or C#. In contrast, we have developed a compiler which translates graph transformation rules into a procedural language for behavioral modeling (Xcore). The generated code is significantly more concise and readable than programming language code. Furthermore, the code is portable since it is completely programming language independent.

Model Refactorings for and with Graph Transformation Rules

Refactoring denotes the activity of improving the structure of software by applying a series of transformations without affecting its externally observable behavior. Refactoring has been applied extensively at the source code level. In the context of model-driven software engineering, refactoring has to be applied consistently to both structural and behavioral models. In this paper, we present tool support for model refactoring in ModGraph, a tool which employs Ecore class diagrams for structural modeling and graph transformation rules for declarative behavioral modeling. A refactoring transformation restructures the structural model — an Ecore class diagram — and propagates the changes consistently to the behavioral model — a set of graph transformation rules. Since the refactoring transformations are implemented with graph transformation rules, ModGraph supports model refactoring both for and with graph transformation rules.

Propagating model refactorings to graph transformation rules

Model-driven software engineering reduces the effort of developing software by replacing low-level programming with the construction of high-level executable models. Refactoring improves the structure of software artifacts without changing external behavior. Originally, refactoring was developed for and applied to (object-oriented) programs. In the context of model-driven software engineering, refactoring has to be applied to both structural and behavioral models. In this paper, we present tool support for model refactoring in ModGraph, a tool which employs Ecore class diagrams for structural modeling and graph transformation rules for behavioral modeling. In particular, we focus on the propagation of refactorings of the structural model into the behavioral model.

Staged Translation of Graph Transformation Rules

Graph transformation rules provide an opportunity to specify model transformations in a declarative way at a high level of abstraction. So far, compilers have translated graph transformation rules into conventional programming languages such as Java, C, or C#. In contrast, we follow a staged translation approach: We developed a compiler which translates graph transformation rules into a procedural language for behavioral modeling (Xcore). By reusing the Xcore compiler, the code may be compiled down to a conventional programming language in a second step. The generated Xcore code is significantly more concise and readable than programming language code. Furthermore, the code is portable since it is completely programming language independent.