Modellgetriebene Entwicklung mit Graphtransformationen

Titelangaben

Winetzhammer, Sabine:
Modellgetriebene Entwicklung mit Graphtransformationen.
Bayreuth , 2015 . - X, 258 S.
( Dissertation, 2015 , Universität Bayreuth, Fakultät für Mathematik, Physik und Informatik)

Volltext

Link zum Volltext (externe URL):

Weitere URLs

Abstract

In dieser Arbeit wird ModGraph vorgestellt. Es bietet einen ganzheitlichen, leichtgewichtigen und hochgradig integrativen Ansatz zur totalen modellgetriebenen Softwareentwicklung.
Der ModGraph-Ansatz bietet eine echte Erweiterung des EMF-Rahmenwerks, einem in Industrie und Forschung etablierten Werkzeug zur Strukturmodellierung (und anschließender Quelltextgenerierung)
mit Ecore-Klassendiagrammen. Dabei steht die Vervollständigung von EMF um die - bislang fehlende - Verhaltensmodellierung im Vordergrund. Diese wird durch einen hybriden Ansatz aus regelbasierter
und prozeduraler Verhaltensmodellierung erreicht, der programmierte Graphtransformationsregeln zur Spezifikation von Verhalten anbietet und gleichzeitig eine strikte Trennung der Regeln und der
prozeduralen Elemente fordert. Dazu setzt sich ModGraph zum Ziel, bestehende Konzepte zu erweitern und zu nutzen, statt diese nochmals zu reimplementieren.

ModGraph konzentriert sich dabei auf den Mehrwert der Graphtransformationsregeln im Kontext der Verhaltensmodellierung. Die Regeln stellen komplexe Änderungen an Objektstrukturen deklarativ dar,
indem lediglich der Zustand der Objektstruktur vor und nach ihrer Ausführung angegeben wird.

In dieser Arbeit wird eine ausführbare Sprache zur Modellierung von Verhalten, basierend auf Graphtransformationsregeln für und mit EMF entwickelt, die nahtlos integriert sind. Den Ansatzpunkt
bieten die strukturellen Ecore-Modelle. Jede Regel wird als Implementierung einer darin deklarierten Operation aufgefasst. Sie spezifiziert das Verhalten der Operation, die auf der Modell-Instanz ausgeführt wird.
Hierbei wird die Instanz als Graph aufgefasst und eine kompakte Darstellung der Regel genutzt, die es erlaubt, Struktur und Änderungen in einem zusammengeführten Diagramm darzustellen. Dazu werden ein- und mehrwertige
Knoten, die Objekte und Objektmengen repräsentieren, sowie Links, die Instanzen von Referenzen darstellen, und Pfade, die für abgeleitete Referenzen stehen, angeboten. Neben Transformationen können auch Tests und
Abfragen auf den Graphen spezifiziert werden, indem Regeln ohne explizite Angabe von Änderungen modelliert werden. Zudem ist es möglich, das Graphmuster durch Bedingungen zu ergänzen. Textuelle Vor- und Nachbedingungen,
sowie durch Graphen repräsentierte negative Anwendbarkeitsbedingungen, erlauben eine Einschränkung der Anwendbarkeit der Regel.

Zur Komposition der Regeln wird Xcore verwendet, das eine textuelle Syntax für Ecore anbietet und diese um die Sprachkonstrukte zur Verhaltensbeschreibung mit dem Java-nahen Xbase erweitert. Außerdem wird es zur Spezifikation
von einfachen oder prozeduralen Operationen verwendet, so dass der Nutzer auswählen kann, welche Teilprobleme mit Regeln oder direkt in Xcore gelöst werden sollen. Dies führt zu einer geeigneteren Nutzung der Regeln. Zudem
kann Xcore zur Strukturmodellierung, alternativ zu Ecore, verwendet werden.

Die Unterstützung des Modellierens im Großen wird außerdem durch die Einbindung eines existierenden Paketdiagrammeditors erreicht. Paketdiagramme statten EMF mit einer Möglichkeit zur Architekturmodellierung aus.

Die - zur Ausführung des Modells nötige - Zusammenführung der Struktur, der Regeln und der prozeduralen Elemente erfolgt entweder auf Modell- oder auf Quelltextebene. Dazu wird eine kompilierte Lösung verwendet,
die zwei verschiedene Modell-Transformationen anbietet. Einmal wird der EMF- oder Xcore-Generator genutzt, der Java-Quelltext erzeugt, in welchen der ModGraph-Generator den aus den Regeln generierten Quelltext
nahtlos integriert. Alternativ kann eine bislang einzigartige Transformation der Regeln in die Modellierungssprache Xcore stattfinden.
Sie werden übersetzt und nahtlos in das bestehende Modell integriert.
Das so entstandene Xcore-Modell kann interpretiert oder in Java-Quelltext übersetzt werden.
Bei der Generierung nach Java (via Xcore) setzt ModGraph einen, bislang im Graphtransformationskontext nicht verfügbaren, stufenweisen Übersetzungsprozess der Regeln um, der zur Unabhängigkeit von der Zielprogrammiersprache führt.

