Evolution-aware Modeling and Analysis of Software Product Lines

Aufgrund ihrer Variabilität umfassen Softwareproduktlinien eine hohe Anzahl von vielfältigen, aber dennoch ähnlichen Produktvarianten. Diese Tatsache sowie die ausgeprägte Wiederverwendung von Softwarebausteinen, zwischen denen außerdem komplizierte Abhängigkeiten bestehen können, lassen die Evolution von Softwareproduktlinien äußerst komplex werden. Diese Komplexität kann zu Inkonsistenzen und Fehlern bei der Evolution führen. Zur Vermeidung dessen werden Modelle eingesetzt, damit bereits vor der eigentlichen Evolution die zukünftigen Veränderungen betrachtet und untersucht sowie eventuelle Probleme durch Auswirkungen der Evolution abgeschätzt werden können. Folglich werden Modellierungsmethoden benötigt, die nicht nur die Variabilität der Produktlinien übersichtlich und verständlich darstellen, sondern auch Evolution abbilden können und eine effiziente Analyse von Evolutionsauswirkungen erlauben. Für die Darstellung von Variabilität existieren zahlreiche Ansätze aus den Modellierungskategorien der annotativen, kompositionalen und transformationalen Modelle. Die Anzahl der Techniken, die gleichzeitig mit Evolution umgehen können, sind jedoch weitaus geringer. Dies ist insofern problematisch, dass nicht für jede der genannten Kategorien Evolution auf eine einfache Weise modelliert werden kann. Die Kategorien bieten allerdings unterschiedliche Vor- und Nachteile bei der Darstellung und sind daher je nach Betrachtungsfokus ungleich nützlicher. Aus diesem Grund wird in dieser Arbeit mit der 175\%-Modellierung eine Modellierungsmethode für Evolution in annotativen Konzepten entwickelt, da für diese Kategorie noch keine Methode existiert, die gleichermaßen normale Variabilität und Evolution handhaben kann. Damit eine flexible Anwendung von Ansätzen aus unterschiedlichen Modellierungskategorien, beispielsweise zum Vergleich, ermöglicht wird, wird außerdem ein Algorithmus zur Transformation von Higher-Order Delta-Modellen - einem transformationalen Ansatz - in 175\%-Modelle entwickelt. So ist nur die Erstellung eines Modells nötig, um zwei Ansätze aus verschiedenen Kategorien verwenden zu können, deren Vor- und Nachteile sich gegenseitig ausgleichen können. Anhand von mathematischer Induktion wird außerdem bewiesen, dass der Algorithmus ein 175\%-Modell erzeugt, das äquivalent zum eingegebenen Higher-Order Delta-Modell ist, d.h. dass sich aus beiden Modellen die gleichen Produktmodelle ableiten lassen. Da 175\%-Modelle aufgrund der Kapselung sämtlicher Modellelemente in einem einzigen Modell sehr groß sind, wird darüber hinaus eine Möglichkeit zum Slicing von 175\%-Modellen vorgestellt, um die Komplexität der Modelle reduzieren und diese auf Basis bestimmter Kriterien analysieren zu können. Sowohl die Technik zur 175\%-Modellierung, der Transformationsalgorithmus und das 175\%-Slicing werden als Eclipse-Plug-ins implementiert und die Implementierung in dieser Arbeit dokumentiert

Entwicklung und Modellierung von Evolutionsszenarien für Delta-orientierte Softwareproduktlinien: Projektarbeit

