Leif Geiger

Using Graph Transformation for Practical Model Driven Software Engineering

Model transformations are one of the core technologies needed to apply OMG’s model-driven engineering concept for the construction of real-world systems. Several formalisms are currently proposed for the specification of these model transformations. A suitable formalism is based on graph transformation systems and graph transformation rules. The chapter provides an overview about the needed concepts to apply graph transformations in the context of model driven engineering and we show the technical feasibility based on several tools and applications.

A graphical specification of model transformations with triple graph grammars

Models and model transformations are the core concepts of OMG’s MDATM approach. Within this approach, most models are derived from the MOF and have a graph-based nature. In contrast, most of the current model transformations are specified textually. To enable a graphical specification of model transformation rules, this paper proposes to use triple graph grammars as declarative specification formalism. These triple graph grammars can be specified within the FUJABA tool and we argue that these rules can be more easily specified and they become more understandable and maintainable. To show the practicability of our approach, we present how to generate Tefkat rules from triple graph grammar rules, which helps to integrate triple graph grammars with a state of a art model transformation tool and shows the expressiveness of the concept.

Graph Based Debugging with Fujaba

Abstract This work is part of the Fujaba project. The Fujaba project aims to use the Unified Modeling Language UML as a programmed graph rewriting language. This paper describes the new graph based debugging functionality that has just been added to the Fujaba environment. This new debugging functionality allows to visualize Java heap object structures as the current host graph and to execute programmed graph rewrite rules stepwise.

Statechart Modeling with Fujaba

This paper is a small case study on a simple visual language. We use the Fujaba approach to exemplify, how the different requirements of an environment for such a visual language may be addressed using Fujaba graph transformations. This covers abstract and concrete syntax, static and operational semantics, and model transformations. This case study shows, how the more sophisticated language elements of Fujaba may be exploited in modeling complex aspects of the statechart environment. In addition, we address some not graph grammar related aspects in building such an environment, e.g. the graphical user interface and multi-user support.

Tool Modeling with Fujaba

This paper is a small tutorial on tool building with Fujaba. With the help of a small case study, we exemplify how the different requirements of an environment for a visual language may be addressed using Fujaba graph transformations. This covers abstract and concrete syntax, static and operational semantics, and model transformations. This case study shows, how the more sophisticated language elements of Fujaba may be exploited in modeling complex aspects of the desired CASE tool. In addition, we address some not graph grammar related aspects in building such an environment, e.g. the graphical user interface and multi-user support.

Integrating OCL and Model Transformations in Fujaba

This paper discusses the integration of the Dresden OCL Toolkit into the Fujaba Tool Suite. The integration not only adds OCL support for class diagrams but also makes OCL usable in Fujabas model transformations. This makes Fujabas model transformations more powerful, completely platform independent and easier to read for developers who are already familiar with OCL. By using the code generator of the Dresden Toolkit, we are able to generate executable Java code from Fujabas model transformations including the OCL constraints.

eDOBS - Graphical Debugging for Eclipse

This paper presents the eDOBS tool. eDOBS is the little brother of the Fujaba environment. While Fujaba is used to create graph grammar based specifications and programs, eDOBS is used to browse graphs, to edit graphs, and to execute graph transformations.

Applying story driven modeling to the paderborn shuttle system case study

Story Driven Modeling (SDM) is a technical software development process employing UML-based modeling in all project phases, including implementation and test. SDM may be considered as a simple version of Model Driven Software Development as proposed by the OMG. SDM uses scenarios in analysis and test phases and provides practical guidelines for the synthesis of statecharts and method behavior specifications. SDM proposes object games for refining textual use case scenarios into so called story boards, i.e. sequences of UML interaction diagrams. From these story boards the modeler derives class diagrams, UML-based, operational behavior specifications and UML-based JUnit tests. The code generators of the Fujaba CASE tool turn this automatically in a Java implementation and run the JUnit tests. This paper is a case study applying SDM to the Paderborn shuttle system. This case study exemplifies how applications that deal with complex object structures may be modeled using SDM.

Transforming graph based scenarios into graph transformation based JUnit tests

This paper describes how the Fujaba CASE tool supports a semi-automatic transformation of usecase scenarios specified by so called story boards into automatic test specifications and test implementations. A story board is a sequence of graph snapshots showing the evolution of a graph based object structure during a typical example execution of an usecase. From such an example execution we automatically derive a test specification that executes the following three basic steps: First, a graph transformation is generated that creates an object structure serving as the test bed for the following steps. Second, we generate an operation that invokes the core method realizing the corresponding usecase. Third, we generate a graph test with a left-hand side corresponding to the graph structure described as result in the story board. On test execution, this graph test validates whether the object structure resulting from the usecase execution matches the results modeled in the usecase scenario. Support for this approach has been implemented within the Fujaba case tool. The approach has been validated in a major research project and in several student projects.

Story driven testing - SDT

In the last years, SCESM community has studied a number of synthesis approaches that turn scenario descriptions into some kind of state machine. In our story driven modeling approach, the statechart synthesis is done manually. Many other approaches rely on human interaction, too. Frequently, the resulting state machines are just the starting point for further system development. The manual steps and the human interaction and the subsequent development steps are subject to the introduction of errors. Thus, it is not guaranteed that the final implementation still covers the initial scenarios. Therefore, this paper proposes the exploitation of scenarios for the derivation of automatic tests. These tests may be used to force the implementation to implement at least the behavior outlined in the requirements scenarios. In addition, this approach raises the value of formal scenarios for requirements elicitation and analysis since such scenarios are turned into automatic tests that may be used to drive iterative development processes according to test-first principles.