Logo des Repositoriums

Auflistung nach Schlagwort "Software Evolution"

1 - 7 von 7
  • ConferencePaper
    Accurate Modeling of Performance Histories for Evolving Software Systems
    (Software Engineering 2021, 2021) Mühlbauer, Stefan; Apel, Sven; Siegmund, Norbert
    This work has been originally published in the proceedings of the 34th IEEE/ACM International Conference on Automated Software Engineering (ASE 2019). Learning from the history of a software system’s performance behavior does not only help discovering and locating performance bugs, but also supports identifying evolutionary performance patterns and general trends. Exhaustive regression testing is usually impractical, because rigorous performance benchmarking requires executing realistic workloads per revision, resulting in large execution times. We devise a novel active revision sampling approach that aims at tracking and understanding a system’s performance history by approximating the performance behavior of a software system across all of its revisions. In short, we iteratively sample and measure the performance of specific revisions to learn a performance-evolution model. We select revisions based on how uncertainty our models predicts their correspondent performance values. Technically, we use Gaussian Process models that not only estimates performance for each revision, but also provides an uncertainty value alongside. This way, we iteratively improve our model with only few measurements. Our evaluation with six real-world configurable software system demonstrates that Gaussian Process models are able to accurately estimate the performance-evolution histories with only few measurements and to reveal interesting behaviors and trends, such as change points.
  • Konferenzbeitrag
    Change Impact Analysis by Architecture-based Assessment and Planning
    (Software Engineering 2017, 2017) Rostami, Kiana; Stammel, Johannes; Heinrich, Robert; Reussner, Ralf
    Software architecture presents the main artifact of software systems reflecting design decisions and thus influence their quality attributes. Furthermore, during software evolution each architecture decision also influences technical artifacts (e.g., test cases) and the corresponding orga- nizational responsibilities (e.g., tester). Thus, it is important to predict the impact of a change request (e.g., changing an interface) on the software architecture and other software artifacts for decision- making. Hence, a software architect can estimate the effort of the implementation of a change request due to corresponding implementation tasks. However, existing approaches are limited to artifacts of the software development process or do not use formal architecture descriptions. We present the Karlsruhe Architectural Maintainability Prediction (KAMP), that enables software architects to ana- lyze the propagation of change requests in software architecture models. Our approach is not limited to the technical operations but as well considers the organizational tasks. KAMP supports softwa- re architects by automatically generated task lists to implement changes. In an empirical study, we showed, that KAMP improves the scalability, precision, and completeness of change propagation analysis.
  • Zeitschriftenartikel
    Discovery and Description of Software Evolution Services
    (Softwaretechnik-Trends: Vol. 33, No. 2, 2013) Jelschen, Jan
    Jan Jelschen Carl von Ossietzky Universit¨ at, Oldenburg, Germany jelschen@se.uni-oldenburg.de
  • Konferenzbeitrag
    Generating Accurate and Compact Edit Scripts using Tree Differencing
    (Software Engineering 2020, 2020) Frick, Veit; Grassauer, Thomas; Beck, Fabian; Pinzger, Martin
    For analyzing changes in source code, edit scripts are used to describe the differences between two versions of a file. These scripts consist of a list of actions that, applied to the source file, result in the new version of the file. In contrast to line-based source code differencing, tree-based approaches such as GumTree, MTDIFF, or ChangeDistiller extract changes by comparing the abstract syntax trees (AST) of two versions of a source file. One benefit of tree-based approaches is their ability to capture moved (sub)trees in the AST. Our approach, the Iterative Java Matcher (IJM), builds upon GumTree and aims at generating more accurate and compact edit scripts that capture the developer's intent. This is achieved by improving the quality of the generated move and update actions, which are the main source of inaccurate actions generated by previous approaches. To evaluate our approach, we conducted a study with 11 external experts and manually analyzed the accuracy of 2400 randomly selected edit actions. Comparing IJM to GumTree and MTDIFF, the results show that IJM provides better accuracy for move and update actions and is more beneficial to understanding the changes.
  • Konferenzbeitrag
    GuideGen: An Approach for Keeping Requirements and Acceptance Tests Aligned
    (Software Engineering 2020, 2020) Hotomski, Sofija; Glinz, Martin
    This contribution was originally published as: Sofija Hotomski, Martin Glinz (2019). GuideGen: An Approach for Keeping Requirements and Acceptance Tests Aligned via Automatically Generated Guidance. Information and Software Technology 110:17–38.
  • Konferenzbeitrag
    Identifying Software Performance Changes Across Variants and Versions
    (Software Engineering 2022, 2022) Mühlbauer, Stefan; Apel, Sven; Siegmund, Norbert
    Performance changes of configurable software systems can occur and persist throughout their lifetime. Finding optimal configurations and configuration options that influence performance is already difficult, but in the light of software evolution, configuration-dependent performance changes may lurk in a potentially large number of different versions of the system. Building on previous work, we combine two perspectives---variability and time---and devise an approach to identify configuration-dependent performance changes retrospectively across the software variants and versions of a software system. In a nutshell, we iteratively sample pairs of configurations and versions and measure the respective performance, which we use to actively learn a model that estimates how likely a commit introduces a performance change. For such commits, we infer the configuration options that best explain observed performance changes. Pursuing a search strategy to measure selectively and incrementally further pairs, we increase the accuracy of identified change points related to configuration options and interactions. Our evaluation with both real-world software systems and synthesized data demonstrates that we can pinpoint performance shifts to individual configuration options and commits with high accuracy and at scale.
  • Konferenzbeitrag
    Reasoning about Product-Line Evolution using Complex Feature Model Differences
    (Software Engineering 2017, 2017) Bürdek, Johannes; Kehrer, Timo; Lochau, Malte; Reuling, Dennis; Kelter, Udo; Schürr, Andy
    In this work, we report about research results on the Reasoning about Product-Line Evo- lution using Complex Feature Model Differences, published in [Bu ̈15]. A (software) product-line constitutes a long-term investment and, therefore, has to undergo continuous evolution to meet con- stantly changing requirements. Initially, product-line evolution leads to changes of the variability model, typically a feature model, due to its central role in the product-line paradigm. Thus, product- line engineers are often faced with the problems that (1) feature models are changed ad-hoc without proper documentation, and (2) the semantic impact of changes is unclear. We propose a comprehen- sive approach to tackle both challenges. For (1), our approach compares the old and new version of the diagram representation of a feature model and specifies the changes using edit operations on feature diagrams. For (2), we propose a novel approach for reasoning about the semantic impact of diagram changes. We present a set of edit operations on feature diagrams, where complex operations are primarily derived from evolution scenarios observed in a real-world case study. We demonstrate the applicability of our approach with respect to the case study, and evaluate its scalability concern- ing experimental data sets.