Multiperspective Change Impact Analysis to Support Software Maintenance and Reengineering

Abstract

The lifecycle of software is characterized by frequent and inevitable changes to address varying requirements and constraints, remaining defects, and various quality goals, such as portability or efficiency. Adapting long-living systems, however, poses the risk of introducing unintended side effects, such as new program errors, that are typically caused by dependencies between software artifacts of which developers are not aware of while changing the software. Consequently, research has focused on developing approaches for software change impact analysis to aid developers with assessing the consequences of changes prior to their implementation. Yet, current change impact analysis approaches are still code-based and only able to assess the consequences of changing source code artifacts. Software development on the other hand is accompanied by various different types of software artifacts, such as software architectures, test cases, source code files, etc. which in turn demand for comprehensive change impact analysis.

This thesis presents a novel approach for change impact analysis that is able to address heterogeneous software artifacts stemming from different development stages, such as architectural models and source code. It allows to forecast the impacts of changes prior to their implementation and is able to address a multitude of different change operations. The approach is based on a novel concept for computing the propagation of changes, for which the interplay of the types of changes, types of software artifacts, and the types of dependencies between them is analyzed by a set of predefined impact propagation rules. To accomplish this, the heterogeneous software artifacts are first mapped on a common meta-model to allow for a multiperspective analysis across the different views on software. Secondly, their dependencies are extracted and explicitly recorded as traceability links, while the type of change to be implemented is specified and modeled using a taxonomy and meta-model for change operations supplied by this thesis. A set of impact propagation rules is then recursively executed to compute the overall impact of the change, where each rule addresses a specific change operation and determines the resulting impact. Meanwhile, the impact computed by each rule is fed back into the analysis process where it may trigger the execution of further rules. Once the overall impact of a change has been determined, the impacted software artifacts are presented to the developer who is then able to understand the overall implications of the change and to implement it more efficiently.

The presented approach is implemented by the prototype tool EMFTrace and currently enables change impact analysis of UML models, Java source code, and JUnit test cases to support developers with their everyday modifications of software systems. The approach was deployed during a comprehensive case study to evaluate its efficiency and correctness when determining the impacts of changes. The approach helped to maintain the consistency of the architecture and the source code of the test system by reliably forecasting the impact propagation between both. The study furthermore confirmed that the approach achieves both high precision (90%) and recall (93%) when determining impacted software artifacts. Consequently, it computed only few false-positives and did not overestimate the impact propagation, which in turn enables developers to understand the effects of changes more easily and with less effort.

Der Lebenszyklus von Software wird von fortlaufenden Änderungen bestimmt, durch welche die Systeme an sich an stetig ändernde Anforderungen und Rahmenbedingungen angepasst, bestehende Defekte behoben sowie Qualitätsziele wie Portabilität und Effizienz adressiert werden. Änderungen bestehender, langlebiger Systeme bergen jedoch immer das Risiko ungewollter Seiteneffekte in sich, die durch Abhängigkeiten zwischen den einzelnen Bestandteilen der Software verursacht und häufig von Entwicklern übersehen werden. So können unbewusst durch Änderungen etwa zusätzliche Programmfehler oder Sicherheitslücken entstehen. Infolgedessen wurden Methoden entwickelt, mit deren Hilfe die Auswirkungen von Änderungen noch vor deren Umsetzung abgeschätzt werden können. Jedoch sind diese Ansätze hauptsächlich auf Quellcode beschränkt und vernachlässigen andere Arten von ebenso relevanten Beschreibungsmitteln, wie etwa Architekturmodelle oder Testfälle.

Diese Arbeit präsentiert einen neuen Ansatz zur Abschätzung der Auswirkungen von Änderungen, der in der Lage ist, unterschiedliche Softwareartefakte verschiedener Entwicklungsphasen, wie etwa Architekturmodelle und Quellcode, zu analysieren. Er ermöglicht es, die Konsequenzen von einer Vielzahl unterschiedlicher Änderungen noch vor deren Umsetzung zu erfassen. Der Ansatz basiert auf einem neuen Konzept zur Vorherbestimmung der Ausbreitung von Änderungen, wofür das Zusammenspiel von Änderungsoperationen, Softwareartefakten und deren Abhängigkeiten von Impact-Regeln analysiert wird. Dafür werden die heterogenen Softwareartefakte zunächst auf ein vereinheitlichendes Metamodell abgebildet, um einen sichtenübergreifenden Zugriff auf diese zu ermöglichen. Anschließend werden deren Abhängigkeiten extrahiert und explizit als Traceability-Links gespeichert, während die Änderungen anhand ihres Typs klassifiziert und ebenfalls explizit modelliert werden, wofür jeweils eine entsprechende Taxonomie sowie ein Metamodell bereitgestellt werden. Durch die anschließend rekursive Ausführung der Impact-Regeln werden die Auswirkungen der Änderung bestimmt, wobei jede Regel genau eine Änderung adressiert. Die von einer Regel berechneten Auswirkungen werden zurück in den Analyseprozess eingespeist, wo sie ggf. die Ausführung weiterer Regeln bedingen. Sobald die rekursive Regelverarbeitung abgeschlossen ist, werden dem Entwickler alle die von der geplanten Änderung betroffenen Softwareartefakte aufgezeigt.

Der entwickelte Ansatz wird prototypisch durch das Werkzeug EMFTrace implementiert und ermöglicht die Analyse von UML-Modellen, Java-Quellcode und JUnit-Testfällen, um Entwickler bei der Modifikation bestehender Systeme zu unterstützen. Der Ansatz wurde in einer umfangreichen Fallstudie hinsichtlich seiner Effektivität und Korrektheit bei der Vorherbestimmung der Auswirkungen von Änderungen evaluiert. Mit Hilfe des entwickelten Ansatzes konnte die Konsistenz zwischen der Architektur und dem Quellcode des Testsystems während der Umsetzung verschiedener Modifikationen aufrechterhalten werden. Gleichzeitig konnte gezeigt werden, dass der Ansatz in der Lage ist, die Auswirkungen von Änderungen sowohl möglichst korrekt (90%), als auch möglichst vollständig (93%) zu bestimmen, wodurch Entwickler effektiv bei der Implementierung von Änderungen unterstützt werden.