Master Seminar

Nowadays, software often has to be available on many platforms and be adaptable to the many different needs of users and customers. Whether it's configuring your new car, your operating system or installing mods for Minecraft, software needs to be flexible and customizable everywhere. It can quickly happen that there are so many configuration options that there can be a different software variant for every person on earth! In this seminar you will become an expert in one aspect of tackling the challenges arising from developing highly configurable software, such as:

• How to model the configurability of such systems (e.g. dependencies)?
• What techniques there are for writing extensible and configurable software?
• What strategies can be used to test meaningfully despite the exponential number of variants?

The seminar is offered next winter term (2026/2027). 

Topics

1. Program Slicing for Software Product Lines

   • Context: Program slicing is the reduction of a program to a subset that produces the same result for a given slicing point. In the context of software product lines can be used for either the extraction of features from legacy code or the analysis of existing SPLs. However, not every SPL implementation technique benefits of program slicing in the same way.

   • Goals: Identify different applications of program slicing used for SPL extraction. Identify different applications of program slicing used for SPL analysis. Discuss which of the employed techniques share commonalities and where they diverge from each other.

2. Real-world Migrations to Software Product Lines

   • Context: Software product line reengineering encompasses the extraction of features from several already existing products in the same domain. During the extraction process many different decisions can be made that make each extraction fairly unique. By collecting such case studies migrating legacy code into a SPL, an effort can be made to summarize the state of the art of SPL Reengineering and detect gaps in the current research.

   • Goals: Collect and describe case studies that focus on extracting a software product line from existing software. Compare the different approaches to each other. Identify common challenges and potential gaps in the process.

3. AI powered SPL Extraction

   • Context: Most variant-rich systems are not initially set up as SPLs. They are developed as set of variants/clones and later refactored into SPLs. This process is called reengineering. The goal of this study is to explore the challenges and opportunities of reengineering SPLs using AIs and compare it to state of the art AI-less approaches.

   • Goals: Collect and describe multiple different approaches for AI powered SPL extraction. Compare strengths, fields of application and limitations with each other. Discuss the impact of AI techniques for SPL extraction by contrasting it with a non-AI baseline.

4. Employing Machine Learning for Generating Artificial Feature Models

   • Context: Feature models encode the all valid configurations of a software product line. Therefore, they are commonly analyzed, e.g., with SAT or #SAT solvers, to gain insights on the underlying product line. However, to empirically evaluate these solvers, many feature models are needed, and not many real-world feature models exist. Therefore, automated techniques to generate artificial feature models have been created.

   • Goals: Find methods for creating artificial feature models. Compare their advantages and disadvantages on a set of chosen criteria. How well do different techniques generate feature models that are close to real-world examples?

5. Meta-Optimization in Software Product Line Engineering

   • Context: Meta-Optimization describes the process of tuning a numerical optimization algorithm with another optimization method. It often becomes necessary as the performance of many optimization techniques heavily depends on the configuration of the algorithm, which is quite hard to do manually. However, in what form such approaches have already been adopted in the world of software product line (SPL) engineering is currently unknown.

   • Goals: Identify meta-optimization techniques commonly employed in SPL engineering. Identify tasks in SPL engineering for which meta-optimization is commonly employed. Are specific meta-optimization techniques particularly suitable for specific problems?

6. Deep Variability -- Interactions across Product Line Borders?

   • Context: The performance or behavior of a software product is not only dependent on the product line it is sampled from. As software is compiled using different compilers, executed on different hardware, and deployed on different data, a large number of additional variability points also impacts the software product. While horizontal interaction between product lines has already been well-researched, the concept of "deep variability" in the vertical dimension is relatively new. However, it is a important new avenue of research, as deep variability can for example negatively impact the reproduciblity of software-based research.

   • Goals: Research the difference between deep variability and cross-product-line analysis/effects. Identify sources of deep variability, impact, and possible solutions. Analyze the impact of deep variability on the reproducibility of software execution and therefore research findings.

7. Detecting Potential Feature Interactions in Software Product Lines

   • Context: Software product lines (SPLs) are often tested for interactions between their features. However testing all possible feature cominations is often unnecessary as not all features can influence each other within the actual implementation. Thus, some approaches take solution space artefacts into account to determine which features are likley to interact and which are not, in order to focus testing efforts.

   • Goals: Identify techniques for determing potential feature interactions in products. Categorize these techniques by their required input, effort and accuracy. Compare the different strategies with respect to their advantages and disadvantages.

8. Heuristic T-Wise Sampling Algorithms

   • Context: Software product lines (SPLs) are often tested by running tests on a small set of representative configurations that cover all possible combinations between t features (i.e. t-wise samples). Creating samples with 100% t-wise coverage is possible, but may take considerable effort for larger SPLs. To this end, heuristic algorithms have been developed that efficiently create samples by trying to maximize the coverage, but not necessarily up to 100%.

   • Goals: Identify which heuristic algorithms exist for t-wise sampling. Identify the individual trade-off of coverage, sample size, and sampling time for these algorithms. Compare the different algorithms with respect to their advantages and disadvantages.

9. Analysis Strategies for Software Product Lines

   • Context: Software product lines (SPLs) describe billions of individual software variants simultaneously. Analyzing all these variants, for example to ensure soundness properties, does not scale in practice. To this end, analysis must exploit the similarities between the variants (i.e., the features), similar to how an SPL implements billions of variants without ever explicitly enumerating them.

   • Goals: Identify common analyses strategies for software product lines and their uses. Identify how the exponential explosion of the configuration space is addressed by these strategies. Compare the different kinds of analyses strategies with respect to their advantages and disadvantages.

10. Knowledge Compilation for Automated Reasoning in SE

    • Context: Knowledge compilation refers to translating an original logical expression to another format with beneficial properties regarding efficiency of follow up analyses. The concept is applied in various domains to accelerate automated reasoning revolving around many computations. However, since the application of knowledge compilation is so heavily scattered across different communities, it is hard for researchers to get an overview on possibilities.

    • Goals: Identify applications of knowledge compilation for SE. Extract targeted problems. Derive mapping between knowledge compilation formats and problems they are used for.

11. Constraint Dialects Used for Representing Variability of Configurable Systems

    • Context: Configurable systems are part of your everyday life. Here, you can assemble multiple product variants from a pool of features. In practice, there are thousands of dependencies between such features. Typically, to facilitate automated reasoning, such dependencies are represented as logical formulas in varying constraint dialects. While automated reasoning research focuses mostly Boolean logic, many other dialects have been considered and employed. However, the relevance of other dialects is hard to quantify as there has not been a systematic analyses of employed techniques.

    • Goals: Identify popular constraint dialects used for representing variability. Examine usage of dialects depending on system domain. Research available reasoning engines for non-boolean dialects.

