The integration of digital twins, i.e., virtual replicas of physical systems, is increasingly transforming manufacturing by enhancing efficiency through real-time monitoring, simulation, and optimization. The 3D-visualization of their data as a core functionality of xR applications (e.g., Virtual Reality) extends their usefulness and can be used as an important tool for teaching, training, and support. However, in addition to already known and well-discussed challenges (e.g., data representation), developing digital twin-assisted xR applications poses various variability challenges due to the complexity of manufacturing processes, data models, and the need for configurability across various scenarios and platforms. In this paper, we share our experiences in developing such applications, focusing on the gap of handling variability. Based on the DigiLehR research project, which also includes three industrial use cases as configurable products of an xR application family, we describe challenges we faced during development and essential lessons learned. Here, we particularly focus on platform specifics, immersion and interaction, digital twin-related data fragmentation, accessibility, and security. Overall, our work aims to create awareness for practitioners and researchers about the challenges of developing digital twin-assisted xR applications and their configurations, encouraging discussions on their efficient application in industrial settings.
Software product line engineering (SPLE) enables systematic reuse in developing various products within specific domains. Several approaches have been proposed to support SPLE implementation. In this paper, we report our experiences using delta-oriented programming (DOP) to implement a payment gateway product line. The implementation has specific challenges because the services of payment gateway are provided by many vendors. Even though they offer similar core services, each vendor often has distinct characteristics that must be accommodated in the product line application. The core services are modeled as similar features in the feature model, but each vendor's implementation might differ. Therefore, the feature selection must address vendor-specific configurations, requiring a multi-level configuration. This paper discusses the challenges and proposes solutions for achieving a multi-level configuration in the payment gateway domain. We also implement the solution as a tool support to enhance flexibility and promote applicability across other domains.
Uniform random sampling (URS) has many applications in configurable systems analysis. Usually, feature models consisting of a hierarchical feature diagram and additional side constraints specify the space of valid configurations to be sampled from. However, URS has predominately been applied on feature models translated a priori into conjunctive normal form (CNF). In this work, we study URS approaches that instead operate directly on feature diagrams and provide a comparative evaluation of their performance against well-established URS tools for CNF representations. Our findings suggest that translating feature models to CNF offers advantages, even in the presence of only few side constraints.
Behavioral Programming is a paradigm that aims to enable incremental development by utilizing scenarios and use cases for actual software development. The overall behavior is formed by the composition of individual threads (b-threads) that run concurrently with each other and use an event-based mechanism to communicate and effect the system's state. However, with a rising number of threads, it gets progressively harder to comprehend state changes and system architecture, making design decisions more difficult. This holds in particular for context-aware programs, i.e., systems that need to react to contextual changes. In this paper, we propose the idea of employing feature modeling techniques from variability management to achieve an architectural representation of context-aware behavioral programs, enabling us to model the relations between behavioral threads and facilitating techniques from context-aware variability management. We illustrate multiple potential advantages and apply the approach to two examples from literature.
Cloud-based software systems offer numerous configuration options which significantly increase the complexity of variability management. The TOSCA DSL has been defined to reduce the reliance on specific vendors and to enhance the interoperability across different cloud services. This approach, however, does not support systematic variability management. Our paper thus introduces an approach addressing the challenges of supporting different types of configurations across different binding times in cloud-based systems. Specifically, by employing TOSCA's vendor-neutral definition language, our approach standardizes and simplifies the management of cloud configurations. We evaluate the correctness and performance of our approach for different configuration dimensions based on a cloud-based voting application. Our approach can improve the flexibility and efficiency of managing cloud environments, which is essential for robust and effective cloud operations.
With ever evolving software, reliability and quality assurance are facing growing complexity and security issues. Particularly, interconnected and configurable systems are threatened by (mis)configurations that can lead to exploitable vulnerabilities. Unfortunately, there is limited information on how such configuration vulnerabilities occur or how practitioners deal with these. To tackle this gap, we investigated the connections between (mis)configurations, vulnerabilities, and their treatment by conducting a survey with 41 security practitioners who have encountered configuration vulnerabilities in their work. More precisely, our objectives were to understand the causes, prevalence, severity, and treatments of such vulnerabilities. We found that configuration vulnerabilities are prevalent and severe in practice. They primarily stem from dependency issues, outdated software, and inconsistent (cross-)configurations; are typically influenced by human errors; and are either identified during testing or, in the worst case, during deployment and operation. Generally, configuration vulnerabilities are detected due to security incidents or through word-of-mouth, implying that more preventive security management is required-ideally at an early stage and as part of a holistic security-engineering process. Overall, we aim to enhance the understanding of researchers and practitioners regarding current practices related to handling configuration vulnerabilities as well as open challenges.
Feature model (FM) configuration can be supported on the basis of different reasoning approaches such as SAT solving, constraint solving, and answer set programming (ASP). To better understand the reasons of including or excluding specific features, feature model configurations (or parts thereof) need to be explained to the user. In this paper, we introduce an algorithmic approach to determine minimal causality-based explanations which refer to those customer requirements and constraints directly responsible for a feature model configuration. This approach helps to create more transparency and understandability of feature model configuration by determining those attributes and constraints directly responsible for a specific configuration result.
Industrial real-time embedded software is usually developed over decades in heterogeneous, multi-disciplinary development teams, inducing major maintenance effort. In addition to a maintenance strategy, increasing variability of products requires a dedicated strategy for the variability management between products and product families. Software product lines (SPLs) provide a proven methodology to address the variability management. Despite the existence of various tools for SPL engineering, none of existing tool kits was matching our requirements especially regarding hierarchical build system based on SCons. We present a variability analysis toolkit which seamlessly integrates with SCons build system, provides a simple integration with CI/CD pipeline, and an option to graphically explore the structure of build system artifacts. Our toolkit automatically calculates key performance indicators for single and multiple product variant graphs. It also provides cluster analysis to find similarities and differences between different product variants. Our initial findings show the acceptance of our Python-based toolkit by the development teams as well as the ability to automatically detect common and variant-specific feature clusters which are useful for further improvement and maintenance of the whole software product line towards an SPL-aware build system.
Feature modeling is widely used to represent variability in software systems, but as feature models grow in size and complexity, manual analysis becomes infeasible. Automated Analysis of Feature Models (AAFM) is a set of tools and algorithms that enable the computeraided analysis of such models. Recently, the AAFM community has made an effort to enable the interoperability of tools by means of the UVL language, however, most of the supporting tools need to execute the operations in a server. This have two main drawbacks, first it requires users to upload the model to remote servers, imposing security concerns and second, limits the complexity of the operations that an online tool can offer. In this paper, we introduce flamapy.ide, an integrated development environment (IDE) based on the flamapy framework, and designed to perform AAFM directly within the browser by relying on WASM technologies. flamapy.ide provides SAT and BDD solvers for efficient feature model analysis and offers support for handling UVL files. Also, enables the configuration and visualization of such models relying on a fully client-side approach. This tool brings AAFM capabilities to web-based platforms, eliminating the need for server-side computation while ensuring ease of use and accessibility.
Variation control systems (VarCS) like ECCO or SuperMod provide capabilities for uniformly handling revisions and variants of software systems based on features, in that regard going beyond the capabilities of existing version control systems like Git. However, existing VarCSs have not been designed to be provided as a service, which limits their integration in web-based engineering environments and tool pipelines. In this paper, we present Software-as-aService (SaaS) extensions for the VarCS ECCO, which also include a REST API to facilitate its integration in different engineering processes. We present ECCO's SaaS architecture and explain its services for managing repositories, as well as local and distributed operations for feature-based development. We demonstrate the ECCO service by showing its integration with ECCOHub, a webbased platform for working with ECCO, as well as ECCO's CI/CD pipeline.
The configuration process for feature-oriented product lines is wellresearched for Boolean and numerical feature configurations. However, in several engineering fields, we encounter the challenge of finding the optimal graph structure to describe a product configuration. Optimising complex graph structures towards multiple objectives within numerous constraints requires a deep understanding of the graph configuration space and the product properties it represents. This study aims to leverage graph neural networks (GNNs) to predict product properties, thereby supporting the configuration process in product lines. In a controlled experiment, we compare a GNN-based approach to a recent state-of-the-art approach utilising graph embeddings. We evaluate these methods on both accuracy and learning efficiency. Our findings indicate that the GNN-based approach outperforms the embedding-based method in terms of accuracy. However, it requires a substantially larger volume of training data to achieve these results. Overall, this research demonstrates the applicability of an ML-supported framework for engineering product lines using graph configurations.
The Universal Variability Language (UVL) was developed as a community-driven effort to create a simple yet extensible language for feature modeling, promoting tool interoperability within the software product line community. Although UVL is supported by several tools like FeatureIDE, Flamapy, and Pure::variants, it currently lacks direct support for web environments. To address this, we introduce a JavaScript-based UVL parser built with the ANTLR framework. This parser makes UVL models accessible directly within browser-based environments, eliminating the need for extra installations and enhancing UVL's usability for web-based tools. Furthermore, the parser can be used in back-end environments with JavaScript runtime environments such as Node.js. The parser has been successfully tested with more than 1,000 UVL models available on UVLHub and supports various UVL language levels and conversion strategies. We demonstrate its integration through two use cases: UVLHub, a public repository for UVL models developed using open science principles, and an application lifecycle management tool for software product lines. This JavaScript UVL parser is the first of its kind, unlocking new possibilities for web and JavaScript applications to take advantage of the advancements in UVL technology.
Scheduling problems constitute a widely considered class of optimization problems with many important practical applications. To solve a scheduling problem, we have to find an assignment of a given set of computational tasks (jobs) to a restricted number of resources (machines) such that all tasks are finished before their deadlines and the overall amount of time is minimal. The frequently considered class of Job-Shop Scheduling Problems (JSSP) is NP-hard and therefore not efficiently solvable for real-world problems. To tackle this issue, many heuristic approaches have been developed for approximating near-optimal solutions. These approaches usually require as input one single JSSP instance with precise knowledge about task execution times and other properties to be fixed in advance. However, many scheduling problems occurring in practice contain not-yet resolved variability (e.g., intervals of possible execution times). The corresponding family of problem instances is not tractable by most recent solution heuristics. To tackle this challenge, we propose to apply established variability modeling and analysis techniques to formally specify configurable scheduling problems. We use feature models to describe the variability within a given JSSP and we describe an encoding into a constraint linear program. This encoding allows us to apply recent CP-SAT solvers to automatically reason about satisfiability and to find optimal solutions for families of JSSP in a single run. Our experimental evaluation shows promising efficiency improvements in comparison to an instance-by-instance solution strategy.
The SOTIF-standard (ISO 21448) requires scenario-based testing to verify and validate advanced driver assistance systems and automated driving systems. Feature modeling and sampling have shown promising results for generating scenarios considered test cases for scenario-based testing. Sampling strategies commonly applied for generating scenarios pursue coverage-criteria such as t-wise feature interaction, but ignore the number of selected features in a valid configuration. In the context of scenario generation, the number of features in a configuration correlates to the complexity of a scenario; thus, considering the number of features is relevant for "sufficiently" covering the scenario space and generating SOTIF-compliant scenarios. In this paper, we propose a complexity-aware coverage criterion embedded in selective sampling as a complexity-aware sampling strategy. Selective sampling approximates and replicates the distribution of the number of selected features of valid configurations. We apply selective sampling to generate scenarios for testing two advanced driver assistance systems. Our experiments demonstrate that selective sampling has the potential to improve scenario generation.
Teaching software product lines to university students is key in disseminating knowledge about software variability. In particular, education is needed to train new researchers and practitioners and, thus, sustain further research on software product lines. However, preparing appropriate teaching material is difficult and time-consuming, even when relying on existing literature. Thus, clone-and-own is a common practice among educators, with all its associated issues. Moreover, there is a lack of full-semester, open courses on software product lines. In this paper, we report on our experience of architecting and designing such a course from scratch, avoiding clone-and-own entirely. In addition, we perform a literature review of influential books on software product lines and which topics they cover. We position our course in terms of these topics, discuss how it compares to existing courses, and justify relevant design decisions. With our course, we aim to strengthen the positive interactions between research, industry, and education. So far, our course has already been held seven times across five universities. A preliminary evaluation of our course indicates that our course is mostly well-received by students.
A product line's features describe its configurable functional properties by means of boolean feature toggles or numeric values. Meanwhile, performance models describe the link between features and non-functional product line properties such as binary size, memory usage, or workload latency. So far, these have focused on static features: model formalisms and learning algorithms assume that the product cannot be reconfigured at runtime and that there is no interaction between features, runtime behaviour, and runtime performance attributes. This is inadequate for real-world configurable software systems: compile-time features may be reconfigured at runtime (e.g. by overriding defaults), and non-featured workload attributes may affect performance attributes and thus must be considered within performance models. We propose performanceaware behaviour models to address this challenge. These build upon existing work on behaviour models and dynamic product lines, and link feature models (static configuration), behaviour models (variable workloads), non-featured runtime variability, and performance models in order to allow engineers to determine arbitrary configuration- and workload-dependent performance attributes of product lines. They are compatible with existing modeling methods and support workload-dependent performance attributes that cannot be expressed as a function of product features alone. We demonstrate the benefits of performance-aware behaviour models in three case studies, and show that they reduce performance prediction error by up to 90 %.
The Linux kernel and its huge configuration space (>15,000 features) has been a frequent study object. While the research community has developed intelligent software configuration tools, often motivated by the Linux kernel and its configuration language Kconfig, the kernel's own configurator xconfig lacks behind. Configuration conflicts need to be resolved manually, which often causes substantial overhead. Unfortunately, Kconfig is a complex and intricate language, and while transformations into propositional logic exist, they typically have shortcomings and are difficult to integrate into xconfig. We contribute research results back to the Linux community and present a demo of ConfigFix. It is a plain-C-based extension of xconfig, providing the currently most accurate abstraction of the Kconfig semantics into propositional logic. It provides configuration conflict resolution. Integrated into the xconfig UI, it offers configuration fixes to users trying to enable or disable kernel features restricted by dependencies. In addition, researchers benefit from the DIMACS export. Our demo presents the main capabilities of xconfig as well as its evaluation showing the accuracy of it.
Software product lines are a common way to develop individually configurable products. In practice, already deployed products have to undergo frequent changes throughout the whole life-cycle due to unavoidable updates (e.g., to close critical vulnerabilities). Such software updates require additional testing effort to reduce the risk of unwanted behavior of deployed functionality. However, existing sampling techniques are ignorant of deployed configurations coming from different points in a system's evolution. Furthermore, available techniques aim to cover all configurations instead of focussing on deployed configurations. Exploiting this knowledge can help to improve efficiency and effectiveness of sample-based quality assurance of product updates. To address this gap, we introduce a new sampling technique that guarantees coverage of all t-wise interactions on a given set of deployed configurations (i.e., field configurations). As our evaluation shows, state-of-the-art sampling approaches that do no exploit this additional knowledge are not able to cover all of these interactions. Incorporating knowledge about field configurations improves the effectiveness of testing while ensuring full coverage of interactions in deployed products.
Feature models are the de-facto standard in product line engineering to capture the commonalities and variability of systems. However, feature models provide little user guidance during configuration and are unable to represent configuration sequences. A configuration sequence refers to the specific order and combination of features that can be selected when configuring a product line. While mechanisms, such as staged configuration and configuration workflows, exist, we argue that the effort to implement these mechanisms does not pay off for small feature models. This paper motivates the use of configuration sequences for feature models to support better user guidance even for a single feature model. We highlight the need for such user guidance and configuration sequences with a real-world use case.
