The variability of product lines can exceed purely Boolean configuration spaces. Cardinality-based Feature Models (CFMs) are employed to model multi-instantiation of features along with individually configurable subtrees. Due to the added complexity, the analysis of CFMs cannot be done with state-of-the-art, SAT-based tooling for analyzing Boolean Feature Models (FMs). Analyses on FMs include checking for satisfying configurations, dead features, false optional features, and whether specific configurations are valid according to the FM. In this work, we compare different solver encodings to enable analysis for CFMs. First, we generalize the analyses on Boolean FMs to the notion of cardinalities and the new anomalies that can occur. Second, we present three different mathematical encodings of CFMs for automated reasoning using solvers. Third, we implement the encoding for ILP, SMT, and CSP solvers. We evaluate the feasibility and performance of our encodings on current ILP, SMT, and CSP solvers. Our evaluation shows that our encoding for CSP solvers enables all common analyses with the best performance among the compared encodings and solvers.

Feature modelling is a cornerstone of software product line engineering, providing a means to represent software variability through features and their relationships. Since its inception in 1990, feature modelling has evolved through various extensions, and after three decades of development, there is a growing consensus on the need for a standardised feature modelling language. Despite multiple endeavours to standardise variability modelling and the creation of various textual languages, researchers and practitioners continue to use their own approaches, impeding effective model sharing. In 2018, a collaborative initiative was launched by a group of researchers to develop a novel textual language for representing feature models. This paper introduces the outcome of this effort: the Universal Variability Language ( UVL ), which is designed to be human-readable and serves as a pivot language for diverse software engineering tools. The development of UVL drew upon community feedback and leveraged established literature in the field of variability modelling. The language is structured into three levels – Boolean, Arithmetic, and Type – and allows for language extensions to introduce additional constructs enhancing its expressiveness. UVL is integrated into various existing software tools, such as FeatureIDE and flamapy, and is maintained by a consortium of institutions. All tools that support the language are released in an open-source format, complemented by dedicated parser implementations for Python and Java. Beyond academia, UVL has found adoption within a range of institutions and companies. It is envisaged that UVL will become the language of choice in the future for a multitude of purposes, including knowledge sharing, educational instruction, and tool integration and interoperability. We envision UVL as a pivotal solution, addressing the limitations of prior attempts and fostering collaboration and innovation in the domain of software product line engineering.

Cyber-Physical Production Systems (CPPSs), such as automated car manufacturing plants, execute a configurable sequence of production steps to manufacture products from a product portfolio. In CPPS engineering, domain experts start with manually determining feasible production step sequences and resources based on implicit knowledge. This process is hard to reproduce and highly inefficient. In this paper, we present the Extended Iterative Process Sequence Exploration (eIPSE) approach to derive variability models for products, processes, and resources from a domain-specific description. To automate the integrated exploration and configuration process for a CPPS, we provide a toolchain which automatically reduces the configuration space and allows to generate CPPS artifacts, such as control code for resources. We evaluate the approach with four real-world use cases, including the generation of control code artifacts, and an observational user study to collect feedback from engineers with different backgrounds. The results confirm the usefulness of the eIPSE approach and accompanying prototype to straightforwardly configure a desired CPPS.

Engineering Cyber-Physical Production Systems (CPPSs) heavily relies on Domain-Specific Languages (DSLs), which are tailored to a specific class of problems inherent to CPPSs. DSLs enable non-programming experts to solve problems in their domain, such as modeling production processes, implementing control software, or managing the variability of production systems. A DSL ecosystem encompasses the entire infrastructure (e.g., libraries and tools) built around its language and contributes to the successful and easy adoption thereof by domain experts. We present a maturity evaluation model for DSL ecosystems serving two aims: to developers, it reveals missing but essential aspects of the ecosystem, and users (e.g., industrial companies) can evaluate the maturity of a DSL ecosystem. We propose criteria to evaluate the maturity of DSL ecosystems and apply them to existing, publicly available DSLs which have been adopted in CPPSs. The results demonstrate that all components of the model are covered and they allow for deriving hypotheses about DSL ecosystems used in CPPSs.