12. Product Line Adoption in Practice

    • Context: Configurable systems are prevalent in virtually every part of human live, such as transportation, communication, or entertainment. In practice, such systems are typically managed as product lines consisting of different products with commonalities and variabilities. Various research efforts target alleged problems in the area of product lines. However, to focus research on actual issues in practice, it is vital to understand concerns that actually occur in practice.

    • Goals: Gather relevant work on industrial practices when dealing with product lines. Identify abiding problems when working with product lines. Provide a classification and overview of problems.

13. Commit Analysis Tools for Product Lines

    • Context: Product line techniques are used in the industry since decades. With a rising code base and multiple developers, the need for supporting the development of product lines rises. To solve problems, we first need to understand them. Different tools have been developed to analyze commits of product lines in existing open source repositories.

    • Goals: Describe existing tools. What are advantages and disadvantages of the tools? Compare the tools with each other.

14. Mutation Testing for Preprocessors

    • Context: Mutation testing is a software testing technique used to evaluate whether existing tests can detect errors in source code. It introduces small code changes using predefined rules called mutation operators and checks whether the test suite detects these changes. In recent years, mutation testing has also been extended to configurable software systems, which allow different features to be enabled or disabled depending on specific requirements. In such systems, preprocessors can be used to include or exclude certain parts of the source code based on configuration settings. Mutation testing can therefore help evaluate the effectiveness of test suites across different software configurations.

    • Goals: Describe how mutation testing for preproessor annotations work. Describe the different mutation operators for preprocessor annotations. Explain the problems with mutation testing for preprocessor annotations.

Formal methods comprise mathematically rigorous techniques to analyze systems, e.g., to verify software or reason about machine-learning classifiers. Classical formal methods target a single result, such as "The system does not deadlock." or "The classifier is robust up to a small input change.", without providing an explanation of why the result holds or what the important ingredients are for obtaining it. Explainable formal methods aim at filling this gap, improving comprehension of system behavior, the analysis process, and its outcomes.

In this seminar, we will address recent advancements in the field of explainable formal methods and AI, covering the foundations and applications of causality, importance measures, logic-based formal explanations, and formal verification of classifiers.

The specific topics and reference papers addressed in the seminar will be published in early October. The seminar is held in English.

Topics

1. Abductive Explanations for Neural Networks
   • Context: Most methods in explainable AI are heuristic and come without guarantees, which logic-based explanations can provide. An abductive explanation is a subset-minimal set of feature values that entails the prediction, i.e., every input agreeing on these features is classified in the same way. Computing such explanations requires encoding the classifier, e.g., a neural network, into a logical representation and solving reasoning problems over it. This topic studies abductive explanations, how they are computed for neural networks using formal reasoners, and how they relate to prime implicants.
   • Goals: Summarize the definition of abductive explanations and relate them to prime implicants of the classifier's decision function. Explain how a neural network is encoded into a logical representation (e.g., MILP or SMT) and how abductive explanations are computed with an oracle for entailment checking. Discuss the guarantees and the scalability of abductive explanations compared to heuristic explanation methods, and their relation to other XAI methods.
2. Feature Causality in Configurable Software Systems
   • Context: Configurable software systems can be tailored to specific needs by selecting features. Some configurations, however, show undesired effects such as failing tests or poor performance, and it is often unclear which features or feature interactions are responsible for such an effect. Feature causality lifts the counterfactual notion of actual causality by Halpern and Pearl to the level of system configurations: a feature selection is a cause of an effect if changing it could have avoided the effect. This topic studies feature causality, its algorithmic foundations, and its use for explaining effects in configurable systems.
   • Goals: Provide the definition feature causality with an own example illustrating cause-effect relations. Explain the connection between feature causes, abductive explanations, and prime implicants, and how feature causes are computed. Present explication methods built on feature causality, such as cause-effect covers and responsibility and blame, and discuss them on an example from the paper's evaluation.
3. Contrastive Explanations
   • Context: Explanations of a classifier's decision come in two flavors. An abductive explanation answers "Why this prediction?" while a contrastive explanation answers "Why not another prediction?", the latter being close to the counterfactual reasoning humans typically use. Both notions are formally connected by a minimal hitting set duality, which enables algorithms that compute and enumerate both kinds of explanations using formal reasoners. This topic studies contrastive and abductive explanations, their duality, and its algorithmic use.
   • Goals: Summarize the definitions of abductive and contrastive explanations and illustrate them on a small classifier. Explain the minimal hitting set duality between both kinds of explanations and relate it to the duality between minimal unsatisfiable subsets and minimal correction sets. Describe how the duality is exploited to enumerate explanations, and discuss how contrastive explanations relate to counterfactual notions of causality and to adversarial examples.
4. Importance Measures for Boolean Functions
   • Context. Which inputs of a system or classifier matter most for its outcome? Importance measures answer this question by assigning a value to each feature. Various notions have been proposed independently in different areas, e.g., through SHAP scores in the field of explainable AI. This topic studies importance measures for Boolean functions and a unifying axiomatic framework that allows these measures to be compared, to derive new measures, and provide practical computations.
   • Goals: Summarize the axiomatic framework of importance value functions and show how influence, Shapley and Banzhaf values, and responsibility-based measures fit into it. Explain how importance values are computed symbolically, e.g., with BDDs or knowledge compilation, and discuss the complexity of their computation. Discuss the criticism of Shapley values for explainability and relate it to the axioms of the unifying framework.
5. Formal Verification of Neural Networks
   • Context: Neural networks are increasingly deployed in safety-critical systems, yet they are known to be vulnerable to small input perturbations. Testing cannot rule out such failures, whereas formal verification proves that a network satisfies a property for all inputs in a given region, e.g., that its output does not change under small perturbations. This topic studies the foundations of neural network verification and how verification relates to formal explanations of classifiers.
   • Goals: Summarize how verification properties of neural networks (e.g., local robustness) are specified, and why verification with ReLU activations is NP-complete. Explain the Reluplex algorithm, i.e., how the simplex method is extended to handle ReLU constraints lazily, and illustrate it on a small network. Discuss the scalability of the approach, its evolution into the Marabou framework, and alternative verification approaches, e.g., SAT-based verification of binarized networks or compilation into tractable circuits.

Supervision

This course is supervised by Rahel Sundermann and Thomas Thüm.

Topics

Deep Variability -- Interactions across Product Line Borders?

Context

