title: Model-Driven Engineering in the Large: Refactoring Techniques for Models and Model Transformation Systems
title: Modellgetriebene Softwareeentwicklung im Großen: Refactoringverfahren für Modelle und Modelltransformationssysteme
Creators: name: Strüber, Daniel
Publisher: name: Philipps-Universität
      Marburg
Year: 2016
Subjects: Modellgetriebene Softwareentwicklung
Data processing, Computer science
Informatik
Modellgetriebene Entwicklung
Model-Driven Software Engineering
Modell-Driven Engineering
Modelltransformation
Softwareentwicklung , Modellgetriebene Entwicklung

description: Model-Driven Engineering (MDE) ist
      ein Paradigma der Softwaretechnik, in dem es darum geht, das
      Abstrationsniveau und dadurch die Entwicklerproduktivität
      während der Softwareentwicklung zu erhöhen. Hierzu lässt man
      Software-Modellen eine wesentliche Rolle während Entwurf,
      Implementierung und Einführung eines Systems zukommen. In
      jüngerer Zeit wurde MDE verhäuft in industriellen Projekten
      hoher Komplexität und großen Umfangs eingesetzt – ein Trend,
      den wir als MDE im Großen bezeichnen. Wir betrachten drei
      Herausforderungen, die durch den Einsatz von MDE in solchen
      Szenarien entstehen: 1. Modelle werden an verteilten
      Standorten, durch Teams von Teams entwickelt. Dabei führt die
      Verwendung großer und unzureichend strukturierter Modelle zu
      erheblichen Problemen, etwa zu einer erhöhten Anfälligkeit
      für Editierkonflikte. 2. Große Systeme werden oft durch einen
      Verbund von Modellen spezifiziert, die auf
      domänenspezifischen Modellierungssprachen (DSMLs) basieren.
      Die Modelle heterogener DSMLs in systematischer Weise zu
      integrieren erfordert geeignete Modularisierungsstrategien.
      3. Um die Entwicklung von Modellen systematisch zu
      beschreiben, spezifiziert man die dazu notwendigen
      Operationen durch Modelltransformationsregeln.
      Modelltransformationsregeln werden oft durch Klonierung
      erzeugt, also durch das Kopieren und Modifizieren vorhandener
      Regeln. Damit sind Nachteile für die Wartbarkeit und
      Performanz der erzeugten Regelsysteme verbunden. Im Rahmen
      dieser Arbeit präsentieren wir drei neue
      RefactoringVerfahren. Jedes dieser Verfahren zielt auf eine
      der benannten Herausforderungen ab: 1. Wir stellen ein
      Verfahren für das Aufsplitten eines monolithischen Modells in
      eine Menge von Teilmodellen vor. Dieses Verfahren ermöglicht
      die Umstrukturierung von Modellen hin zu einer Trennung der
      Belange. Bei der kollaborativen Entwicklung eines Systems
      können die beteiligten Entwickler somit auf Teilmodellen
      arbeiten, die für ihr aktuelles Arbeitspaket relevant sind.
      2. Wir beschreiben ein Verfahren zur Kapselung von
      Modellkomponenten durch die Einführung von Schnittstellen in
      einem Verbund von Modellen. Dieses Verfahren ermöglicht es,
      in Modellen von heterogenen DSMLs Modularität einzuführen. 3.
      Wir präsentieren ein Verfahren, um
      Modelltransformationsregeln, die gemeinsame Anteile
      aufweisen, zu verschmelzen. Dieses Verfahren zielt darauf ab,
      die Wartbarkeit und Performanz in
      Modelltransformationssystemen zu verbessern. Das Verfahren
      erstellt variabiliätsbasierte Regeln, ein neuartiger Typ von
      Regeln, in dem Variabilität anhand von Annotationen
      spezifiziert wird. Die im Rahmen dieser Arbeit vorgestellten
      Verfahren ermöglichen es, den manuellen Aufwand während des
      Refactorings von Modellen und Modelltransformationsregeln
      erheblich zu reduzieren. In einer Reihe von realistischen
      Fallstudien zeigen wir, dass die erstellten Modelle und
      Regeln von vergleichbarer oder, im Fall von Regeln, teilweise
      sogar von zu bevorzugender Qualität gegenüber dem Ergebnis
      eines manuellen Refactorings sind. Wir versprechen uns daher
      eine hohe Relevanz der Beiträge für MDE im Kontext
      industrieller Softwareentwicklung.
description: Model-Driven Engineering (MDE) is a
      software engineering paradigm that aims to increase the
      productivity of developers by raising the abstraction level
      of software development. It envisions the use of models as
      key artifacts during design, implementation and deployment.
      From the recent arrival of MDE in large-scale industrial
      software development – a trend we refer to as MDE in the
      large –, a set of challenges emerges: First, models are now
      developed at distributed locations, by teams of teams. In
      such highly collaborative settings, the presence of large
      monolithic models gives rise to certain issues, such as their
      proneness to editing conflicts. Second, in large-scale system
      development, models are created using various domain-specific
      modeling languages. Combining these models in a disciplined
      manner calls for adequate modularization mechanisms. Third,
      the development of models is handled systematically by
      expressing the involved operations using model transformation
      rules. Such rules are often created by cloning, a practice
      related to performance and maintainability issues. In this
      thesis, we contribute three refactoring techniques, each
      aiming to tackle one of these challenges. First, we propose a
      technique to split a large monolithic model into a set of
      sub-models. The aim of this technique is to enable a
      separation of concerns within models, promoting a
      concern-based collaboration style: Collaborators operate on
      the submodels relevant for their task at hand. Second, we
      suggest a technique to encapsulate model components by
      introducing modular interfaces in a set of related models.
      The goal of this technique is to establish modularity in
      these models. Third, we introduce a refactoring to merge a
      set of model transformation rules exhibiting a high degree of
      similarity. The aim of this technique is to improve
      maintainability and performance by eliminating the drawbacks
      associated with cloning. The refactoring creates
      variability-based rules, a novel type of rule allowing to
      capture variability by using annotations. The refactoring
      techniques contributed in this work help to reduce the manual
      effort during the refactoring of models and transformation
      rules to a large extent. As indicated in a series of
      realistic case studies, the output produced by the techniques
      is comparable or, in the case of transformation rules, partly
      even preferable to the result of manual refactoring, yielding
      a promising outlook on the applicability in real-world
      settings.