Cyber-Physical Production Systems (CPPSs) are envisioned as next-generation adaptive production systems combining modern production techniques with the latest information technology. A CPPS creates a complex environment between different domains (mechanical, electrical, software engineering), requiring multidisciplinary solutions to tackle growing complexity issues and reduce (maintenance) effort. Software plays an increasingly important role in assuring an effective and efficient operation of CPPSs. However, software engineering methods applied for CPPSs seem to lag behind modern software engineering methods, where tremendous progress has been made in the last years. We initiated the Software Engineering in Cyber-Physical Production Systems Workshop (SECPPS-WS) to analyze and overcome this gap. After two instances with mostly academic participants, we conducted a full-day workshop with nine industry representatives from eight companies that develop and maintain CPPSs. Each industry representative presented their current work and challenges. We collected these challenges and condensed a categorized list of challenges backed by industry statements and literature. This paper presents the resulting list and pointers to (partial) solutions to offer guidance for academia and identify promising research opportunities in this area.

In software product line engineering, engineers and researchers use variability models to explicitly represent the commonalities and variability of software systems to foster systematic reuse. Variability modeling has been a field of extensive research for over three decades, including Systematic Literature Reviews (SLRs) and Systematic Mapping Studies (SMSs) to categorize and compare different approaches. Much effort goes into such (secondary) studies, partly because they are often done from scratch and searching for relevant studies for specific research questions is tedious. Systematic reuse of search results would benefit the community by improving the efficiency and quality of such studies. In this paper, we report on creating a curated data set of 78 key SLR/SMS publications and primary studies (e.g., surveys) on variability modeling by conducting a tertiary SMS on variability modeling. When using such a curated paper data set for a secondary study, we estimate researchers can save up to 50 percent effort in the search phase. We present the publicly available data set, which includes categorization of the studies and provides update mechanisms. We see our data set as a foundation for building a Variability Modeling Body of Knowledge (VMBoK). We illustrate the efficient use of the data set in two SLR examples. We argue that our process and the data set can be useful for various research communities to improve the efficiency and quality of secondary (and tertiary) studies.

A plethora of variability modeling approaches has been developed in the last 30 years. Feature modeling and decision modeling became the most common and well-known groups of variability modeling approaches. Even within these groups, however, there are many different variants of approaches. Also, there are many other approaches such as Orthogonal Variability Modeling, UML-based variability modeling, and many more. Despite past and ongoing efforts, there is no standard variability modeling approach the community can agree on. Many approaches have been developed for a certain purpose and have been demonstrated to be useful for at least that purpose, e.g., domain analysis or automated derivation and configuration of products from a software product line. Still, industry frequently develops their own custom variability management solutions. In this short paper, we discuss our first ideas towards developing a framework for variability model transformations. It would allow researchers and practitioners to experiment with and compare different approaches and tools and switch from one approach or tool to another. We demonstrate the basic feasibility of our idea by transforming a feature model into a decision model. We conclude with a research agenda regarding variability model transformations.

Feature models are a de facto standard for representing the commonalities and variability of product lines and configurable software systems. Requirements-level features are commonly implemented in multiple source code artifacts, which results in complex dependencies at the code level. As developers change and evolve features frequently, it is challenging to keep feature models consistent with their implementation. We thus present an approach combining feature-to-code mappings and code dependency analyses to inform engineers about possible inconsistencies. Our focus is on code-level changes requiring updates in feature dependencies and constraints. Our approach uses static code analysis and a variation control system to lift complex code-level dependencies to feature models. We present the suggested dependencies to the engineer in two ways: directly as links between features in a feature model and as a heatmap visualizing the dependency changes of all features in a model. We present results of an evaluation on the Pick-and-Place Unit system, which demonstrates the utility and performance of our approach and the quality of the suggestions.