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.

Components based on Machine Learning (ML) are important for many product lines in the industry today, strongly impacting engineering processes. In particular, engineers need to manage the variability of ML-enabled features in product lines, while at the same time dealing with their continuous evolution, integration, and deployment. MLOps approaches improve the maturity of processes and tools for engineering ML-enabled systems, however, they lack support for feature-based version control, which is essential for product lines. This paper presents an approach providing feature-based versioning for ML-enabled product lines based on the Variation Control System (VarCS) ECCO. Specifically, we present use cases and requirements based on a common MLOps process. We extend ECCO to support Python code and Jupyter Notebooks, two widely used types of artifacts in this domain. We evaluate our approach regarding correctness and performance: the evaluation confirms the extensional correctness of our approach and shows acceptable quality of the intensional checkouts for valid product configurations. Furthermore, the performance is adequate for the investigated use cases.

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.

As Cyber-Physical Systems (CPS) become more prevalent in a wide variety of domains, they are increasingly enriched with digital intelligence. Consequently, the role of humans, as well as their interplay with automation, have become important facets of CPS development, which has driven research in Human-Machine Interaction and Teaming. As technology and possible interaction patterns continuously evolve, requirements and system design become moving targets. This makes it challenging to manage complexity, unless the right degree of abstraction is found. Stakeholders involved in development may also easily lose track of the different perspectives on future CPS-supported work realities. Therefore, in this paper, we present a structured design process, using adaptable models to capture role-specific behaviors, communication, and interaction details. Our approach aims to guide stakeholders and establish a traceable engineering process with transparent and informed decisions. We propose a model-based framework for exploring Human-Machine Teaming requirements in the context of CPS. Our layered methodology encompasses defining the system scope, exploring automation scenario variants, detailing functional requirements, and finding an early candidate design. It enables continuous stakeholder control of a CPS development process based on Human-Machine Teaming requirements. A first demonstration and evaluation show its feasibility and applicability in a real-world context.

Cyber-Physical Systems (CPS) are increasingly becoming part of organizations' digitalization efforts in many different domains. CPS are characterized by their heterogeneity and complexity, thus requiring the involvement of various experts throughout development. Digital Twins (DTs) were found to facilitate the acquisition of such technical knowledge required for effective designs. In particular, we pose that process-oriented model representations can help to account for various concerns (e.g.: privacy and security) across CPS components in a human-centered way, thereby enabling the active participation of relevant actors in requirements elicitation and design exploration. Our human-centered approach uses Digital Process Twins (DPTs) for eliciting and refining requirements for CPS design, and for supporting agile CPS development. Our ongoing project follows the design science method. We demonstrate results of the first design cycle and provide an example illustrating the modeling part of our methodology.

This paper discusses the management of revisions and variants of musical works for the context of musicological research. Domain-specific languages (DSLs) are a fundamental tool in music notation and analysis, as they enable the notation of music and also support music analysis when investigating particular structural properties of melody, harmony, rhythm, or form. However, the fields of music philology and music analysis still lack a systematic approach for uniformly managing revisions and variants of musical compositions. This research-in-progress paper proposes the use of feature-based versioning to streamline the management of revisions and variants in music artifacts. We introduce an illustrative example and present research challenges regarding variability and feature-based versioning for musicological research. We present a preliminary approach which involves mapping features to specific parts of musical works and musical analyses, thereby facilitating the composition of new variants based on selected features, a prerequisite for enhanced research in music philology and music analysis.

Products and production are inherently variable. That is, the products themselves often need to be variable-as in a car plant producing many similar, albeit not identical cars. Such flexibility allows a product to be more easily customizable. We speak of variable products. At the same time, production systems typically need to be flexible in supporting the production of different products. Such flexibility allows for a broader use of production systems, supports lower production volumes while remaining economical, or optimizes production resources to avoid delays. We speak of variable production. This chapter explores variability in products and variability during production where product variability needs to be understood together with its implications on production. Special considerations are products that are consequently used during production and the issue of hardware/software variability, which is mostly handled separately today. We provide examples from an injection molding machine and also discuss open research challenges.

Music engravers nowadays use music notation software to create scores for musical works. As is common in any creative process, many different versions of digital artifacts are created-e.g., to manage editions of the same musical work, editorial markups, or the history and genesis of compositions. In the field of software engineering, researchers have proposed the use of features, i.e., user-visible aspects of systems, to manage both revisions and variants of source code and other software artifacts. Feature-based version control systems establish and maintain feature-to-code mappings defining which parts of the artifacts realize particular features, e.g., which code implements a specific function. These mappings can then be used to generate new variants based on the artifacts by selecting the desired features. Our article provides an in-depth study on feature-based version control for music notation. Our automated approach adopts the domain-specific language (DSL) LilyPond and the feature-oriented version control system ECCO. Existing studies show that features in musical scores are often fine-grained and affect only small parts of an artifact, are scattered across noncontiguous locations in the artifact, and highly interact with each other. Such properties have strong implications for the usefulness of versioning tools. Our experiment investigates two factors related to the correctness of output from feature-based version control systems when used for symbolic music notation. We demonstrate the incremental refinement of feature-to-artifact mappings when committing DSL code. We further study the impact of the order of feature interactions on the correctness of the automatically generated music artifacts. We find that a larger feature interaction threshold produces only marginally more correct results, but fixing and recommitting incorrect variants has a more powerful effect. Our results further show that considering DSL specifics is important for versioning fine-grained and scattered features.

