Many things in the world share similarities, yet variations still exist. The same applies to software development, where commonalities and differences are present. In this regard, the productivity of software development can be improved by applying software product line engineering (SPLE). One challenge in applying SPLE is managing architectural variations in development and deployment, such as microservices. Microservices split an application into separately deployable services that may communicate internally. However, these internal communications can hinder systematic interchangeability, reducing flexibility within the product line. We propose a refined solution based on Unified Modeling Language (UML) with extension for delta oriented programming (DOP) to address challenges in re-engineering microservice-based webshops into software product lines (SPL). Our approach defines a mechanism to reengineer microservices and generate a web-based SPL, designed to support the generation of independent services. We generate a running web application with Java backend and React frontend application. From a single SPL code base, we successfully produce four of the six selected cases of microservice-based webshops.
The Universal Variability Language (UVL) is increasingly adopted as a standard language for feature modeling in software product lines (SPL). In this tutorial, we present advanced modeling scenarios that highlight when and how to use UVL’s language levels and extensions. We also provide a comprehensive overview of the UVL ecosystem, showcasing the tools currently available to support modeling, analysis, sharing, and visualization of feature models.
The practices of software development are facing potentially dramatic change. A product line approach will remain relevant by accommodating emerging techniques, such as the capabilities of generative AI (artificial intelligence). This tutorial surveys the content of a draft book [1] that presents such an approach, built on the concept of a product family, for the systematic development of software-based products. A product family is defined in terms of the perceived similarity (commonalities and variabilities) in behavior of an envisioned set of products. These products are seen to differ according to a set of customer-relevant deferred decisions that determine why multiple products may be needed and how each such product is to be built. Partial resolution of these decisions reduces a family to a subfamily whereas full resolution designates a particular instance of the family. The presented approach adopts an objective of producibility—the ability to deliver needed capabilities to customers in a timely, cost-effective, and predictable manner—in building either singular evolving software products or an evolving domain with which customized software-based products targeting a coherent market can then be derived. The former option defines a software engineering formulation for building a product, expressed in the form of a notional product model. This then provides a foundation for the latter option toward building and instantiating a product family. This option is further extended to more directly address the relevance of enterprise and program management, systems and hardware engineering, and customer engagement. This approach retains the tripartite concept introduced in 1998 with the Domain-specific Engineering (DsE) methodology. DsE was a refinement and reformulation of the Synthesis methodology conceived in 1990 at the Software Productivity Consortium as the first comprehensive approach to software development based on the product family concept. DsE continues to be method-agnostic, accommodating diversity and innovation in software methods and practices, including the potential uses of generative AI. DsE is distinguished in part by the conception of application engineering as a streamlined model-based product manufacturing process. This process entails the resolution of domain-specified deferred decisions, associated with a concrete realization of a product family, as a sufficient means for deriving, comparatively evaluating, and delivering alternative customized whole products.
Software product line engineering (SPLE) is a promising approach for managing variability and enhancing reusability in web development. Despite the diversity of domains, many web applications share a significant number of common features. FeatureIDE, a community-supported SPLE tool, offers multiple composers to integrate feature-based variability into code. This paper introduces WinVMJ Composer, a new FeatureIDE composer for web-based SPL development. WinVMJ Composer supports web backend development using variability modules for Java (VMJ), an architectural pattern for delta-oriented SPLs in Java. We deploy WinVMJ Composer as an Eclipse plugin that lets developers compose product variants based on defined configurations. Integrating Java with FeatureIDE promotes SPLE adoption by offering a familiar and practical development environment.
Cyber-Physical Production Systems (CPPSs) integrate physical and software elements to enable the flexible and adaptive manufacturing demanded by today’s globalized markets. Experts from various engineering disciplines (e.g., electrical, mechatronic, or control software) collaborate to develop these systems. In practice, heterogeneous engineering artifacts (e.g., Bills of Material (BOM), Computer-Aided Design (CAD) drawings, or modeling languages) with diverse semantics are used to design and develop these variability-intensive systems. Managing consistency among these artifacts is crucial to prevent failures during commissioning and reduce engineering costs. However, this is challenging due to interdependencies between artifacts—changes in one artifact affect others, and constraints may evolve, leaving no guarantee of a consistent state. This paper presents our vision for managing consistency in CPPSs by transforming metamodel-conformant artifacts into a unified logical intermediate representation, which can be analyzed using a logical solver. We also propose a Domain-Specific Language (DSL) for expressing consistency rules. Our approach is demonstrated using an existing CPPS variability management method, and we outline a research agenda for future work.
The Universal Variability Language (UVL) is a community-driven initiative aiming to provide a standardized textual language for specifying feature models. UVL is currently supported by a growing ecosystem of tools. While these tools primarily address the problem space of Software Product Lines, its connection to the solution space to derive product variants from reusable artifacts lacks adequate tool support, particularly when handling complex variability beyond Boolean features. To address this gap, we present UVengine, a variability resolution engine that enables the generation of customized products using a template-based approach. UVengine supports all UVL language extensions and allows resolving variability over language-independent, text-based artifacts. It integrates seamlessly with the UVL ecosystem and ensures traceability from feature configurations to implementation artifacts.
The Universal Variability Language (UVL) was designed with high extensibility in mind. Still, the development of new extensions necessitates a precise semantic definition and a transformation into a solver-specific encoding for their analysis. Such a transformation is challenging due to the difference in levels of abstraction, making the resulting encoding hard to understand. Moreover, the transformation itself becomes difficult to be extended. In this paper, we propose a simplified process for UVL extension by (1) analyzing the semantics of UVL and (2) providing a transformation of UVL models into an Answer Set Programming (ASP) encoding. We show the effectiveness of our approach in the exemplary extension of UVL with new concepts: attribute domains, derived attributes and scoped aggregates. Finally, we compare our approach to the conventional flattening of extensions to the existing UVL language levels, showing less implementation effort and better readability.
Assuring the reliability of complex systems is a difficult and expensive undertaking. These costs are further exacerbated when a family of similar products with varying features need to be assured, or when products evolve due to changing requirements or to introduce new functionalities. In this talk I will discuss methods for assuring reliability of such systems, from their representation as product lines to their efficient analysis to methods for building and maintaining assurance cases for such systems using templates.
This paper introduces a novel approach for synthesizing assertion-safe #if-guards (presence conditions) in numerical program families (Software Product Lines - SPLs). Given a partial SPL with missing #if-guards, our approach synthesizes concrete predicates defined over numerical features that are strong enough to prove the assertions in all variants of the given SPL. Moreover, the #if-guards synthesized by our approach are the simplest and the weakest among all possible that guarantee the assertion validity. To address this problem, we use abstract interpretation-based forward and backward lifted (SPL) analyses to generate constraints that are then solved by using the logical abduction technique. We have implemented our approach in a prototype synthesis tool, called SPLSynthesize, for #if-annotated SPLs written in C. We show that our tool is able to successfully synthesize assertion-safe presence conditions defined over numerical features for some interesting C program families.
We compare the main features of the recently introduced Universal Variability Language (UVL) with other textual variability modeling languages from the software product line engineering domain. This comparison is structured according to the level of support that each language provides according to five dimensions: configurable elements, constraints, configuration, scalability, and formal semantics. This work extends our earlier work on comparing textual variability modeling languages that used a similar approach [7, 14].
Computational thinking is a discipline that fosters problem-solving by using tools, concepts and practices that are common in computer science. It was defined back in the 1980s, but has gained more and more popularity since Wing’s 2006 Viewpoint paper. The computational thinking movement promotes the learning of skills at any age and in any application domain, not only in computer science. The discipline has evolved incorporating new dimensions such as the one linked with artificial intelligence or quantum computing, just to mention a few. However, very little attention, if any, has been paid to software variability. In this paper, we propose including variability as a new dimension of computational thinking that complements existing ones. This dimension could be defined as the ability to think about a set of related solutions when solving a problem inspired by the way software product line engineering addresses the development of systems. We provide a first solution that extends existing tools to introduce students with variability thinking skills. Concretely, we use Snap! 8 metaprogramming capabilities to make it possible to learn about variability engineering by implementing a tangible solution of a computer game product line. We have validated our solution in a workshop with 19 students in the fourth year of a software engineering degree, and also with 15 experts in variability from 13 different universities. The results are promising according to the two surveys that we used with both students and experts, which show the feasibility of our proposal. We propose a path for the research needed to include the variability dimension in computational thinking, connecting both lines of research. Developing software variability as a new dimension of computational thinking paves the way for teaching it in a practical way in undergraduate courses and even in high school, democratizing its impact and understanding.
Variability is a key concept in Software Product Line Engineering (SPLE), but there is no standardized method to assess the ability to reason about variation points, dependencies, or configuration rules. This absence hinders the evaluation of training outcomes and the empirical analysis of SPL-related practices. This article presents an assessment instrument designed to measure variability in thinking through visual reasoning tasks. The test consists of multiple-choice items that depict configuration scenarios using stylized illustrations inspired by Playmobil figures and settings. Each item focuses on a specific aspect of variability reasoning, such as dependency constraints or valid product derivation. The proposed approach adapts computational thinking assessment techniques to the Software Product Line (SPL) domain. It enables a structured measurement of variability-related reasoning patterns and contributes to the development of assessment methods and the design of educational activities.
Energy consumption is a growing concern for sustainable software. Although increasingly studied, it remains largely unexplored in configurable systems growing in complexity with features. Feature reduction can eliminate software bloat, but to our knowledge, its impact on energy use has not been investigated. To fill this gap, we investigated how both on-demand and built-in feature reduction (defined later) affect the energy consumption of configurable systems. We conducted a first exploratory study using 28 programs from three systems with built-in feature reduction, namely ToyBox, BusyBox, and GNU, as well as 6 GNU programs debloated on-demand using the Chisel, Debop, and Cov tools. In our results, built-in feature reduction led to statistically significant energy decreases in 7% of the cases, while on-demand reduction, despite achieving energy decreases in 67% of cases, showed no statistical significance. However, when energy consumption increased, it was often more substantial than the reductions observed (occurring in 25% of builtin cases and 11% of on-demand cases) showing the complex and sometimes counterintuitive interplay between feature reduction and energy. Additionally, the observed strong correlation between energy consumption and execution time motivates a shift from traditional debloating goals, centered on binary size/attack surface, to energy-aware strategies that prioritize performance concerns. Finally, we provide an in-depth analysis and discuss the perspective.
More than 30 years ago, feature models were invented. Nowadays, they play a major role in Software Product Line Engineering. Several attempts have been made to establish a standard approach (e.g., OVM, CVL, TVL, etc.), yet researchers are still searching for a simple feature modelling language. To address this challenge, a community-driven variability language called Universal Variability Language (UVL) has been proposed to improve information sharing among researchers and tool developers. Following the spirit of the previous eight editions, this workshop is an interactive event where all participants share knowledge, ongoing realizations, and improvements concerning the UVL to increase its outreach further.
Features offer a way to plan software development, but their locations in software assets are often not known. Existing techniques, such as feature-oriented software development, enable traceability of features by implementing features modularly, but are hard to adopt, since they require heavyweight tooling. We believe that feature traceability should be added during development, using lightweight tooling close to the developers’ activities. However, adding traceability requires encouragement—ideally in terms of techniques that provide immediate benefits to developers. We present HAnS-viz, an IntelliJ IDE plugin that provides feature-oriented visualizations that support developers understand and reason about software systems at the feature level. The visualizations present different kinds of feature characteristics and their location in code. Building on our previous work, HAnS, it uses embedded feature annotations that developers create as they write features to lift code-level assets to feature-level representations. A demo video is available at https://youtube.com/watch?v=e4j40dvJQiQ.
Faults not arising from individual but the interaction of multiple components challenge the testing of software products. This problem is escalated by configurable systems which, in addition to a test, also require a configuration including the interaction to test. T-wise sampling techniques generate a set of configurations such that any interaction between.. features appears in at least one configuration. However, trade-offs need to be made when applying t -wise sampling in practice, as time and resources for testing are limited. For instance, even fo t = 2, some real-world systems require thousands of configurations to cover all interactions, an infeasible sample size in practice. To address these challenges, multiple parameterized and randomized samplers have been developed in the past, raising the question "which sample to use for testing?". In this work, we harness recent advances in the compilation of binary decision diagrams (BDD) and propose pm, a BDD-based metric for comparing the quality of samples. Our evaluation demonstrates that pm is easy to compute and significantly acts as a proxy metric for both sample size and 2-wise coverage. Furthermore, we present an exact algorithm to count 2-wise interactions on BDDs that also scales to the infamous automotive02v4 model, from SPLC's sampling challenge.
The 2nd International Workshop on Reverse Variability Engineering and Evolution of Software-Intensive Systems joins the motivation originating from REVE and VariVolution. It shall bring together active researchers eliciting software variability and studying its evolution, and practitioners who encounter these phenomena in the real-world. Re:Volution offers a platform to exchange ideas, case studies, and tools, fostering research collaborations and synergies.
Neuroimaging pipelines - software-driven analysis workflows of brain images - are characterized by a wide range of tools, parameters, and configuration choices. Such flexibility, while enabling diverse scientific inquiries, gives rise to analytical variability: different pipeline variants can lead to different outcomes. In practice, each neuroimaging pipeline variant produces a statistic map - a complex, structured 3D output whose relevance can only be assessed with specific domain expertise, unlike simple metrics such as execution time. And, in most cases, there is no ground truth against which to judge these outputs, making it unclear which variant yields the best result. In this paper, we introduce a "sampling, variant scoring, learning" methodology to study variability in the absence of a quantitative target - i.e. ground truth. We report our experience in developing an Universal Variability Language (UVL) feature model of 90 features representing the configuration space of a well-established open source neuroimaging analysis software (SPM). We sample and run 1000 valid configurations generating 1000 statistic maps as outputs. We studied various candidate proxy ground truths and computed Spearman correlations as a quantitative metric of the performance of each pipeline. We tested the following 12 proxy ground truths: the average statistic map (across variants), the output of an expertderived configuration, and a set of randomly selected outputs (as baseline). Then, we used a decision tree learning approach to inspect variability. We evaluated the sensitivity of our method to the choice of (proxy) ground truth, both in terms of predictive accuracy and in the identification of important features. These first results outline the challenge of choosing and validating a referential to assess our understanding of variability in the absence of ground truth.
Software-intensive systems are often configurable, with system software frequently being developed as product lines to manage variability. Feature models describe the configurable features and their dependencies in such product lines, enabling automated analysis via reasoning tools. However, some challenges remain: Feature models must be correctly extracted and transformed for effective analysis, their complexity can hamper efficiency, and their evolution over time may exacerbate these issues. In the proposed thesis, we address these challenges by (1) evaluating the impact of extraction and transformation on analysis effectiveness and efficiency, (2) studying long-term evolution trends in the configurability and computational complexity of feature models, and (3) studying individual evolution steps, so practitioners can better assess the impact of updates on end users. Our overall goal is to improve our understanding of large, real-world feature models and their evolution.
Cardinality-based feature models generalize the notion of configurations from Boolean vectors to Integer-valued vectors to denote the number of instances per selected feature. This extension is crucial for applications like cloud computing in which configurable resources can be scaled arbitrarily, thus shaping a-priori unbounded configuration spaces. To find best-fitting configurations, the influence of feature multiplicities on non-functional properties has to be taken into account: selecting more feature instances may improve performance but may also increase the costs. Existing approaches for Boolean configuration spaces usually measure these properties on a small sample of configurations to estimate presumably optimal configurations for the whole configuration space. However, this sample-estimate-optimize schema is not directly adaptable to infinite configuration spaces and it is literally inapplicable if ad-hoc probing of sampled configurations is too costly. We instead propose a model-based optimization approach based on weighted automata as integrated behavioral variability model. We use transition weights to formalize both the relationships between variable product behaviors and feature multiplicities as well as their influences on non-functional properties in a uniform way. We apply the weighted-sum method to find optimal configurations by aggregating multiple objective measures obtained by shortest-path search metrics. In our experimental evaluation, performed on an industrial use case from production automation, we investigate the influence of different scalability parameters on the optimality of the proposed configuration.
