Torrent details for "Langhammer M. Automated Coevolution of Source Code...Soft Archit…" Log in to bookmark
Controls:
×
Report Torrent
Please select a reason for reporting this torrent:
Your report will be reviewed by our moderation team.
×
Report Information
Loading report information...
This torrent has been reported 0 times.
Report Summary:
| User | Reason | Date |
|---|
Failed to load report information.
×
Success
Your report has been submitted successfully.
Checked by:
Category:
Language:
None
Total Size:
3.1 MB
Info Hash:
3B7DDB786C68751DF9BCA882DC7E5F78DCC22114
Added By:
Added:
Oct. 8, 2025, 9:57 a.m.
Stats:
|
(Last updated: Oct. 8, 2025, 10:02 a.m.)
| File | Size |
|---|---|
| Langhammer M. Automated Coevolution of Source Code...Soft Architect. Models 2017.pdf | 3.1 MB |
Name
DL
Uploader
Size
S/L
Added
NOTE
SOURCE: Langhammer M. Automated Coevolution of Source Code...Soft Architect. Models 2017
-----------------------------------------------------------------------------------
COVER
-----------------------------------------------------------------------------------
MEDIAINFO
Textbook in PDF format 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 speci cations, such as the Palladio approach. 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 componentbased 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-de ned changedriven consistency preservation rules between the architectural model and source code. We introduce four di erent 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 change-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 E ect Speci cations based on changes performed to source code methods. The Service E ect Speci cations are used to describe the behaviour of components. For reusing existing source code and existing architectural models within the presented approach, we present di erent 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 de ned 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 speci c consistency preservation rules for integrated source code elements. We have evaluated the presented approach in di erent 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 di erent 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 ve seconds. Finally, we evaluated that the coevolved architectural models can be used for performance prediction. Therefore, we rst 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
×