Preprocessor-based software product lines (SPLs) are used to deal with evolution in space, in which features (so-called configuration options)—annotated in source code with #ifdefs—are included, removed, and systematically reused. Inevitably, feature implementations also evolve over time, i.e., when existing features are revised. Nowadays, Version control systems (VCSs) are well-integrated into SPL development processes for versioning support of releases. Changes to existing features in one version, a.k.a. release of an SPL, usually developed in a branch, frequently need to be propagated to other active releases. However, there is no automated support for analyzing and propagating features in SPL releases. For instance, VCSs can only propagate changes at the commit level, but miss support at the feature level, i.e., the building blocks of SPLs. Manually analyzing and propagating a version of a feature, i.e., a feature revision, through #ifdefs is risky, time-consuming, and error-prone because a feature can be interacting with multiple features and it can be spread in multiple blocks of code across different files. We thus present a novel and tool-supported approach for the analysis and propagation of feature revisions. We evaluated our approach quantitatively by computing its correct behavior and runtime. Our approach analyzes and propagates a feature implementation in ≈63 seconds, with, on average, precision and recall of 99%. In total, we propagated 3,134 features in space and time between 200 pairs of releases on four real-world preprocessor-based SPLs. In addition, we qualitatively evaluated the usefulness of our tool support by conducting interviews with five experienced core developers of three popular preprocessor-based SPLs. The qualitative results confirm that our tool support is useful to speed up the analysis and propagation of feature revisions.

Domain-specific languages (DSLs) offer expressive support for particular problem domains and promise substantial gains compared to general-purpose languages (GPLs). Variability management techniques have been successfully and widely applied in software development for GPLs. This paper describes an exploratory study on using variability management in the context of DSLs for digital publishing. Specifically, the paper presents a digital publishing workflow complementing a music engraving DSL to automatically create musical scores for diverse mobile devices. The paper illustrates variability challenges and shows how the approach links different variability mechanisms in a fully-automated workflow. The evaluation based on an archive of 141 digital music artifacts shows that 98,3% of all pages were correctly rendered. Further, the performance results show a strong correlation of the input size with the engraving time regardless of the kind of device. The paper discusses lessons learned and outlines opportunities for further research.

When evolving software product lines, new features are added over time and existing features are revised. Engineers also decide to merge different features or split features in other cases. Such refactoring tasks are difficult when using manually maintained feature-to-code mappings. Intensional version control systems such as ECCO overcome this issue with automatically computed feature-to-code mappings. Furthermore, they allow creating variants that have not been explicitly committed before. However, such systems are still rarely used compared to extensional version control systems like Git, which keep track of the evolution history by assigning revisions to states of a system. This paper presents an approach combining both extensional and intensional version control systems, which relies on the extensional version control system Git to store versions. Developers selectively tag existing versions to describe the evolution at the level of features. Our approach then automatically replays the evolution history to create a repository of the intensional variation control system ECCO. The approach contributes to research on refactoring features of existing product lines and migrating existing systems to product lines. We provide an initial evaluation of the approach regarding correctness and performance based on an existing system.

Software companies commonly develop and maintain variants of systems, with different feature combinations for different customers. Thus, they must cope with variability in space. Software companies further must cope with variability in time, when updating system variants by revising existing software features. Inevitably, variants evolve orthogonally along these two dimensions, resulting in challenges for software maintenance. Our work addresses this challenge with ECSEST (Extraction and Composition for Systems Evolving in Space and Time), an approach for locating feature revisions and composing variants with different feature revisions. We evaluated ECSEST using feature revisions and variants from six highly configurable open source systems. To assess the correctness of our approach, we compared the artifacts of input variants with the artifacts from the corresponding composed variants based on the implementation of the extracted features. The extracted traces allowed composing variants with 99-100% precision, as well as with 97-99% average recall. Regarding the composition of variants with new configurations, our approach can combine different feature revisions with 99% precision and recall on average. Additionally, our approach retrieves hints when composing new configurations, which are useful to find artifacts that may have to be added or removed for completing a product. The hints help to understand possible feature interactions or dependencies. The average time to locate feature revisions ranged from 25 to 250 seconds, whereas the average time for composing a variant was 18 seconds. Therefore, our experiments demonstrate that ECSEST is feasible and effective.

