title: Supporting software architecture documentation and evolution
Creators: name: Haitzer, Thomas
Publisher: name: :none
Year: 2016

description: Jedes Programm hat eine Architektur. Einige Ansätze verwenden zur Dokumentation dieser Softwarearchitektur verschiedene Perspektiven, die in mehreren Sichten festgehalten werden. Eine oft verwendete Sicht sind Diagramme, die die Komponenten der Architektur und deren Verbindungen zeigen. Ein wichtiges Problem aller dieser Sichten, die Architekturkomponenten zeigen, ist, dass sich die dokumentierte Architektur und die Implementierung während der Evolution des Systems auseinander bewegen können. Dies führt oft zum Verlust von Architekturwissen. Ein verwandtes Problem ist die Erosion von Architekturwissen im Lauf der Zeit. Beide Probleme können zu inkonsistentem, obsoletem oder vollständig verlorenem Architekturwissen führen. Einige Ansätze versuchen, Architektursichten automatisch aus dem Quellcode wiederherzustellen. Manche dieser Ansätze versuchen auch, Artefakte wie Entwurfsmuster, die auf einem höheren Abstraktionsniveau liegen, wiederherzustellen. Allerdings sind diese Ansätze limitiert im Bezug auf Präzision und Wiedererkennung von Entwurfsmustern und sind meist nicht dazu gedacht, den Software Prozess fortlaufend zu unterstützen, sondern zu einem Zeitpunkt eine Architektursicht wiederherzustellen. Sie verhindern nicht, dass eine wiederhergestellte Architektur und der Quellcode in der weiteren Entwicklung wieder auseinander driften. In dieser Arbeit zeigen wir, dass Komponentendiagramme zum besseren Verständnis von Softwarearchitektur beitragen. Basierend auf diesen Erkenntnissen stellen wir einen semi-automatischen Ansatz zur Erstellung von Komponentensichten vor, der die Gefahr für den Verlust von Architekturwissen reduziert, in dem er während der Evolution eines Systems die Artefakte automatisch auf Konsistenz prüft. Unser Ansatz unterstützt auch die Identifikation und Dokumentation von Architekturmustern in den Komponentensichten. Im Gegensatz zu den erwähnten Ansätzen berücksichtigt unser Ansatz die Software Evolution und unterstützt den Softwarearchitekten während der Evolution, in dem er navigierbare Dokumentation zur Verfügung stellt und die Konsistenz der involvierten Artefakte prüft. Des Weiteren beschränkt sich unser Ansatz nicht auf fixe Abstraktionen wie einige, bestimmte Entwurfsmuster, sondern unterstützt die Identifikation und Dokumentation von Architekturmustern, die sich auf einem höheren Abstraktionsniveau befinden. Die Evolution von Software ist ein komplexer Prozess, der aus vielen einzelnen Aufgaben besteht, die voneinander abhängig sein können. Bei großen Systemen müssen für die Evolution oft mehrere Entwicklerteams zusammenarbeiten, die eventuell über mehrere Länder und Zeitzonen verstreut sind. In solchen Szenarien ist die Koordination der einzelnen Aufgaben und der Reihenfolge ihrer Bearbeitung eine große Herausforderung. Unser Ansatz berücksichtigt auch die dokumentierten Entwurfsentscheidungen und hilft bei der komplexen Aufgabe, die die Weiterentwicklung (Evolution) eines Systems darstellt, indem er es erlaubt, die einzelnen Aufgaben und ihre Abhängigkeiten zu definieren und dann automatisch Pläne für die Abarbeitung der Aufgaben generiert, die die Abhängigkeiten und Einschränkungen unter den einzelnen Aufgaben berücksichtigen.
description: Every software has an architecture. A number of approaches propose to document this architecture from different perspectives using different views. A commonly used view is the architectural component view, which shows a system's overall structure and abstracts away the low-level details. A central problem of all architectural views, including component views, is that the architecture and implementation of a software system can drift apart as software systems evolve, often leading to architectural knowledge evaporation. A related problem is the erosion of architectural knowledge over time. Both problems can lead to inconsistent, outdated, or completely lost architectural knowledge. A number of approaches have been proposed to automatically reconstruct architectural views from the source code, in some cases even including the detection of higher-level abstractions such as design patterns. However, the precision and recall of such approaches is still limited, and they are not designed to be continuously used in the software development process, but rather to reconstruct a view at a certain point in time. That is, the reconstructed architecture is likely to suffer from similar architectural knowledge evaporation problems in the future. In this thesis, we provide evidence that component diagrams are beneficial to architecture understanding. Based on these findings, we then introduce a semi-automatic approach for creating architectural component views based on architecture abstraction specifications that allows automatic consistency checking during a system's evolution and thus reduces the risk of architectural drift and erosion. Our approach also supports the identification and documentation of architectural pattern instances in those views. In contrast to the aforementioned approaches, our approach explicitly considers the evolution of the documented system and actively supports this evolution by providing navigable documentation and consistency checking between the involved artifacts. It does not only focus on a limited set of abstractions, like certain design patterns, but can also support the identification and documentation of higher-level architectural patterns. The evolution of software is a complex process that consists of multiple tasks that have many interdependencies. In large systems it usually involves multiple development teams that might be located in different time zones or countries to work on the same system together. In such a situation managing the order of these tasks or evolution steps and their distribution on the different teams becomes challenging. Our approach also takes the architectural decision making during evolution into account and aids the complex task of actually evolving a software system by letting the architects define multiple, interdependent implementation tasks and automatically generate plans for performing the implementation tasks that satisfy all dependencies and constraints.