Softwareproduktlinien bieten aufgrund ihrer Variabilität eine hohe Variantenvielfalt an unterschiedlichen, resultierenden Produkten. Dies und das hohe Maß an Wiederverwendung von Softwarebausteinen innerhalb der Produktlinie sowie deren vielfältige Abhängigkeiten untereinander führen dazu, dass die Evolution von Softwareproduktlinien überaus komplex ist. Damit Inkonsistenzen und Fehler als Folge von Evolution weitestgehend vermieden werden können, müssen vorher die genauen Auswirkungen der geplanten Änderungen eingeschätzt werden können. Dies wird durch die eingehende Betrachtung und Untersuchung der Veränderungen in Form von Modellen erreicht. Daher sind Modellierungsmethoden notwendig, die eine übersichtliche und verständliche Darstellung bieten und gleichzeitig eine effiziente Analyse der Auswirkungen erlauben. Doch auch die vielzählig vorhandenen Ansätze, Evolution von Softwareproduktlinien zu modellieren, müssen ausgiebig erprobt und evaluiert werden, damit Fehler im Konzept ausgeschlossen werden können und eine zuverlässige und alltagstaugliche Anwendung nachgewiesen werden kann. Für diese Evaluation werden Fallstudien mit Evolutionshistorie im Kontext von Softwareproduktlinien benötigt, welche bisher allerdings nicht in ausreichendem Maß vorhanden sind. Daher werden in dieser Projektarbeit vier verschiedene Fallstudien vorgestellt, die Softwareproduktlinien beschreiben. Es handelt sich um einen Verkaufsautomaten, eine Scheibenwischanlage, eine Minenpumpanlage und ein Body Comfort System. Für diese Fallstudien werden Szenarien entwickelt, welche evolutionäre Veränderungen an den zugrundeliegenden Softwareproduktlinien illustrieren. Da es sich um delta-orientierte Fallstudien handelt, werden die Ansätze „Delta-Modellierung“ zur Darstellung von Variabilität und „Higher-Order Delta-Modellierung“ zur Modellierung von Evolution verwendet, um Modelle für die Fallstudien und Evolutionsszenarien zu erstellen. Die entwickelten Evolutionsszenarien werden in einem Eclipse-basierten Prototyp umgesetzt und in dieser Arbeit dokumentiert

Automatische Generierung von feature-orientierten Produktlinien aus Varianten von funktionsblockorientierten Modellen

Zur einfacheren Entwicklung von technischen Systemen werden heutzutage vielfach funktionsblockorientierte Modellierungssprachen wie MATLAB/Simulink verwendet, die ein System als Netzwerk von miteinander verbundenen Funktionsblöcken darstellen. Aufgrund wechselnder Anforderungen entstehen dabei viele Modellvarianten, die nicht mehr effizient verwaltet werden können. Eine Lösung hierfür ist der Einsatz von Produktlinien, bei dem alle Varianten zusammengefasst und in wiederverwendbare Bestandteile zerlegt werden. Die Einzelvarianten werden dabei nur noch bei Bedarf aus diesen Bestandteilen zusammengesetzt. Die Erstellung dieser Produktlinien ist jedoch mit hohem manuellen Aufwand verbunden, besonders wenn vorhandene Modelle wiederverwendet werden sollen. Dies verhindert oft die Einführung dieses Paradigmas. Das Ziel der Dissertation war es deshalb, diese Migration vorhandener Modellvarianten und damit die Erstellung der Produktlinien zu automatisieren. Hierzu wurde eine Migrationsschrittfolge vorgeschlagen: Mithilfe eines Model-Matching-Ansatzes werden zuerst Gemeinsamkeiten und Unterschiede zwischen den Modellen identifiziert und daraus ein zusammengefasstes Modell und sogenannte Features abgeleitet. Mithilfe der Formalen Begriffsanalyse werden daraufhin die Abhängigkeiten zwischen diesen Features extrahiert und daraus ein Feature-Modell erstellt. Feature-Modell und zusammengefasstes Modell bilden dabei eine Produktlinie, die exakt die vorgegebenen Modellvarianten beschreibt

Consistency-Preserving Evolution Planning on Feature Models

A software product line (SPL) enables large-scale reuse in a family of related software systems through configurable features. SPLs represent a long-term investment so that their ongoing evolution becomes paramount and requires careful planning. While existing approaches enable to create an evolution plan for an SPL on feature-model (FM) level, they assume the plan to be rigid and do not support retroactive changes. In this paper, we present a method that enables to create and retroactively adapt an FM evolution plan while preventing undesired impacts on its structural and logical consistency. This method is founded in structural operational semantics and linear temporal logic. We implement our method using rewriting logic, integrate it within an FM tool suite and perform an evaluation using a collection of existing FM evolution scenarios

