Calculation and propagation of model changes based on user level edit operations: a foundation for version and variant management in model driven engineering
Model driven engineering (MDE) has become a widespread approach for developing software in many application domains. Models are primary development documents in MDE and subject to continuous evolution. Models therefore have many versions and variants during system lifetime. Thus, the specification and recognition of changes in models is the key to understand and manage the evolution of a model based system. However, currently available model versioning tools operate on low level, sometimes tool specific model representations which can be considered as an implementation of the abstract syntax graph (ASG) of a model. Moreover, primitive graph edit operations are used to specify model changes. This leads to two serious problems: Firstly, the resulting model differences are hard to understand for normal tool users who are not familiar with the internal, graph based representation of models and the related types of nodes and edges which are usually defined by a meta model. Secondly, generic graph operations lead to further problems in change propagation scenarios since they can violate consistency constraints in ASGs. In the worst case, which particularly applies to all kinds of visual models, the synthesized result can no longer be opened in standard visual editors and must be corrected based on the serialized data format (e.g. XML) by using low level textual editors, which is obviously a tedious task prone to errors. Model differences should therefore be based on edit operations which are understandable for modelers and which preserve elementary consistency constraints in the sense that models remain displayable in visual editors. Edit operations which are offered as editing commands in standard editors or modern refactoring tools are examples of this. The tight integration of editing and versioning tools requires consistent specifications of edit operations; this integration is a largely open problem. The main objective of this thesis is to provide a solution for this problem and to systematically lift model versioning concepts, algorithms and tools to a higher level of abstraction. The central idea is to formally specify the available edit operations for a given type of models as transformation rules using the model transformation language Henshin which is based on graph transformation concepts. These formal specifications are automatically transformed into recognition rules being used by a lifting algorithm which recognizes edit operations in a low level difference of two model versions. The approach has been implemented and evaluated in a framework which is known as SiLift and which is based on the widely used Eclipse Modeling Project. Modellbasierte Softwareentwicklung ist in einigen Domanen inzwischen gangige Praxis. Modelle sind hier primare Artefakte. Sie entwickeln sich daher standig weiter und existieren im Laufe ihrer Evolution in zahlreichen Versionen und Varianten. Die Spezifikation und Erkennung von Anderungen an Modellen sind somit fundamentale Voraussetzung, um die Evolution modellbasierter Systeme zu verstehen und zu kontrollieren. Derzeitig verfugbare Werkzeuge des Versions und Variantenmanagements fur Modelle arbeiten jedoch auf systemnahen, fallweise werkzeugspezifischen Reprasentationen von Modellen, letzten Endes einer Implementierung des abstrakten Syntaxgraphen (ASG) eines Modells. Ferner werden primitive Graphoperationen zur Beschreibung von Anderungen an Modellen unterstellt. Dies fuhrt zu zwei wesentlichen Problemen: Zum einen ist die Darstellung solcher "low level" Anderungen meist unverstandlich, ohne Kenntnisse der internen, ASG basierten Reprasentation der Modelle teilweise sogar unmoglich. Zum anderen birgt die Anwendung von low level Anderungen im Rahmen der Propagation von Anderungen die Gefahr der Synthetisierung inkonsistenter Modelle. Im schlimmsten Fall kann ein Modell so inkorrekt werden, dass es nicht mehr mit Standard Modelleditoren verarbeitet werden kann. Dies gilt insbesondere fur visuelle Modelle, welche in diesem Fall nur noch mit einfachen textuellen Editoren auf Basis der Reprasentation des serialisierten Datenformats (z.B. XML) bearbeitet und korrigiert werden konnen. Modelldifferenzen sollten daher auf fur den Benutzer verstandlichen, konsistenzerhaltenden Editieroperationen basieren, wie sie bspw. von Modelleditoren oder modernen Refactoring Werkzeugen angeboten werden. Zur Erkennung derartiger Editieroperationen existieren bislang nur erste Ansatze. Die enge Integration von Editier und Differenzwerkzeugen erfordert konsistente Spezifikationen der Editieroperationen; diese Integration ist ein offenes wissenschaftliches Problem. Ziel dieser Arbeit ist es, dieses Integrationsproblem zu losen und die Versionierungskonzepte, algorithmen und werkzeuge von einem derzeit systemnahen Niveau auf ein moglichst hohes, benutzernahes Abstraktionsniveau anzuheben. Kernidee des im Rahmen dieser Dissertation entwickelten Ansatzes ist es, die fur einen Modelltyp verfugbaren Editieroperationen formal zu spezifizieren. Hierzu wird die Graphersetzungs und Modelltransformationssprache Henshin genutzt. Editierregeln werden automatisiert in Erkennungsregeln ubersetzt, welche zur Erkennung von Editieroperationen in low level Differenzen genutzt werden. Eine Referenzimplementierung des Ansatzes ist im Rahmen des Eclipse basierten Frameworks SiLift verfugbar und wurde in zahlreichen Fallstudien evaluiert.