Die Eclipse-basierte Werkzeugumgebung zum ModGraph-Ansatz bietet - neben einem intuitiv zu bedienenden grafischen Editor zur Erstellung kommentierter Regeln - eine eigene, auf die Entwicklung der Regeln zugeschnittene
Ansicht, die den Nutzer in die Abläufe der Entwicklung mit ModGraph einführt und ihn anleitet (Cheat Sheets, Dashboard). Dadurch wird dem Modellierer ein einfacher, schrittweiser Übergang von der reinen Modellierung mit
EMF in die Modellierung mit ModGraph ermöglicht.

Zur Evaluation der Arbeit werden zwei größere Anwendungen der ModGraph-Regeln betrachtet. Zum Einen werden propagierende Refactorings für und mit ModGraph erstellt. Dabei wird ein reflektiver Ansatz verfolgt,
der komplexe Refactoring-Operationen an Ecore-Modellen auf die Regeln propagiert. Zum Anderen wird die Anwendung der Graphtransformationsregeln im Kontext der szenarienbasierten Modellierung zur Simulation von
Echtzeitsystemen untersucht.

Abstract in weiterer Sprache

This thesis presents ModGraph, a sound, lightweight and highly integrative approach for total model-driven software engineering. The ModGraph approach extends the Eclipse Modeling Framework, which is widely used in
both industry and research. EMF offers structural modeling (and code generation) using Ecore class diagrams.

This work focuses on adding the missing behavior modeling, by using and extending existing concepts. It presents a hybrid approach for behavior modeling, using both rule-based and procedural elements,
but strictly separated. For the rule-based part, programmed graph transformation rules are used.

ModGraph focuses on the added value of graph transformation rules in the context of behavior modeling. They offer a declarative style to model complex changes on object structures. Therefore one specifies the objects'
state before and after the application of the rule.

This work offers a seamless integrated, executable language to model behavior with graph transformation rules for and with EMF. Each rule implements an operation defined in the Ecore model. It specifies the operations'
behavior, which is executed on a model instance. Therefore the instance is considered as a graph. The rule is specified using a compact editor, which allows the specification of the structure and the changes in a merged view.
To this end, ModGraph provides single- and multi-valued nodes (representing objects and sets of them, respectively) as well as links (representing instances of references) and paths (representing derived references).
Besides transformations, one may specify tests and queries, by defining rules without changes. Furthermore, each rule may be constrained concerning its applicability using textual pre- and postconditions as well as graph-based
graphical negative application conditions.

Rules are composed with Xcore, a textual syntax for Ecore that extends it by using the Java-like language Xbase for behavior specification. Additionally, ModGraph uses Xcore to specify simple or procedural operations. Hence,
the user may decide if a rule or a procedural operation is suitable for the considered part of his problem. This strategy leads to a more concise use of the rules. Furthermore, Xcore may replace Ecore for structural modeling.

Also supporting modeling in the large, ModGraph integrates an existing package diagram editor. In this way it supports architecture modeling in EMF.

For the execution of a model specified with ModGraph, structural, rule-based and procedural models need to be merged. This may be performed on model and on code level. For the realization, a compiled solution offers two kinds
of model transformations. First the EMF or Xcore generator is used to create Java code, in which the ModGraph generator injects the code generated from the rules. Alternatively, ModGraph provides a new unique approach to
compile the rules into operations of the Xcore model. This means compiling the rules to their Xcore representation and injecting it into the model. The resulting Xcore model may be interpreted or compiled.
For generation, ModGraph provides a staged translation to Java (via Xcore), which is
unique in the context of graph transformation tools. It provides platform independence, as the finally generated programming language is no more significant.

ModGraph's Eclipse-based tooling offers an intuitive editor for creating and commenting rules as well as a view that guides and supports the user during the modeling process (cheat sheets, dashboard). Hence, it
helps the EMF user to use ModGraph's capabilities.

To evaluate the approach, this thesis considers two profoundly different use cases. The first one offers propagating refactoring operations for and with ModGraph. Therefore it uses a reflective approach that propagates
the model refactorings to the rules. The second one investigates the usability of graph transformation rules in the context of scenario-based modeling to simulate real-time systems.