Bachelorseminar

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.

Knowledge compilation (KC) describes the process of transforming a knowledge base, usually given as a formal expression such as a logical formula, into an alternative representation with better algorithmic properties. Common properties include improved succinctness (enabling more concise representations) and tractability (enabling operations in polynomial time). KC plays an important role in automated reasoning and formal verification, witnessed by the broad applications of various target languages such as ordered binary decision diagrams (OBDDs), decomposable negation normal forms (DNNFs), and prime implicants (PIs).

In this seminar, we will explore KC with various target languages, their properties, and applications. The starting point will be the prominent KC map by Darwiche and Marquis, enhanced with the role of KC in formal methods.

The specific topics and reference papers addressed in the seminar will be published in early October. The seminar is held in English or German, decided in the kick-off meeting.

Topics

1. The Knowledge Compilation Map
   • Context: Knowledge compilation trades an expensive offline transformation for efficient online reasoning. The knowledge compilation map by Darwiche and Marquis systematically compares target languages with respect to their succinctness, queries, and transformations. The map is the common reference frame for choosing a target language for a given application.
   • Goals: Read the main paper and summarize the language families, queries, and transformations covered by the map. Present the map as a compact overview (e.g., a table or diagram) and explain, using an example formula, how the choice of target language trades succinctness against tractability.
2. Ordered Binary Decision Diagrams
   • Context: Ordered binary decision diagrams (OBDDs) are a knowledge compilation language that provides an often compact representation of Boolean functions, supporting many efficient operations. Their size, however, depends critically on the chosen variable order, and finding a good order is computationally hard. This topic studies the foundations of OBDDs and how variable ordering influences their practical usability.
   • Goals: Summarize the definition of OBDDs, reducedness, canonicity, and the algorithms for applying Boolean operators. Position OBDDs in the KC map. Explain the impact of the variable order on the size of OBDDs using examples and discuss heuristics for finding good orders.
3. Decomposable Negation Normal Forms
   • Context: Decomposable negation normal form (DNNF) is a target language that is strictly more succinct than OBDDs while still supporting important queries such as consistency, clausal entailment, and model enumeration in polynomial time. Adding determinism yields d-DNNF, which additionally allows for efficient model counting. This topic studies the syntactic properties behind DNNF and how they translate to tractable reasoning.
   • Goals: Summarize the definition of DNNF and its sub-languages, and describe which queries and transformations they support efficiently. Position DNNFs and its variants in the KC map, comparing them, e.g., to OBDDs. Explain, using examples, how formulas are compiled into DNNF (e.g., via CNF-to-DNNF compilation) and discuss the role of the decomposition structure.
4. Sentential Decision Diagrams: A Canonical Bridge between OBDDs and DNNFs
   • Context: Sentential decision diagrams (SDDs) are a canonical subset of d-DNNF that strictly generalize OBDDs. They are based on vtrees instead of linear variable orders, support polynomial-time conjunction and disjunction, and can be exponentially more succinct than OBDDs. This topic studies SDDs, their structure, and the role of canonicity in knowledge compilation.
   • Goals: Summarize the definition of SDDs, vtrees, and the apply operation, and relate SDDs to OBDDs and d-DNNF. Discuss the benefits of canonicity for compilation and for downstream applications, e.g., compiling probabilistic graphical models.
5. SAT-based Knowledge Compilation
   • Context: Binary decision diagrams (BDDs) and decomposable negation normal forms (DNNFs) are prominent knowledge compilation languages. The standard algorithms to compile (reduced ordered) BDDs or DNNFs from propositional logic formulas in conjunctive normal form (CNF) is by dedicated algorithms, e.g., following a bottom-up approach in the case of BDDs. An alternative is to perform a top-down compilation by solving multiple satisfiability problems (SAT). This approach circumvents several challenges compared to bottom-up approaches and benefits from modern performant SAT solvers.
   • Goals: Summarize the definition of BDDs, ordering and reducedness, as well as DNNFs. Explain Huang and Darwiche's approach for SAT-based knowledge compilation. Compare top-down and bottom-up compilation as well as commonalities and differences to other compilation methods.
6. Prime Implicants and Prime Implicates
   • Context: Prime implicants (PIs) are the most general conjunctions of literals implying a formula, and prime implicates are their dual. Representing a formula by its prime implicants supports many queries efficiently, but the number of primes can be exponential and their computation is challenging. This topic studies algorithms for computing prime implicants, including those for non-clausal formulas, and their use in knowledge compilation.
   • Goals: Summarize the definitions and key properties of prime implicants and implicates, and their position in the knowledge compilation map. Explore applications of prime implicants and implicates in further areas of computer science. Compare algorithms for prime implicant computation (e.g., SAT-based and decision-diagram-based) and discuss their scalability.
7. Horn Theory Compilation and Approximation
   • Context: Reasoning with general propositional theories is intractable, whereas Horn theories admit linear-time inference via unit propagation. Instead of compiling a theory exactly into a tractable language, one can approximate it by Horn theories. Queries can then be answered, fully or in part, on the bounds in polynomial time, with a fall-back to the original theory only if the bounds are inconclusive. This topic studies the idea of theory approximation, its guarantees, and its limits, such as the potentially exponential size of the bounds.
   • Goals: Summarize the definitions of Horn lower and upper bounds, how they are computed, and how they are used to answer queries. Explain, with an example theory, how the bounds trade off soundness and completeness, and discuss the size and complexity results for the bounds. Position Horn approximation within the knowledge compilation map and compare it with exact compilation into target languages like DNNF or OBDD.
8. Certified Knowledge Compilation
   • Context: Knowledge compilers are complex and highly optimized tools, and their results are used to answer queries such as model counting, which are hard to double-check. A bug in a compiler can thus silently lead to wrong answers. Inspired by proof certificates for SAT solvers, certified knowledge compilation lets the compiler emit a certificate alongside the circuit, which is then validated by an independent, simple, and possibly formally verified checker. This topic studies how formal-methods techniques increase trust in knowledge compilation and how certification relates to the properties of target languages in the KC map.
   • Goals: Summarize which properties of (decision-)DNNF circuits (decomposability, determinism, equivalence to the input CNF) a checker has to establish and which of them are hard to check without additional information. Explain how certificates for knowledge compilation are constructed and checked, e.g., using clausal proofs, and illustrate this with a small example. Discuss the overhead of certification and the benefits of a formally verified checker for verified model counting.
9. Formal Verification of Bayesian Network Classifiers
   • Context: Bayesian network classifiers are used for decision making, e.g., in medical diagnosis, where formal guarantees on their behavior are desirable. Although a Bayesian network computes probabilities, the decision function of a classifier built from it is Boolean: for each input, it either makes a certain decision or not. This decision function can be compiled into an ordered decision diagram (ODD), a generalization of OBDDs. Verification questions about the classifier then become queries on the compiled representation, tractable according to the KC map. This topic studies this compilation-based approach to verifying Bayesian network classifiers.
   • Goals: Summarize how a (naive) Bayesian network classifier induces a Boolean decision function and how it is compiled into an ODD. Explain, using a small example classifier, how questions about the classifier (e.g., whether two classifiers are equivalent or whether a change of parameters affects the decisions) are answered on the ODD, and relate them to the queries of the KC map.