The performance or behavior of a software product is not only dependent on the product line it is sampled from. As software is compiled using different compilers, executed on different hardware, and deployed on different data, a large number of additional variability points also impacts the software product. While horizontal interaction between product lines has already been well-researched, the concept of "deep variability" in the vertical dimension is relatively new. However, it is a important new avenue of research, as deep variability can for example negatively impact the reproducablity of software-based research.

Goal / Research Questions

• Research the difference between deep variability and cross-product-line analysis/effects.
• Identify sources of deep variability, impact, and possible solutions.
• Analyze the impact of deep variability on the reproducibility of software execution and therefore research findings.

Papers

• Luc Lesoil, Mathieu Acher, Arnaud Blouin, and Jean-Marc Jézéquel. “Deep Software Variability: Towards Handling Cross-Layer Configuration”. In: Proc. Int’l Working Conf. on Variability Modelling of Software-Intensive Systems (VaMoS). ACM, 2021, 10:1–10:8. DOI:10.1145/3442391.3442402.
• Mathieu Acher, Benoit Combemale, Georges Aaron Randrianaina, and Jean-Marc Jezequel. “Embracing Deep Variability For Reproducibility and Replicability”. In: Proc. ACM Conf. on Reproducibility and Replicability (REP). ACM, 2024, pp. 30–35. DOI: 10.1145/3641525.3663621.
• [WHRB13] Ora Wulf-Hadash and Iris Reinhartz-Berger. “Cross product line analysis”. In: VaMoS ’13. Pisa, Italy: Association for Computing Machinery, 2013. ISBN: 9781450315418. DOI: 10.1145/2430502.2430531.

Metrics for Characterizing Feature Model Complexity

Context

Feature models encode the all valid configurations of a software product line. Therefore, they are commonly analyzed, e.g., with SAT or #SAT solvers, to gain insights on the underlying product line. But not only insights on the product line, but also the complexity of the feature model, e.g., the ease of solver-based analyses or modifiability of the feature model, can be helpful to guide stakeholder decisions.

Goal / Research Questions

• Identify common measure that characterize the complexity of a feature model for various applications.

• Identify common metrics that are used in the context of feature model complexity.
• Research how those metrics are combined or analyzed to characterize feature model complexity / compute different complexity measures.

Paper

• Carla I.M. Bezerra, Rossana M.C. Andrade, and Jose Maria Monteiro. “Exploring quality measures for the evaluation of feature models: a case study”. In: Journal of Systems and Software 131 (2017), pp. 366–385. ISSN: 0164-1212. DOI:https://doi.org/10.1016/j.jss.2016.07.040.

• Ebrahim Bagheri and Dragan Gasevic. “Assessing the Maintainability of Software Product Line Feature Models Using Structural Metrics”. In: Software Quality Journal (SQJ) 19.3 (2011), pp. 579–612. DOI: https://doi.org/10.1007/s11219-010-9127-2

• Richard Pohl, Vanessa Stricker, and Klaus Pohl. “Measuring the Structural Complexity of Feature Models”. In: Proc. Int’l Conf. on Automated Software Engineering (ASE). ACM, 2013, pp. 454–464. DOI: 10.1109/ASE.2013.6693103.

• Públio Silva, Carla Bezerra, and Ivan Machado. “Automating Feature Model maintainability evaluation using machine learning techniques”. In: Journal of Systems and Software 195 (2023), p. 111539. ISSN: 0164-1212. DOI:https://doi.org/10.1016/j.jss.2022.111539.

Program Slicing for Software Product Lines 

Context

Program slicing is the reduction of a program to a subset that produces the same result for a given slicing point. In the context of software product lines can be used for either the extraction of features from legacy code or the analysis of existing SPLs. However, not every SPL implementation technique benefits of program slicing in the same way.

Goal / Research Questions

• Identify different applications of program slicing used for SPL extraction.

• Identify different applications of program slicing used for SPL analysis.
• Discuss which of the employed techniques share commonalities and where they diverge from each other.

Papers

• Aleksandar S. Dimovski. “Variability Fault Localization by Abstract Interpretation and its Application to SPL Repair”. In: Proceedings of the 18th ACM SIGPLAN International Conference on Software Language Engineering. SLE ’25. Koblenz, Germany: Association for Computing Machinery, 2025, pp. 175188. ISBN: 9798400718847. DOI: 10.1145/3732771.3742722. URL: https://doi.org/10.1145/3732771.3742722.
• Lea Gerling. “Syntax-preserving program slicing for C-based software product lines”. In: Journal of Systems and Software 219 (2025), p. 112255. ISSN: 0164-1212. DOI: https://doi.org/10.1016/j.jss.2024.112255.
• Benjamin Klatt, Klaus Krogmann, and Christoph Seidl. “Program Dependency Analysis for Consolidating Customized Product Copies”. In: Proc. Int’l Conf. on Software Maintenance and Evolution (ICSME). IEEE, 2014, pp. 496–500. DOI: 10.1109/ICSME.2014.81.

Real World Migrations to Software Product Lines

Context

Software product line reengineering encompasses the extraction of features from several already existing products in the same domain. During the extraction process many different decisions can be made that make each extraction fairly unique. By collecting such case studies migrating legacy code into a SPL, an effort can be made to summarize the state of the art of SPL Reengineering and detect gaps in the current research.

Goal / Research Questions

• Collect and describe case studies that focus on extracting a software product line from existing software.

• Compare the different approaches to each other.
• Identify common challenges and potential gaps in the process.

Papers

• Lee, H., Choi, H., Kang, K.C., Kim, D., Lee, Z. (2009). Experience Report on Using a Domain Model-Based Extractive Approach to Software Product Line Asset Development. In: Edwards, S.H., Kulczycki, G. (eds) Formal Foundations of Reuse and Domain Engineering. ICSR 2009. Lecture Notes in Computer Science, vol 5791. Springer, Berlin, Heidelberg. https://doi.org/10.1007/978-3-642-04211-9_14
• Lima, C., Assunção, W.K., Martinez, J. et al. Product line architecture recovery with outlier filtering in software families: the Apo-Games case study. J Braz Comput Soc 25, 7 (2019). https://doi.org/10.1186/s13173-019-0088-4
• G. Zhang, L. Shen, X. Peng, Z. Xing and W. Zhao, "Incremental and iterative reengineering towards Software Product Line: An industrial case study," 2011 27th IEEE International Conference on Software Maintenance (ICSM), Williamsburg, VA, USA, 2011, pp. 418-427, doi: 10.1109/ICSM.2011.6080809.

Analysis Strategies for Software Product Lines

Context

