Abstract:
Zur Entwicklung komplexer Softwaresysteme, werden neben dem Quelltext zusätzliche Artefakte, wie beispielsweise Architekturmodelle, verwendet. Wenn die verwendeten Architekturmodelle während der Entwicklung und Evolution eines Softwaresystems konsistent mit dem Quelltext sind, können Softwarearchitekten und Softwareentwickler bei der Entwicklung der Systeme besser unterstützt werden. Architekturmodelle, die auf dem aktuellem Stand sind, vereinfachen Entwicklungs- und Evolutionssaufgaben, da einfacher beantwortet werden kann wie und wo neue Funktionen implementiert werden sollen. ... mehrAußerdem ist es möglich, modellbasierte Analysen mit Hilfe der Softwarearchitekturmodelle vorzunehmen. Beispielsweise können mit dem Palladio Komponentenmodell (PCM) Performanzvorhersagen durchgeführt werden, wenn ein Architekturmodell des Softwaresystems vorhanden ist und dieses Verhaltensspezifikationen beinhaltet.
Wenn Architekturmodelle bei der Softwareentwicklung und Softwareevolution verwendet werden, können die beiden bekannten Probleme Architekturdrift und Architekturverletzung auftreten. Diese Probleme treten für gewöhnlich auf, wenn bei voranschreitender Entwicklung des Quelltextes die Architektur nicht konsistent zu diesem gehalten wird. Dies führt zu veralteten und schlussendlich nutzlosen Architekturmodellen. Viele existierende Ansätze, zur Vermeidung dieser Probleme, zielen darauf ab, Quelltext und UML-Klassendiagramme konsistent zu halten, oder sie zielen darauf ab, Architekturinformationen in den Quelltext einzubetten. In letzterem Fall wird die Notwendigkeit, die Architektur konsistent mit dem Quelltext zu halten, umgangen, da die Architektur integraler Bestandteil des Quelltextes ist. In der vorliegenden Dissertation beschreiben wir einen neuen Ansatz, um komponentenbasierte Architekturmodelle, welche sich auf einer hohen Abstraktionsebene befinden, konsistent mit dem Quelltext zu halten. Wir beschreiben, wie Instanzen des PCMs konsistent mit Java-Quelltext gehalten werden können. Um Konsistenz zu erreichen, werden Architekturelemente erzeugt, gelöscht oder geändert, sobald ihre entsprechende Quelltextelemente geändert wurden, und umgekehrt. Für die Umsetzung der Konsistenzerhaltung stellen wir einen änderungsgetriebenen Ansatz vor. Dieser verwendet benutzerdefinierte, änderungsgetriebene Abbildungsregeln, um die Konsistenz zwischen den beteiligten Modellen sicherzustellen.
In dieser Dissertation stellen wir vier konkrete Mengen von Abbildungsregeln zwischen Architekturmodellen und Quelltext vor. Diese haben wir in einer prototypischen Implementierung des Ansatzes umgesetzt. Wir stellen außerdem einen Mechanismus vor, der mit den Benutzern des Konsistenzerhaltungsansatzes interagiert, wenn die Konsistenz nicht automatisch erhalten werden kann, sondern die Benutzer zuerst ihre Intention, die sie mit einer bestimmten Änderung verfolgen, dem Ansatz mitteilen müssen. In diesem Fall müssen die Benutzer das genaue Vorgehen für die Konsistenzerhaltung spezifizieren. Da der vorgestellte Ansatz änderungsgetrieben funktioniert, ist es notwendig, dass wir alle Änderungen in den beteiligten Architektur- und Quelltexteditoren aufzeichnen können. Um es Benutzern zu erlauben, vorhandene Editoren, mit denen sie sich auskennen, wiederverwenden zu können, haben wir Beobachter für diese Editoren implementiert. Diese Beobachter zeichnen alle Änderungen an einem Modell auf und informieren unseren Ansatz über jede durchgeführte Änderung. Der in dieser Dissertation vorgestellte Ansatz erlaubt es auch, verhaltensbeschreibende Architekturmodelle konsistent mit dem Quelltext zu halten. Um dies zu erreichen, haben wir einen Ansatz implementiert, der es ermöglicht, Service Effect Specifications des PCMs inkrementell aus Methoden zu erstellen, nachdem diese geändert wurden. Die Service Effect Specifications werden innerhalb des PCMs genutzt, um das Verhalten einer Komponente zu spezifizieren. Um bereits bestehende Architekturmodelle und bestehenden Quelltext innerhalb unseres Ansatzes verwenden zu können, stellen wir je eine Integrationsstrategie für die Architektur und den Quelltext vor. Um bestehende Architekturmodelle zu integrieren, simulieren wir deren Erstellung. Während dieses Erstellvorgangs zeichnen wir die Änderungen auf, die nötig sind, um das Architekturmodell zu erstellen. Diese Änderungen werden als Eingabe für den Konsistenzerhaltungsprozess verwendet, um daraus den entsprechenden Quelltext zu erzeugen. Um vorhandenen Quelltext einzubinden, stellen wir einen Ansatz vor, der auf Architekturrekonstruktionsverfahren basiert, d.h., zuerst wird die Architektur eines bestehenden Softwaresystems rekonstruiert. Die erstellte Architektur wird anschließend zusammen mit dem bestehenden Quelltext in unseren Coevolutionsansatz integriert. Oftmals ist bestehender Quelltext jedoch nicht so aufgebaut, wie es die Abbildungsregeln vorschreiben. Innerhalb der Integrationsstrategie für Quelltext stellen wir deshalb einen Ansatz vor, der in der Lage ist, solche Quelltexte dennoch zu integrieren. Dieser Ansatz ermöglicht es, nicht nur diese Art von Quelltext zu integrieren, sondern diesen auch mit speziell definierten Abbildungsregeln automatisch konsistent zu halten.
Wir haben unseren Ansatz in verschiedenen Fallstudien evaluiert. Dabei haben wir zunächst gezeigt, dass es möglich ist vorhandene Architekturmodelle zu integrieren, indem ihr Aufbau simuliert wird. In der durchgeführten Fallstudie ist es mit unserem Ansatz und den vorgestellten Abbildungsregeln möglich, zwischen 98% und 100% der unterstützten Elemente zu integrieren. Als nächstes haben wir gezeigt, dass unser Ansatz in der Lage ist, existierenden Quelltext zu integrieren und Änderungen am integrierten Quelltext konsistent mit der Architektur zu halten. Für diese Fallstudie haben wir zunächst den Quelltext von vier quelloffenen Projekten in den Ansatz integriert. Als nächstes haben wir gezeigt, dass es möglich ist, Änderungen am Quelltext konsistent mit der Architektur zu halten. Dazu haben wir eine alte Version des Quelltextes integriert und Änderungen die zwischen einer alten und neueren Version durchgeführt wurden, aus einem Versionskontrollsystem extrahiert und erneut auf den Quelltext angewendet. Im Rahmen dieser Evaluation haben wir auch gezeigt, dass es möglich ist Änderungen, die innerhalb von Methoden durchgeführt werden, mit einem Verhaltensmodell konsistent zu halten. Wir haben außerdem eine Evaluation der Leistungsfähigkeit unseres Ansatzes durchgeführt und gezeigt, dass unser Ansatz in den meisten Fällen in der Lage ist, die Architektur in einer Zeit zwischen einer und fünf Sekunden konsistent zu halten, nachdem eine Änderung am Quelltext durchgeführt wurde. Als letztes haben wir gezeigt, dass es möglich ist, coevolvierte Modelle für die Performanzvorhersage zu verwenden. Dazu haben wir zuerst die Modelle in einem Parametrisierungsschritt mit den nötigen Ressourcenverbräuchen angereichert. Als nächstes konnten wir die Performanzvorhersage durchführen. In unserer Fallstudie zeigte sich, dass der Vorhersagefehler für die Antwortzeit eines Systems bei ca. 10% liegt, und damit die coevolvierten Modelle für die Abschätzung der Performanz eines realen Systems verwendet werden können.
Abstract (englisch):
To develop complex software systems, source code and other artefacts, such as architectural models and behaviour descriptions, are used. Keeping these software architecture-based models consistent with the systems’ source code during software development and software evolution helps software architects. Having up-to-date architecture models eases the development and evolution tasks since questions such as how and where to add new features in the software systems can be answered more easily. Furthermore, it is possible to predict the performance of a software system with architecture models that include behavioural specifications, such as the Palladio approach.
... mehr
Architecture drift and architecture erosion are, however, two well-known problems that can arise during architecture-based software development and software evolution. These problems arise when software architecture models are not kept consistent with the source code, e.g. when code is evolved without updating the architecture accordingly. Eventually, this leads to out-dated and thus useless architecture models. Most existing solutions to avoid these problems either focus on keeping UML class diagrams and source code consistent during software evolution, or embed architectural information into the source code to avoid the need of consistency preservation.
In this thesis, we introduce a novel approach to keep high-level component-based architecture models consistent with source code during software development and software evolution. In particular, the approach can be used to keep instances of the Palladio Component Model (PCM) consistent with Java source code. To do so, the architectural elements are created, changed, or deleted as soon as their corresponding source code elements have been changed and vice versa. We also present a change-driven consistency preservation process that preserves consistency based on user-defined change-driven consistency preservation rules between the architectural model and source code. We introduce four different sets of consistency preservation rules between architectural models and source code, which are realised in our prototypical implementation. Within the consistency preservation process, we introduce a user disambiguation concept, which can be used if the consistency preservation cannot be achieved automatically. In this case, users need to clarify how consistency can be achieved. As the presented approach is a changed-driven approach, we need to retrieve each change performed in the involved architectural editors and the source code editors. To enable users to reuse existing editors, which with they are familiar, we implemented monitors for the Eclipse Java source code editor and PCM architectural model editors. The presented approach enables, furthermore, users to keep source code consistent with behavioural architectural models as well. Therefore, we have implemented an approach that incrementally reverse-engineers the PCM Service Effect Specifications based on changes performed to source code methods. The Service Effect Specifications are used to describe the behaviour of components. For reusing existing source code and existing architectural models within the presented approach, we present different integration strategies. For architectural models, we present an approach that simulates the creation of architectural models. During the creation, we monitor the emerging changes and use them as base for the creation of the corresponding source code. For source code, we propose an approach that uses reverse engineering tools to create an architectural model, which can be integrated to the consistency preservation approach presented in this thesis. Arbitrary code, however, is seldom build according to the defined consistency preservation rules. To deal with this fact, we present an approach that is able to deal with integrated source code for which the actual consistency preservation rules cannot be used. The approach is able to keep even those elements consistent using specific consistency preservation rules for integrated source code elements.
We have evaluated the presented approach in different case studies. We showed that it is possible to integrate existing architectural models by simulating their creation. Within the performed case study, we were able to integrate between 98% and 100% of the supported elements for the different consistency preservation rules. Next, we evaluated the integration of existing source code and showed that it is possible to keep changes to source code consistent with the architecture and vice versa. Therefore, we integrated four open source projects into the presented coevolution approach. We showed that changes performed to source code are kept consistent with the architectural model, by integrating an old version from the Version Control System (VCS) and replayed changes to a newer version using a change replay tool. During this evaluation, we also showed that the presented approach is able to keep changes performed to method bodies consistent with the behavioural model. We also conducted a performance evaluation to measure the overhead of the presented change-driven approach during the software evolution. We showed that the presented approach is in most cases able to keep the architectural model consistent with changes performed to the source code within one to five seconds. Finally, we evaluated that the coevolved architectural models can be used for performance prediction. Therefore, we first parameterised the models with resource demands. After the parameterisation step, we execute the performance prediction using the performance prediction capabilities of the PCM. To analyse the accuracy of the performance prediction, we compared the predicted value with actual measured values. In our case study, we observed a prediction error for the response time of approximately 10%, so that the coevolved models can be used to estimate the performance of the real software system.