Supervision

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

Topics

The Dynamics of Decentralized Versus Centralized Development and Version Management

Context
When developers work on a project, it is common to use version control systems, e.g., git or svn. These version control systems can be centralized, where a central repository stores all the code, or distributed, where every developer has a local copy of the entire project. Both come with advantages and disadvantages and also change the dynamic of the workflow when used during development. In this work, the different dynamics, advantages and disadvantages in the development and the version management of centralized and decentralized version control systems should be investigated and discussed.

Papers
- Kıvanç Muşlu, Christian Bird, Nachiappan Nagappan, and Jacek Czerwonka. 2014. Transition from centralized to decentralized version control systems: a case study on reasons, barriers, and outcomes. In Proceedings of the 36th International Conference on Software Engineering (ICSE 2014). Association for Computing Machinery, New York, NY, USA, 334–344. doi.org/10.1145/2568225.2568284
- Singh, V., Aggarwal, A. (2024). Limitations of Centralized Version Control Systems (SVN) and Approaches to Its Migration to Decentralized VCS. In: Bhardwaj, A., Pandey, P.M., Misra, A. (eds) Optimization of Production and Industrial Systems. CPIE 2023. Lecture Notes in Mechanical Engineering. Springer, Singapore. doi.org/10.1007/978-981-99-8343-8_10
- C. Rodríguez-Bustos and J. Aponte, "How Distributed Version Control Systems impact open source software projects," 2012 9th IEEE Working Conference on Mining Software Repositories (MSR), Zurich, Switzerland, 2012, pp. 36-39, https://doi.org/10.1109/MSR.2012.6224297

AI in Open-Source Development Onboarding

Context
Onboarding new contributors in large open-source projects can be challenging, as the amount of new information on established workflows, coding conventions, guidelines, architectural design, etc. can be overwhelming. AI tools may help to ease the onboarding process by, for instance, automating setups, generating or summarizing documentation, and providing real-time code review and mentorship. Your goal is to research the current landscape of AI tools and techniques used for onboarding contributors to open-source projects. Identify and evaluate existing tools and approaches, describing how they work, their benefits, and limitations.

Papers
- Felipe Fronchetti, David C. Shepherd, Igor Wiese, Christoph Treude, Marco Aurélio Gerosa, and Igor Steinmacher. “Do CONTRIBUTING Files Provide Information about OSS Newcomers’ Onboarding Barriers?” In: Proc. Int’l Symposium on Foundations of Software Engineering (FSE). ACM, 2023, 16–28. doi: 10.1145/3611643.3616288.
- Ítalo Santos, Kátia Romero Felizardo, Igor Steinmacher, and Marco Aurélio Gerosa. “Software Solutions for Newcomers’ Onboarding in Software Projects: A Systematic Literature Review”. In: J. Information and Software Technology (IST) 177 (2025), p. 107568. doi: 10.1016/J.INFSOF.2024.107568.
- Xin Tan, Xiao Long, Yinghao Zhu, Lin Shi, Xiaoli Lian, and Li Zhang. “Revolutionizing Newcomers’ Onboarding Process in OSS Communities: The Future AI Mentor”. In: Proc. Int’l Symposium on Foundations of Software Engineering (FSE) 2 (2025). doi: 10.1145/3715767.

The Social and Technical Implications of Branches Versus Forks

Context
Version control is a vital part of software development. Nowadays, branching-based system, such as used by git, are the de-facto standard for structuring software evolution and maintaining multiple variants of a software. Over the last years, forks of software repositories get increasingly popular. Even though branches and forks behave similarly on a technical level, the typical use case scenarios differ considerably. The goal of this work is to examine the commonalities and differences in usage of branches and forks and assess potential pitfalls in development using the techniques.