Software product lines (SPLs) describe billions of individual software variants simultaneously. Analyzing all these variants, for example to ensure soundness properties, does not scale in practice. To this end, analysis must exploit the similarities between the variants (i.e., the features), similar to how an SPL implements billions of variants without ever explicitly enumerating them.

Goal / Research Questions

• Identify common analyses strategies for software product lines and their uses.
• Identify how the exponential explosion of the configuration space is addressed by these strategies.
• Compare the different kinds of analyses strategies with respect to their advantages and disadvantages.

Papers

• Thiago Castro, Leopoldo Teixeira, Vander Alves, Sven Apel, Maxime Cordy, and Rohit Gheyi. “A Formal Framework of Software Product Line Analyses”. In: Trans. on Software Engineering and Methodology (TOSEM) 30.3 (2021). doi: 10.1145/3442389.
• Thomas Thüm, Sven Apel, Christian Kästner, Ina Schaefer, and Gunter Saake. “A Classification and Survey of Analysis Strategies for Software Product Lines”. In: ACM Computing Surveys (CSUR) 47.1 (2014), 6:1–6:45. doi: 10.1145/2580950.
• Sergiy Kolesnikov, Alexander von Rhein, Claus Hunsen, and Sven Apel. “A Comparison of Product-Based, Feature-Based, and Family-Based Type Checking”. In: Proc. Int’l Conf. on Generative Programming: Concepts & Experiences (GPCE). ACM, 2013, pp. 115–124. doi: 10.1145/2517208.2517213.

Analyzing Configuration Spaces of Cardinality-Based Feature Models

Context

Feature models are often limited to boolean configuration spaces with a fixed number of features. However, cardinality-based feature models (CFMs) allow users to choose some features not just once, but multiple times. This makes it difficult to apply existing techniques for analyzing the configuration space represented by a CFM, e.g. for testing and estimating non-funtional properties of configurations.

Goal / Research Questions

• Identify typical analysis techniqes for feature models that cannot be applied to CFMs directly.
• Identify approaches that deal with problems CFMs pose to these techniques
• Discuss and compare commonalities and differences in these approaches
• Discuss missing analyses

Papers