Konsistente Feature Modell gesteuerte Softwareproduktlinien Evolution

SPLs are an approach to manage families of closely related software systems in terms of configurable functionality. A feature model captures common and variable functionalities of an SPL on a conceptual level in terms of features. Reusable artifacts, such as code, documentation, or tests are related to features using a feature-artifact mapping. A product of an SPL can be derived by selecting features in a configuration. Over the course of time, SPLs and their artifacts are subject to change. As SPLs are particularly complex, their evolution is a challenging task. Consequently, SPL evolution must be thoroughly planned well in advance. However, plans typically do not turn out as expected and, thus, replanning is required. Feature models lean themselves for driving SPL evolution. However, replanning of feature-model evolution can lead to inconsistencies and feature-model anomalies may be introduced during evolution. Along with feature-model evolution, other SPL artifacts, especially configurations, need to consistently evolve. The work of this thesis provides remedy to the aforementioned challenges by presenting an approach for consistent evolution of SPLs. The main contributions of this thesis can be distinguished into three key areas: planning and replanning feature-model evolution, analyzing feature-model evolution, and consistent SPL artifact evolution. As a starting point for SPL evolution, we introduce Temporal Feature Models (TFMs) that allow capturing the entire evolution timeline of a feature model in one artifact, i.e., past history, present changes, and planned evolution steps. We provide an execution semantics of feature-model evolution operations that guarantees consistency of feature-model evolution timelines. To keep feature models free from anomalies, we introduce analyses to detect anomalies in feature-model evolution timelines and explain these anomalies in terms of their causing evolution operations. To enable consistent SPL artifact evolution, we generalize the concept of modeling evolution timelines in TFMs to be applicable for any modeling language. Moreover, we provide a methodology that enables involved engineers to define and use guidance for configuration evolution.Softwareproduktlinien (SPLs) ermöglichen es, konfigurierbare Funktionalität von eng verwandten Softwaresystemen zu verwalten. In einem Feature Modell werden gemeinsame und variable Funktionalitäten einer SPL auf Basis abstrakter Features modelliert. Wiederverwendbare Artefakte werden in einem Feature-Artefakt Mapping Features zugeordnet. Ein Produkt einer SPL kann abgeleitet werden, indem Features in einer Konfiguration ausgewählt werden. Im Laufe der Zeit müssen sich SPLs und deren Artefakte verändern. Da SPLs ganze Softwarefamilien modellieren, ist deren Evolution eine besonders herausfordernde Aufgabe, die gründlich im Voraus geplant werden muss. Feature Modelle eignen sich besonders als Planungsmittel einer SPL. Umplanung von Feature Modell Evolution kann jedoch zu Inkonsistenzen führen und Feature Modell Anomalien können im Zuge der Evolution eingeführt werden. Im Anschluss an die Feature Modell Evolution muss die Evolution anderer SPL Artefakte, insbesondere Konfigurationen, konsistent modelliert werden. In dieser Arbeit wird ein Ansatz zur konsistenten Evolution von SPLs vorgestellt, der die zuvor genannten Herausforderungen adressiert. Die Beiträge dieser Arbeit lassen sich in drei Kernbereiche aufteilen: Planung und Umplanung von Feature Modell Evolution, Analyse von Feature Modell Evolution und konsistente Evolution von SPL Artefakten. Temporal Feature Models (TFMs) werden als Startpunkt für SPL Evolution eingeführt. In einem TFM wird die gesamte Evolutionszeitlinie eines Feature Modells in einem Artefakt abgebildet, was sowohl vergangene Änderungen, den aktuellen Zustand, als auch geplante Änderungen beinhaltet. Auf Basis einer Ausführungssemantik wird die Konsistenz von Feature Modell Evolutionszeitlinien sichergestellt. Um Feature Modelle frei von Anomalien zu halten, werden Analysen eingeführt, welche die gesamte Evolutionszeitlinie eines Feature Modells auf Anomalien untersucht und diese mit verursachenden Evolutionsoperationen erklärt. Das Konzept zur Modellierung von Feature Modell Evolutionszeitlinien aus TFMs wird verallgemeinert, um die gesamte Evolution von Modellen beliebiger Modellierungssprachen spezifizieren zu können. Des Weiteren wird eine Methodik vorgestellt, die beteiligten Ingenieuren eine geführte Evolution von Konfigurationen ermöglicht