Papers 
- Shurui Zhou, Bogdan Vasilescu, and Christian Kästner. 2019. What the fork: a study of inefficient and efficient forking practices in social coding. In Proceedings of the 2019 27th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE 2019). Association for Computing Machinery, New York, NY, USA, 350–361. https://doi.org/10.1145/3338906.3338918
- Robles, G., González-Barahona, J.M. (2012). A Comprehensive Study of Software Forks: Dates, Reasons and Outcomes. In: Hammouda, I., Lundell, B., Mikkonen, T., Scacchi, W. (eds) Open Source Systems: Long-Term Sustainability. OSS 2012. IFIP Advances in Information and Communication Technology, vol 378. Springer, Berlin, Heidelberg. https://doi.org/10.1007/978-3-642-33442-9_1
- Christian Bird and Thomas Zimmermann. 2012. Assessing the value of branches with what-if analysis. In Proceedings of the ACM SIGSOFT 20th International Symposium on the Foundations of Software Engineering (FSE '12). Association for Computing Machinery, New York, NY, USA, Article 45, 1–11. https://doi.org/10.1145/2393596.2393648

The Role and Effectiveness of Pull-Requests in Collaborative workflows

Context 
In collaborative software development, pull-requests are frequently used as a mechanism for contributing to the software. They collect a set of proposed changes to the software, and allow project maintainers to make a decision on their inclusion. The goal of this seminar work is to provide an overview on how pull-requests are generally used, how effective they are at introducing or rejecting code changes, and what influences their effectiveness.

Papers
- D. Ford, M. Behroozi, A. Serebrenik and C. Parnin, "Beyond the Code Itself: How Programmers Really Look at Pull Requests," 2019 IEEE/ACM 41st International Conference on Software Engineering: Software Engineering in Society (ICSE-SEIS), Montreal, QC, Canada, 2019, pp. 51-60, https://doi.org/10.1109/ICSE-SEIS.2019.00014
- Moreira Soares D, de Lima Júnior ML, Murta L, Plastino A. What factors influence the lifetime of pull requests?. Softw Pract Exper. 2021; 51: 1173–1193. https://doi.org/10.1002/spe.2946
- Chandra Maddila, Sai Surya Upadrasta, Chetan Bansal, Nachiappan Nagappan, Georgios Gousios, and Arie van Deursen. 2023. Nudge: Accelerating Overdue Pull Requests toward Completion. ACM Trans. Softw. Eng. Methodol. 32, 2, Article 35 (March 2023), 30 pages. https://doi.org/10.1145/3544791

The Differences Between Structured, Semi-Structured, and Unstructured Merging Techniques 

Context
Version control systems are helpful tools in tracking and backing up changes within coding projects and support the collaboration with other developers. However, by working with other developers on the same project simultaneously merge conflicts within a file are inevitable. To this end, merging techniques help in resolving those conflicts. Dependent on the degree of which these techniques take the underlying syntax of the conflicting files into account, they can be classify into structured, semi-Structured, and unstructured merging techniques. Your goal is to research which techniques exists in the current literature and describe how they work, their benefits, and limitations.

Papers
- T. Mens, "A state-of-the-art survey on software merging," in IEEE Transactions on Software Engineering, vol. 28, no. 5, pp. 449-462, May 2002, https://doi.org/10.1109/TSE.2002.1000449
- G. Cavalcanti, P. Borba, G. Seibt and S. Apel, "The Impact of Structure on Software Merging: Semistructured Versus Structured Merge," 2019 34th IEEE/ACM International Conference on Automated Software Engineering (ASE), San Diego, CA, USA, 2019, pp. 1002-1013, https://doi.org/10.1109/ASE.2019.00097
- Guilherme Cavalcanti, Paulo Borba, and Paola Accioly. 2017. Evaluating and improving semistructured merge. Proc. ACM Program. Lang. 1, OOPSLA, Article 59 (October 2017), 27 pages. https://doi.org/10.1145/3133883

AI-based Code Explanation in Code Reviews

Context
Code reviews are widely considered as valuable technique to improve code quality and share knowledge about (anti-)patterns. However, manual code reviews are rather time-consuming. Consequently, there has been a rise of AI-powered code-review techniques that aim to reduce the overhead for developers. The goal of this work is to compare existing AI-based code review techniques and categorize them regarding their share of automated support and manual work.

Papers
- Lo Heander, Emma Söderberg, and Christofer Rydenfält. “Support, Not Automation: Towards AI-supported Code Review For Code Quality and Beyond”. In: Proc. Int’l Symposium on Foundations of Software Engineering (FSE). ACM, 2025, 591–595. doi: 10.1145/3696630.3728505.
- Juho Leinonen, Paul Denny, Stephen MacNeil, Sami Sarsa, Seth Bernstein, Joanne Kim, Andrew Tran, and Arto Hellas. “Comparing Code Explanations Created by Students and Large Language Models”. In: Proc. Conf. on Innovation and Technology in Computer Science Education (ITiCSE). ACM, 2023, 124–130. doi: 10.1145/3587102.3588785.
- Daye Nam, Andrew Macvean, Vincent Hellendoorn, Bogdan Vasilescu, and Brad Myers. “Using an LLM to Help With Code Understanding”. In: Proc. Int’l Conf. on Software Engineering (ICSE). ACM, 2024. doi: 10.1145/3597503.3639187.

Maintenance of Software Forks

Context 
When creating different variants of a software project, it is common to clone or fork the project and make adaptations for a new variant on the cloned code. However, when fixing bug or making updates in one variant that apply to all variants, it is hard to integrate these changes into every cloned and adapted existing variant. The goal of this work is to discuss the idea behind software clones and forks, the problem(s) of maintaining them, and how they can be addressed.

Papers
- J. Businge, M. Openja, S. Nadi, E. Bainomugisha and T. Berger, "Clone-Based Variability Management in the Android Ecosystem," 2018 IEEE International Conference on Software Maintenance and Evolution (ICSME), Madrid, Spain, 2018, pp. 625-634, https://doi.org/10.1109/ICSME.2018.00072
- Poedjadevie Kadjel Ramkisoen, John Businge, Brent van Bladel, Alexandre Decan, Serge Demeyer, Coen De Roover, and Foutse Khomh. 2022. PaReco: patched clones and missed patches among the divergent variants of a software family. In Proceedings of the 30th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE 2022). Association for Computing Machinery, New York, NY, USA, 646–658. https://doi.org/10.1145/3540250.3549112
- Panuchart Bunyakiati and Chadarat Phipathananunth. 2017. Cherry-picking of code commits in long-running, multi-release software. In Proceedings of the 2017 11th Joint Meeting on Foundations of Software Engineering (ESEC/FSE 2017). Association for Computing Machinery, New York, NY, USA, 994–998. https://doi.org/10.1145/3106237.3122818

AI as a Partner in Pair Programming

Context
Pair programming is a common example of Extreme Programming, where two developers work on the same code at one shared workstation. However, as developer hours are expensive, the trend to use large language models instead of a second human developer arose. It is currently unclear how this substitution impacts both developer training and code quality. Your goal is to identify common and possible applications of generative AI for pair programming and to research the changes on code quality and the impact on developer training / knowledge transfer

Papers
- Jiangyue Liu and Siran Li. “Toward Artificial Intelligence-Human Paired Programming: A Review of the Educational Applications and Research on Artificial Intelligence Code-Generation Tools”. In: J. Educational Computing Research 62.5 (2024), pp. 1165–1195. doi: 10.1177/07356331241240460.
- Nathalia Nascimento, Paulo Alencar, and Donald Cowan. “Artificial Intelligence vs. Software Engineers: An Empirical Study on Performance and Efficiency using ChatGPT”. In: Proc. Conf. Centre for Advanced Studies on Collaborative Research (CASCON). IBM Corp., 2023, 24–33. doi: 10.5555/3615924.3615927.
- Alisa Carla Welter, Niklas Schneider, Tobias Dick, Kallistos Weis, Christof Tinnes, Marvin Wyrich, and Sven Apel. “An Empirical Study of Knowledge Transfer in AI Pair Programming”. In: Proc. Int’l Conf. on Automated Software Engineering (ASE). To appear. ACM, 2025.

Mailing List-Based Collaboration in Large-Scale Open-Source Software Projects

Context
Large-scale open-source software projects such as the Linux Kernel often rely on mailing lists as a medium for collaboration. They are used to discuss features, coordinate development efforts, present contributions, and submit patches. The goal of this seminar work is to provide an overview of how such mailing lists are strucuted, moderated, and administrated, who uses them, and for what, and how they enable collaboration in projects with multiple thousand developers.

