Logo des Repositoriums

Auflistung nach Schlagwort "software product lines"

1 - 10 von 15
  • Konferenzbeitrag
    Classifying Edits to Variability in Source Code - Summary
    (Software Engineering 2023, 2023) Bittner, Paul Maximilian; Tinnes, Christof; Schultheiß, Alexander; Viegener, Sören; Kehrer, Timo; Thüm, Thomas
    We report about recent research on edit classification in configurable software, originally published at the 30th Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE) 2022 [Bi22]. For highly configurable software systems, such as the Linux kernel, maintaining and evolving variability information along changes to source code poses a major challenge. While source code itself may be edited, also feature-to-code mappings may be introduced, removed, or changed. In practice, such edits are often conducted ad-hoc and without proper documentation. To support the maintenance and evolution of variability, it is desirable to understand the impact of each edit on the variability. We propose the first complete and unambiguous classification of edits to variability in source code by means of a catalog of edit classes. This catalog is based on a scheme that can be used to build classifications that are complete and unambiguous by construction. To this end, we introduce a complete and sound model for edits to variability. In about 21.5 ms per commit, we validate the correctness, relevance, and suitability of our classification by classifying each edit in 1.7 million commits in the change histories of 44 open-source software systems automatically.
  • Konferenzbeitrag
    Comparing Multiple MATLAB/Simulink Models Using Static Connectivity Matrix Analysis
    (Software Engineering 2020, 2020) Schlie, Alexander; Schulze, Sandro; Schaefer, Ina
    Model-based languages such as MATLAB/Simulink are crucial for the development of embedded software systems. To adapt to changing requirements, engineers commonly copy and modify existing systems to create new variants. Denoted clone-and-own, this straightforward reuse strategy entails severe maintenance and consistency issues as redundant and similar assets proliferate. Software product lines can be a remedy but require all existing variants to be compared prior to their actual migration. However, current work mostly revolves around comparing only two systems and those approaches coping with more are not applicable to embedded software systems such as MATLAB/Simulink. We bridge this gap and propose Static Connectivity Matrix Analysis (SCMA), a novel comparison procedure that evaluates multiple MATLAB/Simulink model variants at once. We transfer models into matrix form and identify all similar structures between them, even with parts being completely relocated during clone-and-own. Moreover, we allow engineers to tailor results and to focus on any arbitrary variant subset, enabling individual reasoning prior to migration. We provide a feasibility study from the automotive domain, showing our matrix representation to be suitable and SCMA to be fast and precise.
  • Konferenzbeitrag
    Feature Modeling and Development with FeatureIDE
    (Modellierung 2018, 2018) Thüm, Thomas; Leich,Thomas; Krieter, Sebastian
    FeatureIDE is an open-source framework to model, develop, and analyze feature-oriented software product lines. It is mainly developed in a cooperation between TU Braunschweig, University of Magdeburg, and Metop GmbH. Nevertheless, many other institutions contributed to it in the past decade. Goal of this tutorial is to illustrate how FeatureIDE can be used to develop software around end-user features. We will show how feature models are connected to and synchronized with other artifacts. The hands-on tutorial will be highly interactive and is devoted to practitioners facing problems with variability, lecturers teaching product lines, and researchers who want to safe resources in building product-line tools.
  • Konferenzbeitrag
    Feature Trace Recording - Summary
    (Software Engineering 2022, 2022) Bittner, Paul Maximilian; Schultheiß, Alexander; Thüm, Thomas; Kehrer, Timo; Young, Jeffrey M.; Linsbauer, Lukas
    In this work, we report about recent research on Feature Trace Recording, originally published at the Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE) 2021. Tracing requirements to their implementation is crucial to all stakeholders of a software development process. When managing software variability, requirements are typically expressed in terms of features, a feature being a user-visible characteristic of the software. While feature traces are fully documented in software product lines, ad-hoc branching and forking, known as clone-and-own, is still the dominant way for developing multi-variant software systems in practice. Retroactive migration to product lines suffers from uncertainties and high effort because knowledge of feature traces must be recovered but is scattered across teams or even lost. We propose a semi-automated methodology for recording feature traces proactively, during software development when the necessary knowledge is present. To support the ongoing development of previously unmanaged clone-and-own projects, we explicitly deal with the absence of domain knowledge for both existing and new source code. We evaluate feature trace recording by replaying code edit patterns from the history of two real-world product lines. Our results show that feature trace recording reduces the manual effort to specify traces.
  • Konferenzbeitrag
    Intention-Based Integration of Software Variants
    (Software Engineering 2020, 2020) Lillack, Max; Stanciulescu, Stefan; Hedman, Wilhelm; Berger, Thorsten; Wasowski, Andrzej
    Cloning is a simple way to create new variants of a system. While cheap at first, it increases maintenance cost in the long term. Eventually, the cloned variants need to be integrated into a configurable platform. Such an integration is challenging: it involves merging the usual code improvements between the variants, and also integrating the variable code (features) into the platform. As such, variant integration differs from traditional software merging, which does not produce or organize configurable code, but creates a single system that cannot be configured into variants. In practice, variant integration requires fine-grained code edits, performed in an exploratory manner, in multiple iterations. Unfortunately, little tool support exists for integrating cloned variants. In this work, we show that fine-grained code edits needed for integration can be alleviated by a small set of integration intentions—domain-specific actions declared over code snippets controlling the integration. Developers can interactively explore the integration space by declaring (or revoking) intentions on code elements. We contribute the intentions (e.g., 'keep functionality' or 'keep as a configurable feature') and the IDE tool INCLINE, which implements the intentions and five editable views that visualize the integration process and allow declaring intentions producing a configurable integrated platform. In a series of experiments, we evaluated the completeness of the proposed intentions, the correctness and performance of INCLINE, and the benefits of using intentions for variant integration. The experiments show that INCLINE can handle complex integration tasks, that views help to navigate the code, and that it consistently reduces mistakes made by developers during variant integration.
  • Konferenzbeitrag
    Optimal Product Line Architectures for the Automotive Industry
    (Modellierung 2018, 2018) Wägemann, Tobias; Tavakoli Kolagari, Ramin; Schmid, Klaus
    The creation of product line architectures is a difficult and complex task. The resulting architectures must support the required system variabilities as well as further quality attributes. In the automotive domain, product lines of software-intensive system models have a great diversity of products, which leads to vast design spaces. Finding optimal product line architectures as part of the system design process requires the consideration of a variety of trade-offs. In practice, this challenge cannot be solved manually for all but the smallest problems, therefore an automated solution is required. Our contribution is the generation of a sound mathematical formalization of the problem. This formalization makes the product line optimization problem accessible to various established multi-objective optimization techniques. The applicability of the chosen approach is shown by means of applying a commercial tool for multi-criteria decision making.
  • Textdokument
    Performance is not Boolean: Supporting Scalar Configuration Variables in NFP Models
    (Tagungsband des FG-BS Frühjahrstreffens 2022, 2022) Friesel, Daniel; Spinczyk, Olaf
    Non-functional properties (NFPs) such as memory requirements, timing, or energy consumption are important characteristics of embedded software systems and software product lines (SPLs) in general. Both during system design and at runtime, the goal is to optimize resource utilization (and, thus, NFPs) by appropriate system configuration or orchestration. NFP models, learned from benchmarks of various SPL configurations, allow for the prediction of these properties, thus enabling NFP-aware software configuration and runtime decisions. However, many existing approaches for automated learning of NFP models limit their scope to boolean variables. We argue that this is no longer sufficient: NFP models must accommodate scalar variables to achieve suitable accuracy when faced with today’s highly configurable software systems and variable workloads. To this end, we evaluate four regression tree-based NFP modeling approaches on eight use cases, and examine model complexity and model accuracy. We find that models with support for scalar variables achieve up to three times lower mean model error when predicting configurations that were not part of the training set. At the same time, the complexity of scalar and boolean-only models is nearly the same; only benchmarking becomes more time-intensive due to the need to explore scalar variables. We conclude that scalar-enabled models provide increased accuracy almost free of charge, and recommend using them when generating NFP models for embedded systems and workloads with scalar configuration variables.
  • Konferenzbeitrag
    Principles of Feature Modeling
    (Software Engineering 2020, 2020) Nešić, Damir; Krüger, Jacob; Stănciulescu, Stefan; Berger, Thorsten
    This abstract summarizes our paper with the homonymous title published at the Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE) 2019.
  • Konferenzbeitrag
    Quantifying the Potential to Automate the Synchronization of Variants in Clone-and-Own - Summary
    (Software Engineering 2023, 2023) Schultheiß, Alexander; Bittner, Paul Maximilian; Thüm, Thomas; Kehrer, Timo
    We report about a recent empirical study on variant synchronization in clone-and-own, originally published at the 38th IEEE International Conference on Software Maintenance and Evolution (ICSME) 2022 [Sc22]. In clone-and-own, a new variant of a software system is created by copying and adapting an existing one. While it is flexible, clone-and-own causes high maintenance effort in the long run as cloned variants evolve in parallel; certain changes, such as bug fixes, need to be propagated between variants. A recent line of research proposes to automate such synchronization tasks when migration to a software product line is not feasible. However, it is yet unclear how far this synchronization can actually be pushed. We present an empirical study in which we quantify the potential to automate the synchronization of variants in clone-and-own. We simulate automated variant synchronization using the history of BusyBox, a real-world multi-variant software system. Our results indicate that existing patching techniques propagate changes with an accuracy of up to 85%, if applied consistently from the start of a project. This can be even further improved to 93% by exploiting lightweight domain knowledge about which features are affected by a change, and which variants implement affected features.
  • Konferenzbeitrag
    Scalable N-Way Model Matching Using Multi-Dimensional Search Trees - Summary
    (Software Engineering 2022, 2022) Schultheiß, Alexander; Bittner, Paul Maximilian; Thüm, Thomas; Kehrer, Timo
    In this work, we report about recent research on n-way model matching, originally published at the International Conference on Model Driven Engineering Languages and Systems (MODELS) 2021. Model matching algorithms are used to identify common elements in input models, which is a fundamental precondition for many software engineering tasks, such as merging software variants or views. If there are multiple input models, an n-way matching algorithm that simultaneously processes all models typically produces better results than the sequential application of two-way matching algorithms. However, existing algorithms for n-way matching do not scale well, as the computational effort grows fast in the number of models and their size. We propose a scalable n-way model matching algorithm, which uses multi-dimensional search trees for efficiently finding suitable match candidates through range queries. We implemented our generic algorithm named RaQuN (Range Queries on N input models) in Java, and empirically evaluate the matching quality and runtime performance on several datasets of different origin and model type. Compared to the state-of-the-art, our experimental results show a performance improvement by an order of magnitude, while delivering matching results of better quality.