Visualisierung von Variabilität in C-Quellcode

In C-Quellcode wird der C-Präprozessor häufig verwendet, um ein Softwaresystem für verschiedene Ausführungsumgebungen und Varianten zu konfigurieren. Anweisungen zur bedingten Kompilierung ermöglichen es, dass Quellcodeteile bei der Verarbeitung durch den Präprozessor ein- oder ausgeblendet werden. Dies erzeugt verschiedene Varianten der Software, erschwert jedoch die Lesbarkeit und Wartung des Quellcodes. Insbesondere die Auswirkungen einzelner Makrodefinitionen sind oft nicht einfach zu ermitteln. In dieser Arbeit soll der Frage nachgegangen werden, wie das Verständnis des Quellcodes und der Auswirkungen von Makrodefinitionen mithilfe von Softwarevisualisierung unterstützt werden kann. Dazu wird eine bestehende Visualisierungsmetapher an den Anwendungsfall angepasst. Anschließend folgt der Entwurf eines Verarbeitungsprozesses, um den Quellcode automatisiert darstellen zu können. Mithilfe eines Prototyps wird die Machbarkeit gezeigt.:Inhaltsverzeichnis Inhaltsverzeichnis I Abbildungsverzeichnis III Tabellenverzeichnis IV Listings V Abkürzungsverzeichnis VI 1 Einleitung 1 1.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 1.2 Zielsetzung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 1.3 Vorgehensweise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 1.4 Stand der Forschung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 2 Grundlagen 6 2.1 Die Programmiersprache C . . . . . . . . . . . . . . . . . . . . . . . . . . 6 2.1.1 Eigenschaften . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 2.1.2 Wichtige Sprachelemente . . . . . . . . . . . . . . . . . . . . . . 7 2.1.3 Der C-Präprozessor . . . . . . . . . . . . . . . . . . . . . . . . . . 8 2.1.4 Ablauf der Kompilierung . . . . . . . . . . . . . . . . . . . . . . . 10 2.2 Softwarevisualisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 2.2.1 Eigenschaften und Ziele . . . . . . . . . . . . . . . . . . . . . . . 11 2.2.2 Getaviz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 2.3 Graphdatenbanken und Neo4j . . . . . . . . . . . . . . . . . . . . . . . . 14 3 Konzeption 17 3.1 Anwendungsfall . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 3.2 Extraktion der benötigten Informationen . . . . . . . . . . . . . . . . . . . 19 3.2.1 Sprachmittel im C-Standard . . . . . . . . . . . . . . . . . . . . . 19 3.2.2 Variabilität in C-Quellcode . . . . . . . . . . . . . . . . . . . . . . 21 3.2.3 Extraktion von Variabilität . . . . . . . . . . . . . . . . . . . . . . 25 3.2.4 Entwurf eines Graphmodells für C-Quellcode . . . . . . . . . . . . 29 3.3 Visualisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33 3.3.1 Analyse bestehender Metaphern . . . . . . . . . . . . . . . . . . . 34 3.3.2 Darstellung der Variabilität in der Benutzungsoberfläche . . . . . . 37 3.4 Überblick über den Generierungsprozess . . . . . . . . . . . . . . . . . . . 39 4 Implementierung 42 4.1 Vorverarbeitung des Quellcodes . . . . . . . . . . . . . . . . . . . . . . . 42 4.1.1 Anpassung von TypeChef . . . . . . . . . . . . . . . . . . . . . . 42 4.1.2 Aufbau des Abstract Syntax Tree . . . . . . . . . . . . . . . . . . 43 4.2 Das jQAssistant-Plugin . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44 4.2.1 Aufbau und grundsätzliche Funktionsweise . . . . . . . . . . . . . 44 4.2.2 Wichtige Descriptors und Relations . . . . . . . . . . . . . . . . . 46 4.2.3 Verarbeitung der XML-Datei . . . . . . . . . . . . . . . . . . . . . 46 4.2.4 Parsen der Bedingungen . . . . . . . . . . . . . . . . . . . . . . . 49II 4.3 Anpassung von Getaviz . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50 4.4 Erweiterung der graphischen Oberfläche . . . . . . . . . . . . . . . . . . . 52 4.5 Test und Evaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 5 Fazit 55 5.1 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 5.2 Kritische Würdigung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56 5.3 Ausblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57 A Übersicht über die Sprachmittel im C-Standard VII Literaturverzeichnis X