- Y. Jiang, B. Adams and D. M. German, "Will my patch make it? And how fast? Case study on the Linux kernel," 2013 10th Working Conference on Mining Software Repositories (MSR), San Francisco, CA, USA, 2013, pp. 101-110, doi: 10.1109/MSR.2013.6624016.
- A. Guzzi, A. Bacchelli, M. Lanza, M. Pinzger and A. van Deursen, "Communication in open source software development mailing lists," 2013 10th Working Conference on Mining Software Repositories (MSR), San Francisco, CA, USA, 2013, pp. 277-286, doi: 10.1109/MSR.2013.6624039.
- K. Nakakoji, K. Yamada and E. Giaccardi, "Understanding the nature of collaboration in open-source software development," 12th Asia-Pacific Software Engineering Conference (APSEC'05), Taipei, Taiwan, 2005, pp. 8 pp.-, doi: 10.1109/APSEC.2005.108.

Automated Sentiment Analysis in Software Teams

Context
"Sentiment analysis" describes the analysis of emotions and sentiments for example in development teams. Based on commit messages it is possible to detect the level of comfort various developers have while working with each other. There are some difficulties to apply general text models to the software engineering domain (kill child process, for example), which are a current point of research. Your goal is to give an overview of sentiment analysis and describe challenges when applying transformer models as well as challenges in the software engineering domain.

Papers
- Marc Herrmann, Martin Obaidi, Larissa Chazette, and Jil Klünder. “On the Subjectivity of Emotions in Software Projects: How Reliable Are Pre-Labeled Data Sets for Sentiment Analysis?” In: J. Systems and Software (JSS) 193.C (2022). doi: 10.1016/j.jss.2022.111448.
- Bin Lin, Fiorella Zampetti, Gabriele Bavota, Massimiliano Di Penta, Michele Lanza, and Rocco Oliveto. “Sentiment Analysis for Software Engineering: How Far Can We Go?” In: Proc. Int’l Conf. on Software Engineering (ICSE). ACM, 2018, 94–104. doi: 10.1145/3180155.3180195.
- Ting Zhang, Bowen Xu, Ferdian Thung, Stefanus Agus Haryono, David Lo, and Lingxiao Jiang. “Sentiment Analysis for Software Engineering: How Far Can Pre-trained Transformer Models Go?” In: Proc. Int’l Conf. on Software Maintenance and Evolution (ICSME). IEEE, 2020, pp. 70–80. doi: 10.1109/ICSME46990.2020.00017.

Automated Testing -- Are LLMs the new Holy Grail of Software Qualitsy Assurance?

Context
Software quality assurance describes processes that ensure and improve the quality of developed software and is especially important for safety-critical systems. However, it is a very complex and therefore expensive process. Motivated by that, there is currently great interest into using large language models to accelerate and improve software quality assurance. Your goal is to identify common and possible applications of generative AI for software testing in the context of software quality assurance processes, research advantages and disadvantages of automatically generated test suits for software systems, and evaluate and compare new LLM-based with traditional test generation approaches

Papers
- Shreya Bhatia, Tarushi Gandhi, Dhruv Kumar, Pankaj Jalote. "Unit Test Generation using Generative AI : A Comparative PerformanceAnalysis of Autogeneration Tools".  International Workshop on Large Language Models for Code (2024). https://doi.org/10.1145/3643795.3648396
- Saswat Anand, Edmund K. Burke, Tsong Yueh Chen, John Clark, Myra B. Cohen,Wolfgang Grieskamp, Mark Harman, Mary Jean Harrold, Phil McMinn. "An orchestrated survey of methodologies for automated software test case generation". The Journal of Systems and Software 86 (2013). https://doi.org/10.1016/j.jss.2013.02.061
- Chao Wang, Hao He, Uma Pal, Darko Marinov, and Minghui Zhou. "QuickCheck: A Lightweight Tool for Random Testing of Haskell Programs". Proceedings of the Fifth ACM SIGPLAN International Conference on Functional Programming (2000). https://doi.org/10.1145/357766.351266

Impact of AI on Teaching Programming to Students

Context
The use of AI tools has become more and more common for students. While there is much to gain from a versatile tool like this, there is also criticism on how it is used. Educators face the challenge on how to detect and grade AI-written solutions and the question if students retain knowledge primarily gained through AI needs to be studied. Your goal is to describe the common usage of LLMs when supporting students that learn how to program, outline the challenge of AI-based cheating and discuss the impact on the knowledge gain students have if they rely heavily on AI support.

Papers
- Tran Tri Dang, Huo-Chong Ling, and Ngoc Quang Tran. “Combating ChatGPT-Based Programming Test Cheating — An Evaluation Using Public Problems”. In: Proc. Int’l Conf. on Computer Science and Technologies in Education (CSTE). IEEE, 2024, pp. 161–165. doi: 10.1109/CSTE62025.2024.00037.
- Christian Rahe and Walid Maalej. “How Do Programming Students Use Generative AI?” In: Proc. Int’l Symposium on Foundations of Software Engineering (FSE) 2 (2025). doi: 10.1145/3715762.
- Yi-Miao Yan, Chuang-Qi Chen, Yang-Bang Hu, and Xin-Dong Ye. “LLM-Based Collaborative Programming: Impact on Students’ Computational Thinking and Self-Efficacy”. In: J. Humanities and Social Sciences Communications 12.1 (2025), p. 149. doi: 10.1057/s41599-025-04471-1.

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

The Dynamics of Decentralized Versus Centralized Development and Version Management

• Kıvanç Muşlu, Christian Bird, Nachiappan Nagappan, and Jacek Czerwonka. 2014. Transition from centralized to decentralized version control systems: a case study on reasons, barriers, and outcomes. In Proceedings of the 36th International Conference on Software Engineering (ICSE 2014). Association for Computing Machinery, New York, NY, USA, 334–344. https://doi.org/10.1145/2568225.2568284
• Singh, V., Aggarwal, A. (2024). Limitations of Centralized Version Control Systems (SVN) and Approaches to Its Migration to Decentralized VCS. In: Bhardwaj, A., Pandey, P.M., Misra, A. (eds) Optimization of Production and Industrial Systems. CPIE 2023. Lecture Notes in Mechanical Engineering. Springer, Singapore. https://doi.org/10.1007/978-981-99-8343-8_10
• C. Rodríguez-Bustos and J. Aponte, "How Distributed Version Control Systems impact open source software projects," 2012 9th IEEE Working Conference on Mining Software Repositories (MSR), Zurich, Switzerland, 2012, pp. 36-39, https://doi.org/10.1109/MSR.2012.6224297

AI in Open-Source Development Onboarding

• Felipe Fronchetti, David C. Shepherd, Igor Wiese, Christoph Treude, Marco Aurélio Gerosa, and Igor Steinmacher. “Do CONTRIBUTING Files Provide Information about OSS Newcomers’ Onboarding Barriers?” In: Proc. Int’l Symposium on Foundations of Software Engineering (FSE). ACM, 2023, 16–28. doi: 10.1145/3611643.3616288.

• Ítalo Santos, Kátia Romero Felizardo, Igor Steinmacher, and Marco Aurélio Gerosa. “Software Solutions for Newcomers’ Onboarding in Software Projects: A Systematic Literature Review”. In: J. Information and Software Technology (IST) 177 (2025), p. 107568. doi: 10.1016/J.INFSOF.2024.107568.

• Xin Tan, Xiao Long, Yinghao Zhu, Lin Shi, Xiaoli Lian, and Li Zhang. “Revolutionizing Newcomers’ Onboarding Process in OSS Communities: The Future AI Mentor”. In: Proc. Int’l Symposium on Foundations of Software Engineering (FSE) 2 (2025). doi: 10.1145/3715767.

The Social and Technical Implications of Branches Versus Forks

• Shurui Zhou, Bogdan Vasilescu, and Christian Kästner. 2019. What the fork: a study of inefficient and efficient forking practices in social coding. In Proceedings of the 2019 27th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE 2019). Association for Computing Machinery, New York, NY, USA, 350–361. https://doi.org/10.1145/3338906.3338918
• Robles, G., González-Barahona, J.M. (2012). A Comprehensive Study of Software Forks: Dates, Reasons and Outcomes. In: Hammouda, I., Lundell, B., Mikkonen, T., Scacchi, W. (eds) Open Source Systems: Long-Term Sustainability. OSS 2012. IFIP Advances in Information and Communication Technology, vol 378. Springer, Berlin, Heidelberg. https://doi.org/10.1007/978-3-642-33442-9_1
• Christian Bird and Thomas Zimmermann. 2012. Assessing the value of branches with what-if analysis. In Proceedings of the ACM SIGSOFT 20th International Symposium on the Foundations of Software Engineering (FSE '12). Association for Computing Machinery, New York, NY, USA, Article 45, 1–11. https://doi.org/10.1145/2393596.2393648

The Role and Effectiveness of Pull-Requests in Collaborative Workflows

• D. Ford, M. Behroozi, A. Serebrenik and C. Parnin, "Beyond the Code Itself: How Programmers Really Look at Pull Requests," 2019 IEEE/ACM 41st International Conference on Software Engineering: Software Engineering in Society (ICSE-SEIS), Montreal, QC, Canada, 2019, pp. 51-60, https://doi.org/10.1109/ICSE-SEIS.2019.00014
• Moreira Soares D, de Lima Júnior ML, Murta L, Plastino A. What factors influence the lifetime of pull requests?. Softw Pract Exper. 2021; 51: 1173–1193. https://doi.org/10.1002/spe.2946
• Chandra Maddila, Sai Surya Upadrasta, Chetan Bansal, Nachiappan Nagappan, Georgios Gousios, and Arie van Deursen. 2023. Nudge: Accelerating Overdue Pull Requests toward Completion. ACM Trans. Softw. Eng. Methodol. 32, 2, Article 35 (March 2023), 30 pages. https://doi.org/10.1145/3544791

The Differences Between Structured, Semi-Structured, and Unstructured Merging Techniques 

• T. Mens, "A state-of-the-art survey on software merging," in IEEE Transactions on Software Engineering, vol. 28, no. 5, pp. 449-462, May 2002, https://doi.org/10.1109/TSE.2002.1000449
• G. Cavalcanti, P. Borba, G. Seibt and S. Apel, "The Impact of Structure on Software Merging: Semistructured Versus Structured Merge," 2019 34th IEEE/ACM International Conference on Automated Software Engineering (ASE), San Diego, CA, USA, 2019, pp. 1002-1013, https://doi.org/10.1109/ASE.2019.00097
• Guilherme Cavalcanti, Paulo Borba, and Paola Accioly. 2017. Evaluating and improving semistructured merge. Proc. ACM Program. Lang. 1, OOPSLA, Article 59 (October 2017), 27 pages. https://doi.org/10.1145/3133883

AI-based Code Explanation in Code Reviews

• Lo Heander, Emma Söderberg, and Christofer Rydenfält. “Support, Not Automation: Towards AI-supported Code Review For Code Quality and Beyond”. In: Proc. Int’l Symposium on Foundations of Software Engineering (FSE). ACM, 2025, 591–595. doi: 10.1145/3696630.3728505.
• Juho Leinonen, Paul Denny, Stephen MacNeil, Sami Sarsa, Seth Bernstein, Joanne Kim, Andrew Tran, and Arto Hellas. “Comparing Code Explanations Created by Students and Large Language Models”. In: Proc. Conf. on Innovation and Technology in Computer Science Education (ITiCSE). ACM, 2023, 124–130. doi: 10.1145/3587102.3588785.
• Daye Nam, Andrew Macvean, Vincent Hellendoorn, Bogdan Vasilescu, and Brad Myers. “Using an LLM to Help With Code Understanding”. In: Proc. Int’l Conf. on Software Engineering (ICSE). ACM, 2024. doi: 10.1145/3597503.3639187.

Maintenance of Software Forks

• J. Businge, M. Openja, S. Nadi, E. Bainomugisha and T. Berger, "Clone-Based Variability Management in the Android Ecosystem," 2018 IEEE International Conference on Software Maintenance and Evolution (ICSME), Madrid, Spain, 2018, pp. 625-634, https://doi.org/10.1109/ICSME.2018.00072
• Poedjadevie Kadjel Ramkisoen, John Businge, Brent van Bladel, Alexandre Decan, Serge Demeyer, Coen De Roover, and Foutse Khomh. 2022. PaReco: patched clones and missed patches among the divergent variants of a software family. In Proceedings of the 30th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE 2022). Association for Computing Machinery, New York, NY, USA, 646–658. https://doi.org/10.1145/3540250.3549112
• Panuchart Bunyakiati and Chadarat Phipathananunth. 2017. Cherry-picking of code commits in long-running, multi-release software. In Proceedings of the 2017 11th Joint Meeting on Foundations of Software Engineering (ESEC/FSE 2017). Association for Computing Machinery, New York, NY, USA, 994–998. https://doi.org/10.1145/3106237.3122818