Welcome to this special issue that includes empirical studies on configurable systems. This special issue in the Empirical Software Engineering journal is intended to provide the systems and software product lines community with a valuable collection of high-quality research articles that explore configurable systems with empirical studies. Particular attention was paid to research and industrial work carrying out experiments on configuration steps in the life cycle of system and software product lines. A configurable system is an artifact composed from instances of a set of predefined component types that can be composed and parameterized. The configuration step requires knowledge representation formalisms to capture variety and complexity of configurable products, but also acquisition methods and efficient reasoning algorithms for supporting solution search, to represent, and integrate user settings, personalization, and optimization. The configuration ends with the deployment and launches execution steps. This configuration can also change over time, because of a change of context. This is called reconfiguration. The majority of articles extend research presented at SPLC, the 23rd International Systems and Software Product Lines Conference. The conference was held from September 9 to 13, 2019 in Paris, France [1]. We received seventeen articles for this special issue. The call was open, but the SPLC 2019 authors were encouraged to prepare a revised and substantially extended version, and to consider as possible extensions additional practical applications determined by case studies or experiences, empirical validations, systematic comparisons with other approaches, or sound theoretical foundations. The submitted manuscripts were each peer reviewed by three reviewers. Finally, ten papers were accepted for inclusion in this special issue and six of them were extended versions of the SPLC 2019 research papers.

Feature annotation based on preprocessor directives is the most common mechanism in Highly-Configurable Software Systems (HCSSs) to manage variability. However, it is challenging to understand, maintain, and evolve feature fragments guarded by #ifdef directives. Yet, despite HCSSs being implemented in Version Control Systems, the support for evolving features in space and time is still limited. To extend the knowledge on this topic, we analyze the feature life cycle in space and time. Specifically, we introduce an automated mining approach and apply it to four HCSSs, analyzing commits of their entire development life cycle (13 to 20 years and 37,500 commits). This goes beyond existing studies, which investigated only differences between specific releases or entire systems. Our results show that features undergo frequent changes, often with substantial modifications of their code. The findings of our empirical analyses stress the need for better support of system evolution in space and time at the level of features. In addition to these analyses, we contribute an automated mining approach for the analysis of system evolution at the level of features. Furthermore, we also make available our dataset to foster new studies on feature evolution in HCSSs.

Companies need to collect and analyze time series data to continuously monitor the behavior of software systems during operation, which can in turn be used for performance monitoring, anomaly detection or identifying problems after system crashes. However, gaining insights into common data patterns in time series is challenging, in particular, when analyzing data concerning different properties and from multiple systems. Clustering approaches have been hardly studied in the context of monitoring data, despite their possible benefits. In this paper, we present a feature-based approach to identify clusters in unlabeled infrastructure monitoring data collected from multiple independent software systems. We introduce time series properties which are grouped into feature sets and combine them with various unsupervised machine learning models to find the methods best suited for our clustering goal. We thoroughly evaluate our approach using two large-scale, industrial monitoring datasets. Finally, we apply one of the top-ranked methods to thousands of time series from hundreds of software systems, thereby showing the usefulness of our approach.

Software companies frequently customize and extend product lines in multiple projects concurrently to quickly deliver solutions to customers. Engineers use a distributed and feature-oriented development process, commonly supported by version control systems to track implementation-level changes. For instance, feature branches are widely used to add new or modify existing features. However, when merging back features to the product line, the information about feature-to-code mappings is usually lost. Furthermore, the granularity of merging is limited to branches, making it hard to extract and merge selected individual features from one product to another. This paper thus presents feature-oriented clone and pull operations for distributed development, which are implemented in the FORCE2 platform. Our evaluation uses variants of the ArgoUML product line to investigate the correctness and performance of our approach. The results show that the feature-oriented operations work with high precision and recall for different cases of feature interactions, also when feature implementations are scattered across many locations in the source code. The performance measurements demonstrate that the operations can be integrated in the typical workflows of engineers.

Software companies need to provide a large set of features satisfying functional and non-functional requirements of diverse customers, thereby leading to variability in space. Feature location techniques have been proposed to support software maintenance and evolution in space. However, so far only one feature location technique also analyses the evolution in time of system variants, which is required for feature enhancements and bug fixing. Specifically, existing tools for managing a set of systems over time do not offer proper support for keeping track of feature revisions, updating existing variants, and creating new product configurations based on feature revisions. This paper presents four challenges concerning such capabilities for feature (revision) location and composition of new product configurations based on feature/s (revisions). We also provide a benchmark containing a ground truth and support for computing metrics. We hope that this will motivate researchers to provide and evaluate tool-supported approaches aiming at managing systems evolving in space and time. Further, we do not limit the evaluation of techniques to only this benchmark: we introduce and provide instructions on how to use a benchmark extractor for generating ground truth data for other systems. We expect that the feature (revision) location techniques maximize information retrieval in terms of precision, recall, and F-score, while keeping execution time and memory consumption low.

This repository contains: - a dataset of system variants with feature revisions from six highly-configurable systems: Bison, Curl, Irssi, LibSSH, SQLite and Marlin - the results from our work, including a repository with traces mapping feature revisions to artifacts and variants composed with the traces for each system