• Lukas Güthing, Mathis Weiß, Ina Schaefer, and Malte Lochau. 2024. Sampling Cardinality-Based Feature Models. In Proceedings of the 18th International Working Conference on Variability Modelling of Software-Intensive Systems (VaMoS '24). Association for Computing Machinery, New York, NY, USA, 46–55. doi.org/10.1145/3634713.3634719
• Robert Müller, Mathis Weiß, and Malte Lochau. 2025. Finding Optimal Configurations of Cardinality-based Feature Models using Weighted Automata. In Proceedings of the 29th ACM International Systems and Software Product Line Conference - Volume A (SPLC-A '25). Association for Computing Machinery, New York, NY, USA, 69–80. doi.org/10.1145/3744915.3748464
• Weckesser, M., Lochau, M., Schnabel, T., Richerzhagen, B., Schürr, A. (2016). Mind the Gap! Automated Anomaly Detection for Potentially Unbounded Cardinality-Based Feature Models. In: Stevens, P., Wąsowski, A. (eds) Fundamental Approaches to Software Engineering. FASE 2016. Lecture Notes in Computer Science(), vol 9633. Springer, Berlin, Heidelberg. doi.org/10.1007/978-3-662-49665-7_10

Using Sampling for Performance Prediction of Software Product Lines

Context

For highly-configurable software, it is often important to know which configurations lead to low or high performance (e.g., runtime) of the resulting products. As the number of configurations is often extremely large, measuring all configurations is usually infeasible. Instead, some approaches use sampling, where a set of configurations is chosen for measurement, and the results are generalized to the full software product line.

Goal / Research Questions

• Summarize the sampling techniques used for performance prediction of configurable systems.
• Explain the used performance prediction approaches.
• Identify differences and commonalities between used strategies.

Papers

• Jeho Oh, Don Batory, Margaret Myers, and Norbert Siegmund. 2017. Finding near-optimal configurations in product lines by random sampling. In Proceedings of the 2017 11th Joint Meeting on Foundations of Software Engineering (ESEC/FSE 2017). Association for Computing Machinery, New York, NY, USA, 61–71. https://doi.org/10.1145/3106237.3106273
• Atri Sarkar, Jianmei Guo, Norbert Siegmund, Sven Apel, and Krzysztof Czarnecki. 2015. Cost-efficient sampling for performance prediction of configurable systems. In Proceedings of the 30th IEEE/ACM International Conference on Automated Software Engineering (ASE '15). IEEE Press, 342–352. https://doi.org/10.1109/ASE.2015.45
• Juliana Alves Pereira, Mathieu Acher, Hugo Martin, and Jean-Marc Jézéquel. 2020. Sampling Effect on Performance Prediction of Configurable Systems: A Case Study. In Proceedings of the ACM/SPEC International Conference on Performance Engineering (ICPE '20). Association for Computing Machinery, New York, NY, USA, 277–288. https://doi.org/10.1145/3358960.3379137

An Overview of Variability Bug Collections for the Linux Kernel

Context

Configurable software systems can have variability bugs, which are bugs that occur in some but not all configurations of the software. The Linux kernel, being the most complex public software product line and having a wide-spread usage, is of particular interest for variability bug research. There are various works that have investigated varibility-related defects in the Linux kernel, and compiled respective data collections.

Goal / Research Questions

• Analyze the research that collects variability bugs in the Linux kernel.
• Explain the scope that was considered for finding the bugs, and the extent of the resulting collections.
• Explain different definitions for variability bugs in the Linux kernel.

Papers

• Iago Abal, Jean Melo, Ştefan Stănciulescu, Claus Brabrand, Márcio Ribeiro, and Andrzej Wąsowski. 2018. Variability Bugs in Highly Configurable Systems: A Qualitative Analysis. ACM Trans. Softw. Eng. Methodol. 26, 3, Article 10 (July 2017), 34 pages. https://doi.org/10.1145/3149119
• Jeho Oh, Necip Fazıl Yıldıran, Julian Braha, and Paul Gazzillo. 2021. Finding broken Linux configuration specifications by statically analyzing the Kconfig language. In Proceedings of the 29th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE 2021). Association for Computing Machinery, New York, NY, USA, 893–905. https://doi.org/10.1145/3468264.3468578
• Reinhard Tartler, Christian Dietrich, Julio Sincero, Wolfgang Schröder-Preikschat, and Daniel Lohmann. 2014. Static analysis of variability in system software: the 90,000 #ifdefs issue. In Proceedings of the 2014 USENIX conference on USENIX Annual Technical Conference (USENIX ATC'14). USENIX Association, USA, 421–432.

Knowledge Compilation for Automated Reasoning in SE

Context

Knowledge compilation refers to translating an original logical expression to another format with beneficial properties regarding efficiency of follow up analyses. The concept is applied in various domains to accelerate automated reasoning revolving around many computations. However, since the application of knowledge compilation is so heavily scattered across different communities, it is hard for researchers to get an overview on possibilities.

Goal / Research Questions

• Identify applications of knowledge compilation for SE
• Extract targeted problems
• Derive mapping between knowledge compilation formats and problems they are used for

Papers

• Chico Sundermann, Elias Kuiter, Tobias Heß, Heiko Raab, Sebastian Krieter, and Thomas Thüm. “On the Benefits of Knowledge Compilation for Feature-Model Analyses”. In: Annals of Mathematics and Artificial Intelligence (AMAI) 92.5 (2023), pp. 1013–1050. doi: 10.1007/s10472-023-09906-6.
• Von Rhein, Alexander, Sven Apel, and Franco Raimondi. "Introducing binary decision diagrams in the explicit-state verification of Java code." Proc. Java Pathfinder Workshop. Vol. 82. 2011.
• Chico Sundermann, Jacob Loth, and Thomas Thüm. 2024. Efficient Slicing of Feature Models via Projected d-DNNF Compilation. In Proceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering (ASE '24). Association for Computing Machinery, New York, NY, USA, 1332–1344. https://doi.org/10.1145/3691620.3695594

Constraint Dialects Used for Representing Variability of Configurable Systems

Context

Configurable systems are part of your everyday life. Here, you can assemble multiple product variants from a pool of features. In practice, there are thousands of dependencies between such features. Typically, to facilitate automated reasoning, such dependencies are represented as logical formulas in varying constraint dialects. While automated reasoning research focuses mostly Boolean logic, many other dialects have been considered and employed. However, the relevance of other dialects is hard to quantify as there has not been a systematic analyses of employed techniques.

Goal / Research Questions

• Identify popular constraint dialects used for representing variability
• Examine usage of dialects depending on system domain
• Research available reasoning engines for non-boolean dialects

Papers

• Benavides, David, Pablo Trinidad, and Antonio Ruiz Cortés. "Using Constraint Programming to Reason on Feature Models." SEKE. Vol. 5. 2005. https://www.academia.edu/6845094/Using_Constraint_Programming_to_Reason_on_Feature_Models
• Michel, Raphaël, et al. "An SMT-based approach to automated configuration." SMT@ IJCAR 20 (2012): 109-119. https://doi.org/10.29007/5n7n
• Fan, Shaofeng, and Naixiao Zhang. "Feature model based on description logics." International Conference on Knowledge-Based and Intelligent Information and Engineering Systems. Springer, 2006. https://doi.org/10.1109/SPLINE.2007.24

Commit Analysis Tools for Product Lines

Context

Product line techniques are used in the industry since decades. With a rising code base and multiple developers, the need for supporting the development of product lines rises. To solve problems, we first need to understand them. Different tools have been developed to analyze commits of product lines in existing open source repositories.

Goal / Research Questions

• Describe existing tools
• What are advantages and disadvantages of the tools?
• Compare the tools with each other

Papers

• Nicolas Dintzner, Arie van Deursen, Martin Pinzger. “FEVER: An approach to analyze feature-oriented changes and artefact co-evolution in highly configurable systems”. In: Empir Software Eng Vol 23, 905–952 (2018). https://doi.org/10.1007/s10664-017-9557-6
• Christian Kröher, Lea Gerling, Klaus Schmid. “Comparing the intensity of variability changes in software product line evolution”. In: Journal of Systems and Software Vol 203 (2023). https://doi.org/10.1016/j.jss.2023.111737
• Paul Maximilian Bittner, Alexander Schultheiß, Benjamin Moosherr, Timo Kehrer, Thomas Thüm. “Variability-Aware Differencing with DiffDetective”. In: FSE: Companion Proceedings of the 32nd ACM International Conference on the Foundations of Software Engineering (2024). https://doi.org/10.1145/3663529.3663813

Supporting Clone-And-Own in Industry

Context

Using Clone-and-Own, i.e., copying existing code and adapting it for special requests, is a common way of developing configurable software in the industry. However, this comes with challenges for developers and the necessity for techniques to cope with appearing problems.

Goal / Research Questions

• How is Clone-and-Own used in the industry?
• Identify advantages and disadvantages for developers
• Discuss possibilities to support management of code clones

Papers

• Raúl Lapeña, Manuel Ballarin, Carlos Cetina. “Towards Clone-And-Own Support: Locating Relevant Methods in Legacy Products”. In: Proceedings of the 20th International Systems and Software Product Line Conference (2016). http://dx.doi.org/0.1145/2934466.2934485
• Yael Dubinsky, Julia Rubin, Thorsten Berger, Slawomir Duszynski, Martin Becker and Krzysztof Czarnecki. “An Exploratory Study of Cloning in Industrial Software Product Lines”. In: 17th European Conference on Software Maintenance and Reengineering (2013). https://doi.org/10.1109/CSMR.2013.13
• Julia Rubin, Krzysztof Czarnecki, Marsha Chechik. “Managing cloned variants: a framework and experience”. In: Proc. Int’l Systems and Software Product Line Conf. (SPLC). ACM, 2013, pp. 101–110. DOI: 10.1145/2491627.2491644.

Material

The course material is provided in the corresponding Stud.IP course.

Supervision

This course is supervised by Raphael Dunkel and Thomas Thüm.

Topics

Developer Workflow in Variation Control Systems

Context

Editing variational systems can be a mentally challenging task as it requires to understand and maintain multiple features and their interactions simultaneously. Variation control systems promote development of software product lines in terms of projectional editing: Instead of editing the complete software product line, developers edit a view of the software that shows only relevant parts of the code such as all code elements that belong to a particular feature or variant.

Goal / Research Questions

• Describe the workflow of developers in variation control systems.
• Describe how the workflow in vartiation control systems differs from the workflow with version control systems, and how they interact.
• Investigate challenges and edge cases.

Papers

• Eric Walkingshaw and Klaus Ostermann. “Projectional Editing of Variational Software”. In: Proc. Int’l Conf. on Generative Programming: Concepts & Experiences (GPCE). ACM, 2014, pp. 29–38. doi: 10.1145/2658761.2658766.
• Lukas Linsbauer, Alexander Egyed, and Roberto Erick Lopez-Herrejon. “A Variability Aware Configuration Management and Revision Control Platform”. In: Proc. Int’l Conf. on Software Engineering (ICSE). ACM, 2016, pp. 803–806. doi: 10.1145/2889160.2889262.
• Lukas Linsbauer, Felix Schwägerl, Thorsten Berger, and Paul Grünbacher. “Concepts of Variation Control Systems”. In: J. Systems and Software (JSS) 171 (2021), p. 110796. doi: 10.1016/j.jss.2020.110796.

Variability Modelling Languages and Their Analyzability

Context

To describe the valid configurations of a product line, researchers created a multitude of variability modelling languages. Each language has different advantages and disadvantages in relevant properties such as usability or expressiveness. However, language representation also limits the applicability of different automated variability analyses and their ease of computation.

Goal / Research Questions

• Identify common languages for variability modelling.

• Compare these languages, especially in regards to the analyses their representation allows for.

• Identify similarities between language analyzability and identify shared root causes. Which attributes of variability modelling languages impact the applicability and complexity of automated analysis approaches?

Paper

• David Benavides, Chico Sundermann, Kevin Feichtinger, José A. Galindo, Rick Rabiser, and Thomas Thüm. “UVL: Feature Modelling With the Universal Variability Language”. In: J. Systems and Software (JSS) 225 (2025). doi: 10.1016/j.jss.2024.112326.

• Holger Eichelberger and Klaus Schmid. “A Systematic Analysis of Textual Variability Modeling Languages”. In: Proc. Int’l Systems and Software Product Line Conf. (SPLC). ACM, 2013, 12–21. doi: 10.1145/2491627.2491652.

• Chico Sundermann, Stefan Vill, Thomas Thüm, Kevin Feichtinger, Prankur Agarwal, Rick Rabiser, José A. Galindo, and David Benavides. “UVLParser: Extending UVL With Language Levels and Conversion Strategies”. In: Proc. Int’l Systems and Software Product Line Conf. (SPLC). ACM, 2023, pp. 39–42. doi: 10.1145/3579028.3609013.

Formalizing Variational Analyses with the Choice Calculus

Context

To design and specify analyses, formal languages are needed. For analysing source code in software product lines, one such a language is the choice calculus, a minimal language to describe variation. The choice calculus has been used as a foundation for specifying numerous analyses in research, and as a basis for their implementation.

Goal / Research Questions

• Describe what the choice calculus is and how it can be used to specify and implement variational analyses.
• Give an overview of existing use cases and analyses that were formalized with the choice calculus.
• Identify commonalities and differences in different usages and dialects of the choice calculus. Why and how is it adapted to its intended use case?

Papers

• Martin Erwig and Eric Walkingshaw. “The Choice Calculus: A Representation for Software Variation”. In: Trans. on Software Engineering and Methodology (TOSEM) 21.1 (2011), 6:1–6:27. doi: 10.1145/2063239.2063245.
• Sheng Chen, Martin Erwig, and Eric Walkingshaw. “A Calculus for Variational Programming”. In: Proc. Europ. Conf. on Object-Oriented Programming (ECOOP). Vol. 56. Schloss Dagstuhl, 2016, 6:1–6:28. doi: 10.4230/LIPICS.ECOOP.2016.6.
• Jeffrey M. Young, Paul Maximilian Bittner, Eric Walkingshaw, and Thomas Thüm. “Variational Satisfiability Solving: Efficiently Solving Lots of Related SAT Problems”. In: Empirical Software Engineering (EMSE) 28 (2022), p. 53. doi: 10.1007/s10664-022-10217-3.

Analysis Strategies for Software Product Lines

Context

Software product lines (SPLs) describe billions of individual software variants simultaneously. Analyzing all these variants, for example to ensure soundness properties, does not scale in practice. To this end, analysis must exploit the similarities between the variants (i.e., the features), similar to how an SPL implements billions of variants without ever explicitly enumerating them.

Goal / Research Questions

• Identify common analyses strategies for software product lines and their uses.
• Identify how the exponential explosion of the configuration space is addressed by these strategies.
• Compare the different kinds of analyses strategies with respect to their advantages and disadvantages.

Papers

• Thiago Castro, Leopoldo Teixeira, Vander Alves, Sven Apel, Maxime Cordy, and Rohit Gheyi. “A Formal Framework of Software Product Line Analyses”. In: Trans. on Software Engineering and Methodology (TOSEM) 30.3 (2021). doi: 10.1145/3442389.
• Thomas Thüm, Sven Apel, Christian Kästner, Ina Schaefer, and Gunter Saake. “A Classification and Survey of Analysis Strategies for Software Product Lines”. In: ACM Computing Surveys (CSUR) 47.1 (2014), 6:1–6:45. doi: 10.1145/2580950.
• Sergiy Kolesnikov, Alexander von Rhein, Claus Hunsen, and Sven Apel. “A Comparison of Product-Based, Feature-Based, and Family-Based Type Checking”. In: Proc. Int’l Conf. on Generative Programming: Concepts & Experiences (GPCE). ACM, 2013, pp. 115–124. doi: 10.1145/2517208.2517213.

Methods for Finding Locations Where a Feature is Implemented

Context

For comprehending, maintaining, and extending existing software, it is crucial to find locations of interest in a software system quickly, reliably, and exhaustively. To that end, tracing features to their implementation is one of the most common activities of developers. However, such feature traces are rarely documented in practice. Therefore, research on feature location an feature identification tries to assist developers in documenting or recovering such information.

Goal / Research Questions

• Describe the concept of feature location.
• What sources of knowledge are exploited by existing methods? How is the knowledge used?
• Identify which feature location techniques are useful for in different project types or development scenarios.

Papers

• Christian Kästner, Alexander Dreiling, and Klaus Ostermann. “Variability Mining: Consistent Semiautomatic Detection of Product-Line Features”. In: IEEE Trans. on Software Engineering (TSE) 40.1 (2014), pp. 67–82. doi: 10.1109/TSE.2013.45.
• Lukas Linsbauer, Roberto Erick Lopez-Herrejon, and Alexander Egyed. “Variability Extraction and Modeling for Product Variants”. In: Software and Systems Modeling (SoSyM) 16.4 (2017), pp. 1179–1199. doi: 10.1007/s10270-015-0512-y.
• Julia Rubin and Marsha Chechik. “A Survey of Feature Location Techniques”. In: Domain Engineering: Product Lines, Languages, and Conceptual Models. Ed. by Iris Reinhartz-Berger, Arnon Sturm, Tony Clark, Sholom Cohen, and Jorn Bettin. Springer, 2013, pp. 29–58. doi: 10.1007/978-3-642-36654-3_2.

Clone-Based Software Reuse - Evolution and Maintenance Practices in Open Source 

Context

On GitHub, developers often maintain a separate, modified variant (fork) alongside the original. Shared components between variants may not be consistently updated. This can lead to inefficient patching across variants.

Goal / Research Questions

• Identify and describe why and how clone-and-own is applied in open source projects on GitHub.
• Identify and describe challenges of software reuse between open source repos.
• Identify and describe tools and techniques that might aid developers in maintaining their variant.

Papers

• John Businge, Moses Openja, Sarah Nadi, Engineer Bainomugisha, and Thorsten Berger. “Clone-Based Variability Management in the Android Ecosystem”. In: Proc. Int’l Conf. on Software Maintenance and Evolution (ICSME). IEEE, 2018, pp. 625–634. doi: 10.1109/ICSME.2018.00072.
• John Businge, Ahmed Zerouali, Alexandre Decan, Tom Mens, Serge Demeyer, and Coen De Roover. “Variant Forks - Motivations and Impediments”. In: Proc. Int’l Conf. on Software Analysis, Evolution and Reengineering (SANER). IEEE, 2022, pp. 867–877. doi: 10.1109/SANER53432.2022.00105.
• Poedjadevie Kadjel Ramkisoen, John Businge, Brent van Bladel, Alexandre Decan, Serge Demeyer, Coen De Roover, and Foutse Khomh. “PaReco: Patched Clones and Missed Patches Among the Divergent Variants of a Software Family”. In: Proc. Europ. Software Engineering Conf./Foundations of Software Engineering (ESEC/FSE). ACM, 2022, pp. 646–658. doi: 10.1145/3540250.3549112.
• Shurui Zhou, Ştefan Stănciulescu, Olaf Leßenich, Yingfei Xiong, Andrzej Wąsowski, and Christian Kästner. “Identifying Features in Forks”. In: Proc. Int’l Conf. on Software Engineering (ICSE). ACM, 2018, pp. 105–116. doi: 10.1145/3180155.3180205.

On the Difficulty of Obtaining Feature Models Retroactively 

Context

In software product line theory, feature models are a core component of a product line. In practice however, developers often do not model the variability in a system explicitly. The knowledge about features and their relationships is often implicitly encoded in configurations files, the build system, and/or solution space variability. Various techniques and tools try to extract this knowledge, which is a system-dependent and complex process.

Goal / Research Questions

• Assess the core ideas behind techniques for extracting knowledge about features and their relationships from a system.
• Identify and present technical and organizational challenges of extracting knowledge for feature modelling.

Papers

• Jessie Carbonnel, Marianne Huchard, and Clémentine Nebut. “Towards the Extraction of Variability Information to Assist Variability Modelling of Complex Product Lines”. In: Proc. Int’l Workshop on Variability Modelling of Software-Intensive Systems (VaMoS). ACM, 2018, pp. 113–120. doi: 10.1145/3168365.3168378.
• Alexander Knüppel, Thomas Thüm, Stephan Mennicke, Jens Meinicke, and Ina Schaefer. “Is There a Mismatch Between Real-World Feature Models and Product-Line Research?” In: Proc. Europ. Software Engineering Conf./Foundations of Software Engineering (ESEC/FSE). ACM, 2017, pp. 291–302. doi: 10.1145/3106237.3106252.
• Johann Mortara and Philippe Collet. “Capturing the Diversity of Analyses on the Linux Kernel Variability”. In: Proc. Int’l Systems and Software Product Line Conf. (SPLC). ACM, 2021, pp. 160–171. doi: 10.1145/3461001.3471151.
• Anjali Sree-Kumar, Elena Planas, and Robert Clarisó. “Extracting Software Product Line Feature Models From Natural Language Specifications”. In: Proc. Int’l Systems and Software Product Line Conf. (SPLC). ACM, 2018, pp. 43–53. doi: 10.1145/3233027.3233029.

Recommender Systems for Product Line Configuration

Context

Product line configuration describes the process of deriving valid configurations, i.e. individual products, from a product line by selecting and deselecting features. As product lines can grow very large and therefore contain an enormous number of both features and valid configurations, this process can grow very complex. Recommender systems can be used to support this process by proposing the user with recommended decisions.

Goal / Research Questions

• Research and compare different approaches to recommender systems.

• Research the usage of recommender systems in product line configuration and necessary adaptions for this specific use case.

• Identify advantages and disadvantages of recommender systems in comparison to other approaches of computer-aided product line configuration.

Papers

• Juliana Alves Pereira, Matuszyk Pawel, Sebastian Krieter, Myra Spiliopoulou, and Gunter Saake. “Personalized Recommender Systems for Product-Line Configuration Processes”. In: Comput. Lang. Syst. Struct. 54 (2018), pp. 451–471. doi: 10.1016/j.cl.2018.01.003.

• Jorge Rodas-Silva, José A. Galindo, Jorge García-Gutiérrez, and David Benavides. “Selection of Software Product Line Implementation Components Using Recommender Systems: An Application to Wordpress”. In: IEEE Access 7 (2019), pp. 69226–69245. doi: 10.1109/ACCESS.2019.2918469.

• Raouia Triki, Raúl Mazo, and Camille Salinesi. “Combining Configuration and Recommendation to Enable an Interactive Guidance of Product Line Configuration”. In: Recommender Systems. John Wiley & Sons, 2014. Chap. 7, pp. 135–155. doi: 10.1002/9781119054252.ch7.

Variability Mechanisms Used in Practice

Context

Software product lines can be implemented using a wide variety of different variability mechanism, such as preprocessors, plug-in frameworks, or feature-oriented programming. All these techniques come with advantages and disadvantages, which make them feasible or not feasible for use a given use case. Thus, in practice often many factors have to be considered when developing a software product line and deciding on a variability mechanism.

Goal / Research Questions

• Identify which variability mechanism are used in practice.
• Identify and describe advantages and disadvantages of the different variability mechanisms.
• Discuss reasons that are used to justify the implementation of a particular variability mechanism.

Papers

• Thorsten Berger, Jan-Philipp Steghöfer, Tewfik Ziadi, Jacques Robin, and Jabier Martinez. “The State of Adoption and the Challenges of Systematic Variability Management in Industry”. In: Empirical Software Engineering (EMSE) 25.3 (2020), pp. 1755–1797. doi: 10.1007/S10664-019-09787-6.
• Sascha El-Sharkawy, Nozomi Yamagishi-Eichler, and Klaus Schmid. “Metrics for Analyzing Variability and its Implementation in Software Product Lines: A Systematic Literature Review”. In: J. Information and Software Technology (IST) 106 (2019), pp. 1–30. doi: 10.1016/j.infsof.2018.08.015.
• Jabier Martinez, Xhevahire Tërnava, and Tewfik Ziadi. “Software Product Line Extraction From Variability-Rich Systems: The Robocode Case Study”. In: Proc. Int’l Systems and Software Product Line Conf. (SPLC). ACM, 2018, pp. 132–142. doi: 10.1145/3233027.3233038.

Satisfiability Solving for Feature Model Analyses 

Context

In software product lines, feature models specify the set of available features as well as their constraints, such as dependencies between features. Feature models can be analyzed in many different ways such as detecting defects or computing insightful metrics for developers. Many analyses can be reduced to satisfiability solving proplems, which allows the employment of dedicated solvers.

Goal / Research Questions

• List common satisfiability-based analyses for feature models and their uses.
• Identify what types of solvers can be used to implement each analysis.
• Identify and describe circumstances that make each solver preferable to others.

Papers

• David Benavides, Sergio Segura, and Antonio Ruiz-Cortés. “Automated Analysis of Feature Models 20 Years Later: A Literature Review”. In: Information Systems 35.6 (2010), pp. 615–708. doi: 10.1016/J.IS.2010.01.001.
• Elias Kuiter, Sebastian Krieter, Chico Sundermann, Thomas Thüm, and Gunter Saake. “Tseitin or not Tseitin? The Impact of CNF Transformations on Feature-Model Analyses”. In: Proc. Int’l Conf. on Automated Software Engineering (ASE). ACM, 2022, 110:1–110:13. doi: 10.1145/3551349.3556938.
• Chico Sundermann, Elias Kuiter, Tobias Heß, Heiko Raab, Sebastian Krieter, and Thomas Thüm. “On the Benefits of Knowledge Compilation for Feature-Model Analyses”. In: Annals of Mathematics and Artificial Intelligence (AMAI) 92.5 (2023), pp. 1013–1050. doi: 10.1007/s10472-023-09906-6.

AI for Patching in Clone-and-Own Environments

Context

Clone-and-Own is a common way of handling software variability, where the source code is copied and then partially adapted for each specific product. This has the disadvantage of requiring increased developer intervention when a bug necessitates changes not only in one product's code base, but multiple adaptions that can be slightly different. Automated transfer of software patches between different variants can help to alleviate this problem by reducing the time expenditure of the involved developers.

Goal / Research Questions

• Identify common techniques that allow for the transfer of patches between different variants.

• Identify AI techniques that are used for patch transferring and research the necessary adaptations for this use-case.

• Compare the advantages and disadvantages of AI techniques to non-AI techniques.

Papers

• Xingyu Li, Zheng Zhang, Zhiyun Qian, Trent Jaeger, and Chengyu Song. “An Investigation of Patch Porting Practices of the Linux Kernel Ecosystem”. In: Proc. Working Conf. on Mining Software Repositories (MSR). ACM, 2024, 63–74. doi: 10.1145/3643991.3644902.

• Shengyi Pan, You Wang, Zhongxin Liu, Xing Hu, Xin Xia, and Shanping Li. “Automating Zero-Shot Patch Porting for Hard Forks”. In: Proc. Int’l Symposium on Software Testing and Analysis (ISSTA). ACM, 2024, 363–375. doi: 10.1145/3650212.3652134.

• Susheng Wu, Ruisi Wang, Yiheng Cao, Bihuan Chen, Zhuotong Zhou, Yiheng Huang, JunPeng Zhao, and Xin Peng. “Mystique: Automated Vulnerability Patch Porting with Semantic and Syntactic-Enhanced LLM”. In: Proc. Int’l Symposium on Foundations of Software Engineering (FSE) 2 (2025). doi: 10.1145/3715718.

Feature-Model Analysis Beyond Boolean Logic

Context

In the literature, many complex feature-model constructs have been suggested that cannot be easily translated to boolean logic. Still, most work focuses on purely boolean reasoning limiting the applicability to the complex constructs. Hence, researchers and practitioners often have a hard time identifying suitable solutions for the constructs they may want to use.

Goal / Research Questions

• Identify feature-modelling constructs that cannot be easily represented with boolean logic.
• Identify reasoning proposals that may cope with those constructs.
• Derive a mapping which proposals could be solved with which reasoning approaches.
• Discuss the gap between constructs and available solutions.

Papers

• David Benavides, Pablo Trinidad, and Antonio Ruiz-Cortés. “Using Constraint Programming to Reason on Feature Models”. In: Proc. Int’l Conf. on Software Engineering and Knowledge Engineering (SEKE). 2005, pp. 677–682. Preprint on Academia.edu.
• Paul Maximilian Bittner, Thomas Thüm, and Ina Schaefer. “SAT Encodings of the At-Most-k Constraint – A Case Study on Configuring University Courses”. In: Proc. Int’l Conf. on Software Engineering and Formal Methods (SEFM). Ed. by Peter Csaba Ölveczky and Gwen Salaün. Springer, 2019, pp. 127–144. doi: 10.1007/978-3-030-30446-1_7.
• Krzysztof Czarnecki and Chang Hwan Peter Kim. “Cardinality-Based Feature Modeling and Constraints: A Progress Report”. In: Proc. Int’l Workshop on Software Factories (SF). 2005, pp. 16–20. Preprint on CiteseerX.
• Daniel-Jesus Munoz, Mónica Pinto, Lidia Fuentes, and Don Batory. “Transforming Numerical Feature Models into Propositional Formulas and the Universal Variability Language”. In: J. Systems and Software (JSS) 204 (2023). doi: 10.1016/j.jss.2023.111770.

Material

The course material is provided in the corresponding Stud.IP course.

Supervision

This course is supervised by Paul Bittner and Thomas Thüm.

Topics

1. Developer Workflow in Variation Control Systems
2. Understanding Edits to Software Product Lines
3. Formalizing Variational Analyses with the Choice Calculus
4. Analysis Strategies for Software Product Lines
5. Methods for Finding Locations Where a Feature is Implemented
6. Clone-Based Software Reuse - Evolution and Maintenance Practices in Open Source
7. On the Difficulty of Obtaining Feature Models Retroactively
8. Web Configurators for Software Product Lines
9. Variability Mechanisms Used in Practice
10. Satisfiability Solving for Feature Model Analyses
11. Sampling Strategies for Software Product-Line Testing
12. Feature-Model Analysis Beyond Boolean Logic

Material

The course material is provided in the corresponding Stud.IP course.