Software Composition Analysis and its Importance for Software Security 

• Zerouali, A., Mens, T., Decan, A. et al. On the impact of security vulnerabilities in the npm and RubyGems dependency networks. Empir Software Eng 27, 107 (2022). https://doi.org/10.1007/s10664-022-10154-1
• Nasif Imtiaz, Seaver Thorn, and Laurie Williams. 2021. A comparative study of vulnerability reporting by software composition analysis tools. In Proceedings of the 15th ACM / IEEE International Symposium on Empirical Software Engineering and Measurement (ESEM) (ESEM '21). Association for Computing Machinery, New York, NY, USA, Article 5, 1–11. https://doi.org/10.1145/3475716.3475769
• Laura Bottner, Artur Hermann, Jeremias Eppler, Thomas Thüm, and Frank Kargl. 2023. Evaluation of Free and Open Source Tools for Automated Software Composition Analysis. In Proceedings of the 7th ACM Computer Science in Cars Symposium (CSCS '23). Association for Computing Machinery, New York, NY, USA, Article 3, 1–11. https://doi.org/10.1145/3631204.3631862

Existing Practices for Commenting and Documentation of Software Projects

• Rani, P., Panichella, S., Leuenberger, M. et al. What do class comments tell us? An investigation of comment evolution and practices in Pharo Smalltalk. Empir Software Eng 26, 112 (2021). https://doi.org/10.1007/s10664-021-09981-5
• Emad Aghajani, Csaba Nagy, Mario Linares-Vásquez, Laura Moreno, Gabriele Bavota, Michele Lanza, and David C. Shepherd. 2020. Software documentation: the practitioners' perspective. In Proceedings of the ACM/IEEE 42nd International Conference on Software Engineering (ICSE '20). Association for Computing Machinery, New York, NY, USA, 590–601. https://doi.org/10.1145/3377811.3380405
• Chao Wang, Hao He, Uma Pal, Darko Marinov, and Minghui Zhou. 2023. Suboptimal Comments in Java Projects: From Independent Comment Changes to Commenting Practices. ACM Trans. Softw. Eng. Methodol. 32, 2, Article 45 (March 2023), 33 pages. https://doi.org/10.1145/3546949

Automated Sentiment Analysis in Software Teams

• Marc Herrmann, Martin Obaidi, Larissa Chazette, and Jil Klünder. “On the Subjectivity of Emotions in Software Projects: How Reliable Are Pre-Labeled Data Sets for Sentiment Analysis?” In: J. Systems and Software (JSS) 193.C (2022). doi: 10.1016/j.jss.2022.111448.
• Bin Lin, Fiorella Zampetti, Gabriele Bavota, Massimiliano Di Penta, Michele Lanza, and Rocco Oliveto. “Sentiment Analysis for Software Engineering: How Far Can We Go?” In: Proc. Int’l Conf. on Software Engineering (ICSE). ACM, 2018, 94–104. doi: 10.1145/3180155.3180195.
• Ting Zhang, Bowen Xu, Ferdian Thung, Stefanus Agus Haryono, David Lo, and Lingxiao Jiang. “Sentiment Analysis for Software Engineering: How Far Can Pre-trained Transformer Models Go?” In: Proc. Int’l Conf. on Software Maintenance and Evolution (ICSME). IEEE, 2020, pp. 70–80. doi: 10.1109/ICSME46990.2020.00017.

Continuous Integration, Delivery, and Deployment in Collaborative Software Development 

• Michael Hilton, Timothy Tunnell, Kai Huang, Darko Marinov, and Danny Dig. 2016. Usage, costs, and benefits of continuous integration in open-source projects. In Proceedings of the 31st IEEE/ACM International Conference on Automated Software Engineering (ASE '16). Association for Computing Machinery, New York, NY, USA, 426–437. https://doi.org/10.1145/2970276.2970358
• Mojtaba Shahin, Mansooreh Zahedi, Muhammad Ali Babar, and Liming Zhu. 2017. Adopting Continuous Delivery and Deployment: Impacts on Team Structures, Collaboration and Responsibilities. In Proceedings of the 21st International Conference on Evaluation and Assessment in Software Engineering (EASE '17). Association for Computing Machinery, New York, NY, USA, 384–393. https://doi.org/10.1145/3084226.3084263
• R. K. Gupta, M. Venkatachalapathy and F. K. Jeberla, "Challenges in Adopting Continuous Delivery and DevOps in a Globally Distributed Product Team: A Case Study of a Healthcare Organization," 2019 ACM/IEEE 14th International Conference on Global Software Engineering (ICGSE), Montreal, QC, Canada, 2019, pp. 30-34, https://doi.org/10.1109/ICGSE.2019.00020

Impact of AI on Teaching Programming to Students

• Tran Tri Dang, Huo-Chong Ling, and Ngoc Quang Tran. “Combating ChatGPT-Based Programming Test Cheating — An Evaluation Using Public Problems”. In: Proc. Int’l Conf. on Computer Science and Technologies in Education (CSTE). IEEE, 2024, pp. 161–165. doi: 10.1109/CSTE62025.2024.00037.
• Christian Rahe and Walid Maalej. “How Do Programming Students Use Generative AI?” In: Proc. Int’l Symposium on Foundations of Software Engineering (FSE) 2 (2025). doi: 10.1145/3715762.
• Yi-Miao Yan, Chuang-Qi Chen, Yang-Bang Hu, and Xin-Dong Ye. “LLM-Based Collaborative Programming: Impact on Students’ Computational Thinking and Self-Efficacy”. In: J. Humanities and Social Sciences Communications 12.1 (2025), p. 149. doi: 10.1057/s41599-025-04471-1.

(Automated) Team Recommendation for Collaborative Software Development 

• Tuarob, S., Assavakamhaenghan, N., Tanaphantaruk, W. et al. Automatic team recommendation for collaborative software development. Empir Software Eng 26, 64 (2021). https://doi.org/10.1007/s10664-021-09966-4
• Assavakamhaenghan, N., Tanaphantaruk, W., Suwanworaboon, P. et al. Quantifying effectiveness of team recommendation for collaborative software development. Autom Softw Eng 29, 51 (2022). https://doi.org/10.1007/s10515-022-00357-7
• Pisol Ruenin, Morakot Choetkiertikul, Akara Supratak, Suppawong Tuarob, TeReKG: A temporal collaborative knowledge graph framework for software team recommendation, Knowledge-Based Systems, Volume 289, 2024, 111492, ISSN 0950-7051, https://doi.org/10.1016/j.knosys.2024.111492

AI as a Partner in Pair Programming

• Jiangyue Liu and Siran Li. “Toward Artificial Intelligence-Human Paired Programming: A Review of the Educational Applications and Research on Artificial Intelligence Code-Generation Tools”. In: J. Educational Computing Research 62.5 (2024), pp. 1165–1195. doi: 10.1177/07356331241240460.
• Nathalia Nascimento, Paulo Alencar, and Donald Cowan. “Artificial Intelligence vs. Software Engineers: An Empirical Study on Performance and Efficiency using ChatGPT”. In: Proc. Conf. Centre for Advanced Studies on Collaborative Research (CASCON). IBM Corp., 2023, 24–33. doi: 10.5555/3615924.3615927.
• Alisa Carla Welter, Niklas Schneider, Tobias Dick, Kallistos Weis, Christof Tinnes, Marvin Wyrich, and Sven Apel. “An Empirical Study of Knowledge Transfer in AI Pair Programming”. In: Proc. Int’l Conf. on Automated Software Engineering (ASE). To appear. ACM, 2025.

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. The Dynamics of Decentralized Versus Centralized Development and Version Management
   
   - Kıvanç Muşlu, Christian Bird, Nachiappan Nagappan, and Jacek Czerwonka. 2014. Transition from centralized to decentralized version control systems: a case study on reasons, barriers, and outcomes. In Proceedings of the 36th International Conference on Software Engineering (ICSE 2014). Association for Computing Machinery, New York, NY, USA, 334–344. doi.org/10.1145/2568225.2568284
   - Singh, V., Aggarwal, A. (2024). Limitations of Centralized Version Control Systems (SVN) and Approaches to Its Migration to Decentralized VCS. In: Bhardwaj, A., Pandey, P.M., Misra, A. (eds) Optimization of Production and Industrial Systems. CPIE 2023. Lecture Notes in Mechanical Engineering. Springer, Singapore. doi.org/10.1007/978-981-99-8343-8_10
   - C. Rodríguez-Bustos and J. Aponte, "How Distributed Version Control Systems impact open source software projects," 2012 9th IEEE Working Conference on Mining Software Repositories (MSR), Zurich, Switzerland, 2012, pp. 36-39, doi.org/10.1109/MSR.2012.6224297
2. Comparative Studies of Git and Alternative Version Control Systems
   
   - C. Costa and L. Murta, "Version Control in Distributed Software Development: A Systematic Mapping Study," 2013 IEEE 8th International Conference on Global Software Engineering, Bari, Italy, 2013, pp. 90-99, doi.org/10.1109/ICGSE.2013.19
   - S. Just, K. Herzig, J. Czerwonka and B. Murphy, "Switching to Git: The Good, the Bad, and the Ugly," 2016 IEEE 27th International Symposium on Software Reliability Engineering (ISSRE), Ottawa, ON, Canada, 2016, pp. 400-411, doi.org/10.1109/ISSRE.2016.38
   - Ogayar-Anguita, Carlos J., Alfonso López-Ruiz, Rafael J. Segura-Sánchez, and Antonio J. Rueda-Ruiz. 2023. "A Version Control System for Point Clouds" Remote Sensing 15, no. 18: 4635. doi.org/10.3390/rs15184635
3. The Social and Technical Implications of Branches Versus Forks
   
   - Shurui Zhou, Bogdan Vasilescu, and Christian Kästner. 2019. What the fork: a study of inefficient and efficient forking practices in social coding. In Proceedings of the 2019 27th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE 2019). Association for Computing Machinery, New York, NY, USA, 350–361. doi.org/10.1145/3338906.3338918
   - Robles, G., González-Barahona, J.M. (2012). A Comprehensive Study of Software Forks: Dates, Reasons and Outcomes. In: Hammouda, I., Lundell, B., Mikkonen, T., Scacchi, W. (eds) Open Source Systems: Long-Term Sustainability. OSS 2012. IFIP Advances in Information and Communication Technology, vol 378. Springer, Berlin, Heidelberg. doi.org/10.1007/978-3-642-33442-9_1
   - Christian Bird and Thomas Zimmermann. 2012. Assessing the value of branches with what-if analysis. In Proceedings of the ACM SIGSOFT 20th International Symposium on the Foundations of Software Engineering (FSE '12). Association for Computing Machinery, New York, NY, USA, Article 45, 1–11. doi.org/10.1145/2393596.2393648
4. The Role and Effectiveness of Pull-Requests in Collaborative Workflows
   
   - D. Ford, M. Behroozi, A. Serebrenik and C. Parnin, "Beyond the Code Itself: How Programmers Really Look at Pull Requests," 2019 IEEE/ACM 41st International Conference on Software Engineering: Software Engineering in Society (ICSE-SEIS), Montreal, QC, Canada, 2019, pp. 51-60, doi.org/10.1109/ICSE-SEIS.2019.00014
   - Moreira Soares D, de Lima Júnior ML, Murta L, Plastino A. What factors influence the lifetime of pull requests?. Softw Pract Exper. 2021; 51: 1173–1193. doi.org/10.1002/spe.2946
   - Chandra Maddila, Sai Surya Upadrasta, Chetan Bansal, Nachiappan Nagappan, Georgios Gousios, and Arie van Deursen. 2023. Nudge: Accelerating Overdue Pull Requests toward Completion. ACM Trans. Softw. Eng. Methodol. 32, 2, Article 35 (March 2023), 30 pages. doi.org/10.1145/3544791
5. The Differences Between Structured, Semi-Structured, and Unstructured Merging Techniques
   
   - T. Mens, "A state-of-the-art survey on software merging," in IEEE Transactions on Software Engineering, vol. 28, no. 5, pp. 449-462, May 2002, doi.org/10.1109/TSE.2002.1000449
   - G. Cavalcanti, P. Borba, G. Seibt and S. Apel, "The Impact of Structure on Software Merging: Semistructured Versus Structured Merge," 2019 34th IEEE/ACM International Conference on Automated Software Engineering (ASE), San Diego, CA, USA, 2019, pp. 1002-1013, doi.org/10.1109/ASE.2019.00097
   - Guilherme Cavalcanti, Paulo Borba, and Paola Accioly. 2017. Evaluating and improving semistructured merge. Proc. ACM Program. Lang. 1, OOPSLA, Article 59 (October 2017), 27 pages. doi.org/10.1145/3133883
6. Predicting Future Merge Conflicts
    

   - Caius Brindescu, Iftekhar Ahmed, Rafael Leano, and Anita Sarma. 2020. Planning for untangling: predicting the difficulty of merge conflicts. In Proceedings of the ACM/IEEE 42nd International Conference on Software Engineering (ICSE '20). Association for Computing Machinery, New York, NY, USA, 801–811. doi.org/10.1145/3377811.3380344
   - M. Owhadi-Kareshk, S. Nadi and J. Rubin, "Predicting Merge Conflicts in Collaborative Software Development," 2019 ACM/IEEE International Symposium on Empirical Software Engineering and Measurement (ESEM), Porto de Galinhas, Brazil, 2019, pp. 1-11, doi.org/10.1109/ESEM.2019.8870173
   - Klissiomara Dias, Paulo Borba, Marcos Barreto, Understanding predictive factors for merge conflicts, Information and Software Technology, Volume 121, 2020, 106256, ISSN 0950-5849, doi.org/10.1016/j.infsof.2020.106256

7. Maintenance of Software Forks
   
   - J. Businge, M. Openja, S. Nadi, E. Bainomugisha and T. Berger, "Clone-Based Variability Management in the Android Ecosystem," 2018 IEEE International Conference on Software Maintenance and Evolution (ICSME), Madrid, Spain, 2018, pp. 625-634, doi.org/10.1109/ICSME.2018.00072
   - Poedjadevie Kadjel Ramkisoen, John Businge, Brent van Bladel, Alexandre Decan, Serge Demeyer, Coen De Roover, and Foutse Khomh. 2022. PaReco: patched clones and missed patches among the divergent variants of a software family. In Proceedings of the 30th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE 2022). Association for Computing Machinery, New York, NY, USA, 646–658. doi.org/10.1145/3540250.3549112
   - Panuchart Bunyakiati and Chadarat Phipathananunth. 2017. Cherry-picking of code commits in long-running, multi-release software. In Proceedings of the 2017 11th Joint Meeting on Foundations of Software Engineering (ESEC/FSE 2017). Association for Computing Machinery, New York, NY, USA, 994–998. doi.org/10.1145/3106237.3122818
8. Software Composition Analysis and its Importance for Software Security
   
   - Zerouali, A., Mens, T., Decan, A. et al. On the impact of security vulnerabilities in the npm and RubyGems dependency networks. Empir Software Eng 27, 107 (2022). doi.org/10.1007/s10664-022-10154-1
   - Nasif Imtiaz, Seaver Thorn, and Laurie Williams. 2021. A comparative study of vulnerability reporting by software composition analysis tools. In Proceedings of the 15th ACM / IEEE International Symposium on Empirical Software Engineering and Measurement (ESEM) (ESEM '21). Association for Computing Machinery, New York, NY, USA, Article 5, 1–11. doi.org/10.1145/3475716.3475769
   - Laura Bottner, Artur Hermann, Jeremias Eppler, Thomas Thüm, and Frank Kargl. 2023. Evaluation of Free and Open Source Tools for Automated Software Composition Analysis. In Proceedings of the 7th ACM Computer Science in Cars Symposium (CSCS '23). Association for Computing Machinery, New York, NY, USA, Article 3, 1–11. doi.org/10.1145/3631204.3631862
9. Existing Practices for Commenting and Documentation of Software Projects
   
   - Rani, P., Panichella, S., Leuenberger, M. et al. What do class comments tell us? An investigation of comment evolution and practices in Pharo Smalltalk. Empir Software Eng 26, 112 (2021). doi.org/10.1007/s10664-021-09981-5
   - Emad Aghajani, Csaba Nagy, Mario Linares-Vásquez, Laura Moreno, Gabriele Bavota, Michele Lanza, and David C. Shepherd. 2020. Software documentation: the practitioners' perspective. In Proceedings of the ACM/IEEE 42nd International Conference on Software Engineering (ICSE '20). Association for Computing Machinery, New York, NY, USA, 590–601. doi.org/10.1145/3377811.3380405
   - Chao Wang, Hao He, Uma Pal, Darko Marinov, and Minghui Zhou. 2023. Suboptimal Comments in Java Projects: From Independent Comment Changes to Commenting Practices. ACM Trans. Softw. Eng. Methodol. 32, 2, Article 45 (March 2023), 33 pages. doi.org/10.1145/3546949
10. Communication in Collaborative Software Development
    
    - J. F. DeFranco and P. A. Laplante, "Review and Analysis of Software Development Team Communication Research," in IEEE Transactions on Professional Communication, vol. 60, no. 2, pp. 165-182, June 2017, doi.org/10.1109/TPC.2017.2656626
    - Junior, I.d.F., Marczak, S., Santos, R. et al. C2M: a maturity model for the evaluation of communication in distributed software development. Empir Software Eng 27, 188 (2022). doi.org/10.1007/s10664-022-10211-9
    - Adriano Neves de Souza, Sírius Thadeu Ferreira da Silva, Juliana Baptista dos Santos França, Angélica Fonseca da Silva Dias, Jonice Oliveira, and Adriana S. Vivacqua. 2022. Communication Channels and their Challenges: an Analysis of Software Development Teams during the COVID-19 Pandemic. Proc. ACM Hum.-Comput. Interact. 7, GROUP, Article 3 (January 2023), 26 pages. doi.org/10.1145/3567553
11. Continuous Integration, Delivery, and Deployment in Collaborative Software Development
    
    - Michael Hilton, Timothy Tunnell, Kai Huang, Darko Marinov, and Danny Dig. 2016. Usage, costs, and benefits of continuous integration in open-source projects. In Proceedings of the 31st IEEE/ACM International Conference on Automated Software Engineering (ASE '16). Association for Computing Machinery, New York, NY, USA, 426–437. doi.org/10.1145/2970276.2970358
    - Mojtaba Shahin, Mansooreh Zahedi, Muhammad Ali Babar, and Liming Zhu. 2017. Adopting Continuous Delivery and Deployment: Impacts on Team Structures, Collaboration and Responsibilities. In Proceedings of the 21st International Conference on Evaluation and Assessment in Software Engineering (EASE '17). Association for Computing Machinery, New York, NY, USA, 384–393. doi.org/10.1145/3084226.3084263
    - R. K. Gupta, M. Venkatachalapathy and F. K. Jeberla, "Challenges in Adopting Continuous Delivery and DevOps in a Globally Distributed Product Team: A Case Study of a Healthcare Organization," 2019 ACM/IEEE 14th International Conference on Global Software Engineering (ICGSE), Montreal, QC, Canada, 2019, pp. 30-34, doi.org/10.1109/ICGSE.2019.00020
12. Linus' Law: "Given Enough Eyeballs, All Bugs are Shallow."
    
    - Andrew Meneely and Laurie Williams. 2010. Strengthening the empirical analysis of the relationship between Linus' Law and software security. In Proceedings of the 2010 ACM-IEEE International Symposium on Empirical Software Engineering and Measurement (ESEM '10). Association for Computing Machinery, New York, NY, USA, Article 9, 1–10. doi.org/10.1145/1852786.1852798
    - Reshmi Maulik, Subhajit Datta, and Subhashis Majumder. 2022. Litmus Test for Linus’ Law: A Structural Equation Modeling Based Approach. In Proceedings of the 26th International Conference on Evaluation and Assessment in Software Engineering (EASE '22). Association for Computing Machinery, New York, NY, USA, 237–242. doi.org/10.1145/3530019.3534080
    - Jing Wang, Patrick C. Shih, John M. Carroll, Revisiting Linus’s law: Benefits and challenges of open source software peer review, International Journal of Human-Computer Studies, Volume 77, 2015, Pages 52-65, ISSN 1071-5819, doi.org/10.1016/j.ijhcs.2015.01.005
13. (Automated) Team Recommendation for Collaborative Software Development
    
    - Tuarob, S., Assavakamhaenghan, N., Tanaphantaruk, W. et al. Automatic team recommendation for collaborative software development. Empir Software Eng 26, 64 (2021). doi.org/10.1007/s10664-021-09966-4
    - Assavakamhaenghan, N., Tanaphantaruk, W., Suwanworaboon, P. et al. Quantifying effectiveness of team recommendation for collaborative software development. Autom Softw Eng 29, 51 (2022). doi.org/10.1007/s10515-022-00357-7
    - Pisol Ruenin, Morakot Choetkiertikul, Akara Supratak, Suppawong Tuarob, TeReKG: A temporal collaborative knowledge graph framework for software team recommendation, Knowledge-Based Systems, Volume 289, 2024, 111492, ISSN 0950-7051, doi.org/10.1016/j.knosys.2024.111492
14. Open-Source Licensing and Compliance
    
    - Yaroslav Golubev, Maria Eliseeva, Nikita Povarov, and Timofey Bryksin. 2020. A Study of Potential Code Borrowing and License Violations in Java Projects on GitHub. In Proceedings of the 17th International Conference on Mining Software Repositories (MSR '20). Association for Computing Machinery, New York, NY, USA, 54–64. doi.org/10.1145/3379597.3387455
    - X. Cui et al., "An Empirical Study of License Conflict in Free and Open Source Software," 2023 IEEE/ACM 45th International Conference on Software Engineering: Software Engineering in Practice (ICSE-SEIP), Melbourne, Australia, 2023, pp. 495-505, doi.org/10.1109/ICSE-SEIP58684.2023.00050
    - Thomas Wolter, Ann Barcomb, Dirk Riehle, and Nikolay Harutyunyan. 2023. Open Source License Inconsistencies on GitHub. ACM Trans. Softw. Eng. Methodol. 32, 5, Article 110 (September 2023), 23 pages. doi.org/10.1145/3571852

Material

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