Erklären von Erfüllbarkeitsanfragen für Softwareproduktlinien

Many analyses have been proposed to ensure the correctness of the various models used throughout software product line development. However, these analyses often merely serve to detect such circumstances without providing any means for dealing with them once encountered. To aid the software product line developer in understanding the cause of defects, a new algorithm capable of explaining satisfiability queries in a software product line context is presented in this thesis. This algorithm finds explanations by using SAT solvers to extract minimal unsatisfiable subsets from the propositional formulas that express the defects. The algorithm is applied to feature model defects such as dead features and redundant constraints, automatic truth value propagations in configurations, and preprocessor annotations that are superfluous or cause dead code blocks. Using feature models and configurations from real software product lines of varying sizes, this approach is evaluated against an existing explanation approach based on Boolean constraint propagation. The results show that Boolean constraint propagation occasionally fails to find any explanation at all but is magnitudes faster than using minimal unsatisfiable subset extractors. In response, both algorithms are combined into a single one that is as fast as Boolean constraint propagation for the cases where that finds an explanation, but also finds an explanation for all the other cases.Viele Analysen wurden vorgeschlagen, um die Korrektheit der verschiedenen in der Entwicklung von Softwareproduktlinien genutzten Modelle zu gewährleisten. Allerdings dienen diese Analysen häufig lediglich dem Erkennen solcher Umstände, ohne Mittel zu liefern, sie zu lösen, sobald sie angetroffen wurden. Um dem Entwickler der Softwareproduktlinie das Verstehen der Ursache der Defekte zu erleichtern, wird in dieser Arbeit ein neuer Algorithmus zum Erklären von Erfüllbarkeitsanfragen im Kontext von Softwareproduktlinien vorgestellt. Dieser Algorithmus findet Erklärungen, indem mittels SAT-Solvern eine minimale unerfüllbare Teilmenge aus der aussagenlogischen Formel, die den Defekt ausdrückt, extrahiert wird. Der Algorithmus wird angewandt auf Defekte in Feature-Modellen wie tote Features und redundante Constraints, automatische Resolution von Wahrheitswerten in Konfigurationen sowie Präprozessorannotationen, die überflüssig sind oder tote Code-Blocks verursachen. Dieser Ansatz wird anhand von Feature-Modellen und Konfigurationen aus echten Softwareproduktlinien verschiedener Größen gegen einen existierenden, auf Boolean-Constraint-Propagation basierenden Ansatz zum Erklären evaluiert. Die Ergebnisse zeigen, dass Boolean-Constraint-Propagation gelegentlich gar keine Erklärung findet, aber um Größenordnungen schneller als mittels Extraktoren für minimale unerfüllbare Teilmengen ist. Daraufhin werden beide Algorithmen in einem einzigen verbunden, der so schnell wie Boolean-Constraint-Propagation ist, wenn dieser eine Erklärung findet, aber auch eine Erklärung in allen übrigen Fällen findet