# Publications of Mathieu Acher

Journal articles, conference and workshop papers, books, and other works (2008–2026), newest first.

Source: https://www.mathieuacher.com/publications/ · BibTeX: https://www.mathieuacher.com/acher.bib · Last updated: 2026-10-19

Google Scholar: https://scholar.google.com/citations?user=cC6xt1YAAAAJ · DBLP: https://dblp.org/pid/57/2898.html · HAL: https://cv.hal.science/mathieu-acher · ORCID: https://orcid.org/0000-0003-1483-3858

## Awards

- Distinguished Paper Award: "CRACS: Question-Driven Assessment of Legacy Code Summaries in Industrial IBM-i Modernization", SCAM 2026 - 26th IEEE International Conference on Source Code Analysis and Manipulation (Engineering Track), co-located with ICSME 2026, 2026.
- Distinguished Paper Award: "Policy Testing with MDPFuzz (Replicability Study)", Proceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis, 2024.
- Best Paper Award: "Testing for Fault Diversity in Reinforcement Learning", Proceedings of the 5th ACM/IEEE International Conference on Automation of Software Test (AST 2024), Lisbon, Portugal, April 15-16, 2024, 2024.
- Best Paper Award: "Experience in Specializing a Generic Realization Language for SPL Engineering at Airbus", MODELS 2023 - 26th International Conference on Model-Driven Engineering Languages and Systems, 2023.
- Best Paper Award: "Scratching the Surface of ./configure: Learning the Effects of Compile-Time Options on Binary Size and Gadgets", ICSR 2022 - 20th International Conference on Software and Systems Reuse, 2022.
- Best Paper Award: "A comparison of performance specialization learning for configurable systems", SPLC 2021 - 25th ACM International Systems and Software Product Line Conference, 2021.
- Best Paper Award: "Sampling Effect on Performance Prediction of Configurable Systems: A Case Study", International Conference on Performance Engineering (ICPE 2020), 2020.
- Most Influential Paper Award at VARIABILITY 2026: "Using Machine Learning to Infer Constraints for Product Lines", Software Product Line Conference (SPLC'16), 2016.
- Best Student Paper Award: "Generating Counterexamples of Model-based Software Product Lines: An Exploratory Study", 17th International Software Product Line Conference (SPLC'13), 2013.
- Most Influential Paper Award at SLE 2019: "Composing Feature Models", 2nd International Conference on Software Language Engineering (SLE'09), 2009.

## 2026

- **Code Transformation Rule Synthesis Using LLMs: Potential and Limits.** Axel Allain, Aymeric Blot, Djamel Eddine Khelladi, and Mathieu Acher. *41st IEEE/ACM International Conference on Automated Software Engineering (ASE 2026)*, 2026. [PDF](https://hal.science/hal-05607247v2/file/Code_Transformation_Rule_Synthesis_Using_LLMs__Potential_and_Limits-3.pdf) · [HAL](https://hal.science/hal-05607247) · [DOI](https://doi.org/10.1145/3832783.3837504) · [arXiv](https://arxiv.org/abs/2609.03592)
  Abstract: Due to their black-box nature, LLMs suffer from limited explainability and a lack of determinism. Their usage cost can also rise, particularly with repetitive tasks on large codebases. To mitigate this, we conduct a novel empirical study targeting three domainspecific languages for transformation rules, namely Comby, GritQL, and Ast-Grep. We evaluate three LLMs (GPT-5.4, GPT-oss-120B, and Llama3.1-8B) on six diverse datasets covering four softwareevolution tasks: API misuse correction, program repair, API migration, and language version migration. Our results provide evidence that transformation rule synthesis moves beyond proof-of-concept with strong frontier models. GPT-5.4 achieves consistently high rule applicability rates and produces transformations closest to the ground truth across most benchmarks. Smaller and open-weight GPT-oss-120B and Llama3.1-8B models remain effective for simpler, localized changes but struggle with complex migration scenarios. We also observe non-negligible generalizability through the usage of meta-variables and through a high reuse score in the first quartile of many datasets. Finally, when compared to the anti-unification algorithm, LLMs outperform it in correctness, but underperform in rule applicability. Overall, our results show great potential for LLMs to generate sound, correct, generalizable, and reusable rules.

- **Spec2COBOLRot: An Agentic-AI Degradation Loop for Realistic COBOL Corpus Generation.** Jean-Baptiste Espinasse, Djamel Eddine Khelladi, and Mathieu Acher. *AISM 2026 - 2nd International Workshop on AI for Software Modernization co-located with Automated Software Engineering Conference*, 2026. [PDF](https://hal.science/hal-05739200v1/file/Spec2COBOLRot__An_Agentic_AI_Degradation_Loop_for_Realistic_COBOL_Corpus_Generation-2.pdf) · [HAL](https://hal.science/hal-05739200) · [DOI](https://doi.org/10.1145/3843775.3844543) · [arXiv](https://arxiv.org/abs/2609.26835)
  Abstract: COBOL remains widely deployed, yet representative corpora reflecting real production code are rarely available, limiting rigorous benchmarking of modernization approaches. We propose a systematic agentic AI pipeline for generating realistic COBOL programs, combining specification-driven generation with iterative degradation guided by patterns and complexity targets extracted from real production code. Here, realism is understood as structural fidelity to production code as captured by our metrics. We evaluate whether degradation reaches target complexity levels while preserving business behavior, and examine the limits of the approach, across three programs from distinct business domains. Results show the pipeline reliably produces syntactically valid programs and moves them toward realistic structural complexity. However, preserving business behavior is not always achieved by construction, and targeting structural metrics independently of business logic risks producing programs whose complexity does not reflect a plausible maintenance history. We discuss these limitations and outline a more realistic alternative as a direction for future work, generating legacy programs from scratch along a simulated development history.

- **Controlling Variability in Neuroimaging Analysis Pipelines with Software Product Lines.** Gauthier Le Bartz Lyan, Paul Temple, Boris Clenet, and Mathieu Acher. *VARIABILITY 2026 - Software and Systems Reuse, Product Lines, and Configuration*, 2026. [DOI](https://doi.org/10.1007/978-3-032-40763-4_9)

- **Core open science practices in major medical journals: development of an automatized tool based on a Large Language Model.** Constant Vinatier, Guillaume Freyermuth, Margaux Millour, Gauthier Le Bartz Lyan, Sarah Buet, Perrine Lunel, Nicolas Robillard, Florian Naudet, and Mathieu Acher. *Open Research Europe, 6*, 2026. [HAL](https://hal.science/hal-05751701) · [DOI](https://doi.org/10.12688/openreseurope.24615.1)
  Abstract: Background: Open science practices are increasingly promoted to improve the transparency and reproducibility of biomedical research, and their large-scale monitoring has been identified as a priority by initiatives such as the UNESCO Recommendation on Open Science. Existing automated tools cover only narrow subsets of practices. We developed and validated an automated tool, based on locally run open-weights large language models (LLMs), to extract a core set of 13 open science practices from published medical research articles. Methods: We built a validation database of 303 research articles published in 2020–2021 in 10 major general medical journals, stratified across randomized controlled trials (RCTs), meta-analyses, and other designs. Duplicate manual extraction with expert adjudication served as the reference standard. The pipeline combined document conversion (GROBID), BM25-based chunk retrieval, and classification by three Llama models (3-8B, 3-70B, 3.3-70B) run entirely locally, with and without supplementary materials. Diagnostic performance (sensitivity, specificity, predictive values, F1) was computed against the reference standard. Results: Usable outputs were obtained for 301/303 articles. Performance was heterogeneous across criteria rather than across models: practices reported in standardized statements (conflicts of interest, funding, author contributions, data sharing, pre-registration, reporting guidelines) were extracted reliably (F1 ≥ 0.75 for at least one model), whereas rare or inconsistently reported practices (code sharing, statistical analysis plan, protocol sharing, ORCID, open access status, preprints) remained difficult regardless of model size. Study-type classification exceeded 0.90 on all metrics. Larger models improved several criteria at a 6.6–7.5× computational cost, and adding supplementary materials did not improve performance, mainly due to conversion failures. Conclusions: A fully local, open-weights LLM pipeline can reliably monitor a substantial subset of open science practices. Document conversion and layout heterogeneity, rather than language understanding, constitute the main barrier to scaling automated open science monitoring.

- **Open Science Policies and Practices Among Medical Journals.** Constant Vinatier, Ayu Putu Madri Dewi, Guillaume Freyermuth, Margaux Millour, Maud Scheidecker, F Arnault, Mathieu Acher, Vladislav Nachev, Tracey L Weissgerber, Nicholas J Devito, Gwénaël Dumont, Gowri Gopalakrishna, Gauthier Le Bartz Lyan, Inge Stegeman, Mariska M G Leeflang, and Florian Naudet. *JAMA Network Open, 9(9)*, 2026. [HAL](https://hal.science/hal-05749577) · [DOI](https://doi.org/10.1001/jamanetworkopen.2026.32070)
  Abstract: Importance: Open science practices are essential for improving transparency, reproducibility, and trust in biomedical research. Journals play a critical role in promoting these practices through editorial policies, yet implementation and impact remain unclear. Objective: To evaluate the open science policies of leading medical journals and assess implementation and detectability of practices using automated tools. Design, setting, and participants: This cross-sectional study of journal policies and open science practices evaluated research articles published in 10 leading general medical journals from January 2020 to December 2023. Additionally, the diagnostic accuracy of automated tools was validated against manual extraction. Exposures: Journal policies regarding open science practices and article-level implementation of 13 core practices including registration, protocol sharing, and intention to share data. Main outcomes and measures: Journal policies were assessed using the Transparency and Openness Promotion guidelines (TOP2025). At the article level, 13 core open science practices were examined. Additionally, 9 validated automated tools were applied to detect these practices, and their performance was compared with manual extraction of articles. Results: Overall, 15 624 research articles published in 10 general medical journals were analyzed (validation subset, 312 articles: 103 randomized clinical trials [RCTs], 98 meta-analyses, and 111 with other designs). At the journal level, TOP2025 evaluation identified substantial heterogeneity in policies, primarily applied to clinical trials. At the article level, open science practices were more frequently implemented in RCTs than other designs: registration (RCTs: 99% [95% CI, 97%-100%]; meta-analyses: 69% [95% CI, 56%-79%]; other designs: 16% [95% CI, 9%-26%]), protocol sharing (RCTs: 96% [95% CI, 93%-98%]; meta-analyses: 67% [95% CI, 54%-78%]; other designs: 20% [95% CI, 12%-33%]), and intention to share data (RCTs: 79% [95% CI, 67%-87%]; meta-analyses: 65% [51%-77%]; other designs: 70% [95% CI, 57%-81%]). Automated tools showed variable performance (F1 scores, 0.06-1.00) and generally underestimated practices. Conclusions and relevance: In this cross-sectional study of 15 624 articles in 10 leading medical journals, journal policies were only partially aligned with TOP2025, and article-level open science practices were more frequently reported for RCTs than for other designs, supporting the need for stronger journal policies.

- **A Replication Study of Communication Style Analysis in the Linux Kernel Mailing List.** Júlia Azevedo, Theo Canuto, Heraldo Borges, Mathieu Acher, and Juliana Alves Pereira. *VEM 2026 - 14th Workshop on Software Visualization, Maintenance and Evolution co-located with CBSoft 2026*, 2026. [PDF](https://inria.hal.science/hal-05756009v1/file/A%20Replication%20Study%20of%20Communication%20Style%20Analysis%20in%20the%20Linux%20Kernel%20Mailing%20List-final.pdf) · [HAL](https://hal.science/hal-05756009)
  Abstract: The Linux Kernel Mailing List (LKML) has long served as an important empirical source for studying communication dynamics in large-scale open-source software development. However, replicating historical LKML studies under contemporary data conditions remains challenging due to differences in archival infrastructures, metadata consistency, and dataset construction practices. This paper presents a qualitative replication of the study Differentiating Communication Styles of Leaders on the Linux Kernel Mailing List using the LKML5Ws curated dataset. We first investigate the feasibility of reconstructing LKML corpora directly from official archives using the lei interface and discuss the practical limitations encountered during large-scale data acquisition. We then re-execute the original analytical pipeline using LKML5Ws, maintaining high fidelity to the original methodological assumptions and execution environment. Through this replicated analysis, we evaluate multiple dimensions, including authorship classification, lexical statistics, expletive usage, and part-of-speech distributions. Ultimately, this work explores both the feasibility and the methodological challenges of revisiting established empirical studies using a contemporary LKML dataset.

- **CRACS: Question-Driven Assessment of Legacy Code Summaries in Industrial IBM-i Modernization.** N'Guessan Hermann Kouadio, Mathieu Acher, Olivier Barais, and Jean-Marc Jézéquel. *SCAM 2026 - 26th IEEE International Conference on Source Code Analysis and Manipulation (Engineering Track), co-located with ICSME 2026*, 2026. **Distinguished Paper Award.** [PDF](https://hal.science/hal-05757598v1/file/CRACS_scam2026_engineering_track_paper.pdf) · [HAL](https://hal.science/hal-05757598)
  Abstract: In the context of legacy system modernization, code summaries, whether manually written or automatically generated (e.g., using LLMs), are increasingly used to support program comprehension. However, evaluating whether these summaries effectively assist modernization activities remains challenging. We study IBM-i RPG AS/400 in an industrial modernization context, where the legacy code and sparse documentation make automated summarization and evaluation particularly challenging. Existing automatic metrics fail to capture semantic adequacy, while expert-based evaluations are costly, difficult to scale, and challenging to reproduce. This problem is critical in modernization contexts, as inaccurate summaries may lead to misinterpretations of legacy behavior and increase migration risks. To address this challenge, we propose a semi-automated, context-aware, questiondriven approach for evaluating code summary quality: CRACS. Our method relies on expert-defined comprehension questions targeting key program elements such as database operations, user interface interactions, and algorithmic logic. Evaluated on 18 industrial RPG programs (160 subroutines, ≈12k SLOC) and 640 summaries (160 expert-written plus 480 degraded and LLMgenerated variants) using 846 expert-defined comprehension questions, CRACS reliably separates reference documentation from weaker summaries (large effect, Cliff's δ > 0.8). It also remains stable across five LLM evaluators and reuses 38 question templates to cover 91% of questions.

- **Testing Uniform Random Samplers: Methods, Datasets, and Protocols.** Olivier Zeyen, Maxime Cordy, Martin Gubri, Gilles Perrouin, and Mathieu Acher. *ACM Transactions on Software Engineering and Methodology, 35(10)*, 2026. [HAL](https://hal.science/hal-05760466) · [DOI](https://doi.org/10.1145/3797477) · [arXiv](https://arxiv.org/abs/2503.14079)
  Abstract: Boolean formulae compactly encode huge, constrained search spaces. Thus, variability-intensive systems are often encoded with Boolean formulae. The search space of a variability-intensive system is usually too large to explore without statistical inference (e.g., testing). Testing every valid configuration is computationally expensive (if not impossible) for most systems. This leads most testing approaches to sample a few configurations before analysing them. A desirable property of such samples is uniformity : Each solution should have the same selection probability. Uniformity is the property that facilitates statistical inference. This property motivated the design of uniform random samplers, relying on SAT solvers and counters and achieving different tradeoffs between uniformity and scalability. Though we can observe their performance in practice, judging the quality of the generated samples is different. Assessing the uniformity of a sampler is similar in nature to assessing the uniformity of a pseudo-random number (PRNG) generator. However, sampling is much slower, and the nature of sampling also implies that the hyperspace containing the samples is constrained. This means that testing PRNGs is subject to fewer constraints than testing samplers. We propose a framework that contains five statistical tests, which are suited to test uniform random samplers. Moreover, we demonstrate their use by testing eight samplers. Finally, we demonstrate the influence of the Boolean formula given as input to the samplers under test on the test results.

- **Code Transformation Rule Synthesis using LLMs: Potential and Limits.** Axel Allain, Aymeric Blot, Djamel Eddine Khelladi, and Mathieu Acher. *CoRR, abs/2609.03592*, 2026. [DOI](https://doi.org/10.48550/arXiv.2609.03592) · [arXiv](https://arxiv.org/abs/2609.03592) · [Published version](/publications/#allain2026code)
  Abstract: Due to their black-box nature, LLMs suffer from limited explain- ability and a lack of determinism. Their usage cost can also rise, particularly with repetitive tasks on large codebases. To mitigate this, we conduct a novel empirical study targeting three domain- specific languages for transformation rules, namely Comby, GritQL, and Ast-Grep. We evaluate three LLMs (GPT-5.4, GPT-oss-120B, and Llama3.1-8B) on six diverse datasets covering four software- evolution tasks: API misuse correction, program repair, API migra- tion, and language version migration. Our results provide evidence that transformation rule synthesis moves beyond proof-of-concept with strong frontier models. GPT-5.4 achieves consistently high rule applicability rates and produces transformations closest to the ground truth across most benchmarks. Smaller and open-weight GPT-oss-120B and Llama3.1-8B models remain effective for simpler, localized changes but struggle with complex migration scenarios. We also observe non-negligible generalizability through the usage of meta-variables and through a high reuse score in the first quartile of many datasets. Finally, when compared to the anti-unification algorithm, LLMs outperform it in correctness, but underperform in rule applicability. Overall, our results show great potential for LLMs to generate sound, correct, generalizable, and reusable rules.

- **Spec2COBOLRot: An Agentic-AI Degradation Loop for Realistic COBOL Corpus Generation.** Jean-Baptiste Espinasse, Djamel Eddine Khelladi, and Mathieu Acher. *CoRR, abs/2609.26835*, 2026. [DOI](https://doi.org/10.48550/arXiv.2609.26835) · [arXiv](https://arxiv.org/abs/2609.26835) · [Published version](/publications/#espinasse2026spec2cobolrot)
  Abstract: COBOL remains widely deployed, yet representative corpora reflecting real production code are rarely available, limiting rigorous benchmarking of modernization approaches. We propose a systematic agentic AI pipeline for generating realistic COBOL programs, combining specification-driven generation with iterative degradation guided by patterns and complexity targets extracted from real production code. Here, realism is understood as structural fidelity to production code as captured by our metrics. We evaluate whether degradation reaches target complexity levels while preserving business behavior, and examine the limits of the approach, across three programs from distinct business domains. Results show the pipeline reliably produces syntactically valid programs and moves them toward realistic structural complexity. However, preserving business behavior is not always achieved by construction, and targeting structural metrics independently of business logic risks producing programs whose complexity does not reflect a plausible maintenance history. We discuss these limitations and outline a more realistic alternative as a direction for future work, generating legacy programs from scratch along a simulated development history.

- **Externalized CPDAG Summaries Improve LLM Causal Deduction.** Wentao Sun, João Paulo Nogueira, Dominique Verchère, Mathieu Acher, and Alonso Silva. *CoRR, abs/2609.31071*, 2026. [DOI](https://doi.org/10.48550/arXiv.2609.31071) · [arXiv](https://arxiv.org/abs/2609.31071) · [Published version](/publications/#sun2026externalized)
  Abstract: Corr2Cause asks whether a causal claim holds in every DAG compatible with observed correlations and conditional independencies. We frame this as latent-object reasoning: the label is defined by a CPDAG query, but free-form chain-of-thought often collapses the Markov-equivalence-class problem into local pattern matching. We propose Structured Thinking, a two-turn pipeline that first externalizes a typed, schema-constrained CPDAG summary and then answers against that graph state. On the Corr2Cause full test, Structured Thinking raises Qwen3.5-27B from 73.0 to 86.4 F1(Yes) over a strong PC-instruction baseline in the primary paired run (+13.4 pp; McNemar p=2.4× 10^-6; bootstrap 95% CI [+8.4, +18.6]); across three full-ID seeds, the mean gain is +8.1 ± 5.3 pp. A PC-scaffolded two-turn prose control reaches only 67.6 F1, indicating that a detailed PC scaffold plus a schema-free prose intermediate is not sufficient. The same pattern holds on Qwen3.6-27B, Paraphrase-OOD, and GPT-5.4-mini. Scrambling the emitted CPDAG costs 12.0 pp F1, and a full-split audit shows close agreement with the reference CPDAG (ID skeleton F1 0.960; exact match 75.9%). These results support a bounded design principle: externalize the latent object that defines the label, constrain its form, and test whether downstream answers use it.

- **On the Effectiveness of Feedforward Neural Networks for Performance Prediction in Highly Configurable Systems: The Case of Linux Kernel Size.** João Marcello Bessa, Heraldo Borges, Pedro Lopes, Lucas Lopes, Mathieu Acher, and Juliana Alves Pereira. *Journal of Software Engineering Research and Development, 14(1)*, 2026. [DOI](https://doi.org/10.5753/jserd.2026.6399)
  Abstract: Highly configurable software systems, such as the Linux kernel, expose thousands of configuration options whose combinations can drastically influence non-functional properties. In embedded or resource-constrained environments, kernel binary size is particularly important because it directly affects memory footprint, boot time, storage usage, and overall system responsiveness. Accurately predicting binary size from configuration options enables developers to evaluate trade-offs early in the development cycle, reducing the need for costly trial-and-error compilation and measurement processes. This study investigates the use of Feedforward Neural Networks (FNNs) for predicting Linux kernel binary size and compares their performance against strong classical Machine Learning (ML) baselines, including Random Forest and Gradient Boosting Trees. In addition, we analyze the impact of feature selection (FS) strategies on predictive accuracy and computational cost. We evaluate five FS approaches, including supervised tree-based importance rankings and a semantic, label-free method based on Word2Vec embeddings extracted from Linux kernel documentation. Our experiments were conducted on a dataset containing 9,670 Linux kernel configuration options. The results show that classical tree-based ensemble methods outperformed FNNs in predictive accuracy, with Gradient Boosting Trees achieving the best overall results (MAPE of 5.21%). Although FNNs combined with feature selection achieved reasonable accuracy (best MAPE of 8.26%) and benefited from reduced training times, they did not surpass the traditional ML baselines. These findings provide important empirical evidence that more complex neural architectures do not necessarily yield superior performance for SPL prediction tasks, even in high-dimensional configuration spaces. We also show that the Word2Vec-based semantic FS method offers a practical label-free alternative for early-stage scenarios where measured NFP data are unavailable or expensive to obtain, although it generally underperforms supervised feature selection strategies in both accuracy and efficiency. Overall, our findings provide practical guidance for SPL practitioners and researchers in selecting prediction models and preprocessing strategies that balance accuracy, interpretability, and computational cost in highly configurable systems.

- **In the Search for Truth: Refining and Exploring Variability in Neuroimaging Pipelines.** Youenn Merel Jourdan, Helge Spieker, Camille Maumet, and Mathieu Acher. *Preprint*, 2026. [PDF](https://inria.hal.science/hal-05525807v2/file/In_the_Search_for_Truth_Refining_Exploring_Variability_Neuroimaging_Pipelines.pdf) · [HAL](https://hal.science/hal-05525807)
  Abstract: Neuroimaging pipelines can be designed as highly configurable software workflows whose variants may produce different analysis results and scientific conclusions. Managing this analytical variability is particularly challenging because outputs are complex, high-dimensional brain maps and no ground truth exists to assess their correctness. We model neuroimaging pipelines as a software product line and leverage the resulting feature model in a novel two-step process. First, we refine the configuration space by learning constraints from observed outputs and integrating them into the feature model. Second, we explore the refined space to identify influential features, characterize clusters, and predict unseen configurations. Evaluations on two case studies show that a small subset of features explains most observed variability and that accurate predictions can be achieved from a limited number of executed variants. They also demonstrate the complementarity of the two steps: refining the configuration space by excluding undesirable variants improves the interpretability and predictive power of subsequent exploration. Beyond neuroimaging, our results demonstrate how feature models can support both specialization and structured exploration of complex configuration spaces without ground truth.

- **A systematic and large-scale exploration of analytical variability in task-fMRI.** Youenn Merel Jourdan, Mathieu Acher, and Camille Maumet. *OHBM 2026 - Annual Meeting of the Organization for Human Brain Mapping*, 2026. [PDF](https://inria.hal.science/hal-05458481v2/file/Abstract_OHBM_2026_YMJ.pdf) · [HAL](https://hal.science/hal-05458481)
  Abstract: Configurability of neuroimaging pipelines is essential for tailoring the analyses to different experimental conditions but also gives rise to analytical variability : i.e. distinct pipelines, equally valid from a scientific point of view, may produce different findings. Previous works have explored the sources of this variability typically by studying the variability induced (in the results) by a small set of pre-defined pipeline variations – such as the choice of software, operating systems or preprocessing methods. In this work, we leverage methods from software engineering to systematically explore analytical variability from preprocessing up to group analysis in a multi-task fMRI dataset. We investigate 20 parameters – including interpolation algorithm, coregistration cost function, number of motion regressors – expressing a total of over 27,000 distinct pipelines. We propose a method to study variability in this large space without any assumptions made on the expected results or target downstream task. We separate variability of interest (differences observed across valid results) from unwanted variability (differences linked to pipelines producing unacceptable or low quality results) while minimizing the required amount of visual quality control. Finally, among the valid pipelines, we identify the parameters that have the strongest impact on the final results.

- **Fault Diversity in Reinforcement Learning Policy Testing.** Quentin Mazouni, Arnaud Gotlieb, Mathieu Acher, and Helge Spieker. *ACM Transactions on Software Engineering and Methodology*, 2026. [PDF](https://inria.hal.science/hal-05760415v1/file/TOSEM-AST2024.pdf) · [HAL](https://hal.science/hal-05760415) · [DOI](https://doi.org/10.1145/3821533)
  Abstract: Reinforcement Learning (RL) is the common approach to solving sequential decision-making problems. Testing is an effective method for detecting functional faults in RL policies. Not only should policy testing find as many failures as possible, but it should also reveal diverse ones. In that regard, Quality diversity optimization (QD) is a type of evolutionary algorithm that returns a set of high-quality diverse solutions. In this article, we explore the use of Quality Diversity to tackle fault diversity in policy testing. We define and address the challenges of adapting QD to testing policies with both deterministic test cases -considered by most of the literature -and stochastic executions. We utilize stochastic executions to define a domain-agnostic generic behavior space, tailored to policy testing. We compare QD-based policy testing to a state-of-the-art policy testing framework with two QD optimizers and three environments. Our evaluation assess fault detection, fault diversity and investigate the sensitivity of our method to the behavior space definition and the number of test executions. Our results show that QD improves fault diversity without significantly reducing fault discovery. Furthermore, QD optimization does not necessarily need domain knowledge and can adapt to generic behaviors with stochastic executions.

- **Imperfect Visual Verification for Code Edition : A Case Study on TikZ.** Charly Reux, Mathieu Acher, Djamel Eddine Khelladi, Clément Quinton, and Olivier Barais. *CoRR, abs/2606.15693*, 2026. [PDF](https://hal.science/hal-05582911v1/file/main.pdf) · [HAL](https://hal.science/hal-05582911) · [DOI](https://doi.org/10.48550/arXiv.2606.15693) · [arXiv](https://arxiv.org/abs/2606.15693)
  Abstract: LLMs have significantly advanced code generation, enabling the synthesis of functional programs. While recent systems achieve strong performance on many coding benchmarks, tasks involving programs such as TikZ that generate visual artifacts remain challenging, in particular on visual code customization. Unlike generation from scratch, customization requires localized, semantics-preserving edits: the model must locate relevant code, modify it according to the instruction, and preserve the remaining structure and rendering. Approaches based on post-hoc iterative refinement/correction where a verifier provides feedback to guide corrections, have shown promise. However, in the case of programs with a visual outcome such as in TikZ, where correctness is harder or likely impossible to formalize and evaluate automatically, deterministic verifiers do not exist. Hence, developers can only rely on imperfect verifiers. In this paper, we conduct an empirical study to answer:to what extent can iterative refinement remain effective when the verifier itself is unreliable? We use TikZ as a focused case study that isolates the core difficulties of the problem (weak code structure, fine-grained visual semantics, and difficult feature localization) in a controlled and challenging setting. We define visual code customization as an iterative editing problem with an imperfect oracle, and introduce a framework for analyzing such iterative refinements. We conduct a large-scale study and evaluate multiple LLM-based and tool-augmented visual verifiers within iterative refinement pipelines, and perform extensive manual annotation of refinement trajectories to assess verifier behavior and feedback quality. Our findings show that even imperfect verifiers can determine with moderate accuracy whether visual instructions are applied to code, achieving F1-scores up to 0.815. Feedback improves iterative refinement, especially for weaker models, adding 11–20 perfect customizations for Qwen3-vl-30b-a3b-Instruct, while stronger models like Gemini-3 gain fewer improvements (+5) but benefit more from accurate verification that prevents premature acceptance. Feedback is effective only when it precisely identifies image issues, provides actionable guidance, addresses all relevant problems, and remains grounded in the original instruction.

- **PyroBuildS: Speeding up the exploration of large configuration spaces with incremental build.** Georges Aaron Randrianaina, Djamel Eddine Khelladi, Olivier Zendra, and Mathieu Acher. *Journal of Systems and Software (JSS), 231*, 2026. [PDF](https://hal.science/hal-05213625v1/file/PyroBuildS-JSS.pdf) · [HAL](https://hal.science/hal-05213625) · [DOI](https://doi.org/10.1016/j.jss.2025.112592)
  Abstract: Software developers are acutely aware that software build is an essential but resource-intensive step in any software development process, all the more when building large and/or highly configurable systems, whose vast number of configuration options leads to an explosion in the number of variants to build and evaluate. A potential approach to speed up the builds of multiple configurations is to do incremental build, i.e., to not clean the build environment and reuse previous builds when building a new configuration. Previous exploratory studies showed some benefits and limitations of incremental build, but mainly on small configurable software systems and on a limited set of close configurations. However, for large configuration spaces, little is known whether the large distance across configurations impacts the correctness and efficiency of incremental build. This paper presents PyroBuildS, a new approach to speed up incremental builds while keeping reproducibility, featuring a configuration variation operator parameterized by two deny lists of problematic options and a mutation size (diversity). We evaluate PyroBuildS through an empirical study on three large complex configurable systems, namely Linux, BusyBox, and ToyBox, with respectively 18637, 1078, 330 configuration options. We first show that for all configurations PyroBuildS produces the exact same binaries as a clean build, except for Linux with some non-reproducible random configurations. We identify the reasons why incremental build speeds up or slows down the build of large configuration spaces – a knowledge that can be integrated into PyroBuildS. Incremental build systematically pays off, since problematic options are avoided in the first place — something only PyroBuildS does. We also show that a naive use of incremental build on random Linux configurations backfires, taking more time than clean builds. Thus, PyroBuildS controls diversity to avoid too many differences across configurations to perform efficient incremental builds. Thanks to its ability to operate over non-problematic options and close enough configurations, PyroBuildS significantly speeds up the exploration of large configuration spaces, with a gain in build time from 16% to 22% in all three systems with mutated configurations. Finally, with random configurations, PyroBuildS also speeds up the build time from 15% to 20% for ToyBox and BusyBox.

- **SpaceTime Programming: Live and Omniscient Exploration of Code and Execution.** Jean-Baptiste Döderlein, Djamel Eddine Khelladi, Mathieu Acher, and Benoît Combemale. *CoRR, abs/2603.18735*, 2026. [DOI](https://doi.org/10.48550/arXiv.2603.18735) · [arXiv](https://arxiv.org/abs/2603.18735)
  Abstract: Programming environments typically separate the world of static code from the dynamic execution of programs. Developers must switch between writing code and observing its execution, often with limited tools to understand the relationship between code changes and runtime behavior. Several paradigms and approaches exist to bridge this gap, including exploratory programming for comparing code variants, live programming for immediate feedback, and omniscient debugging for exploring execution history. However, existing solutions tend to focus on specific aspects and one specific paradigm rather than providing a fully integrated environment with multiple capabilities. This paper introduces spacetimeProgramming, a novel approach that unifies these paradigms to create a programming model for exploring both code modifications and execution flow. At the core of our approach is a trace mechanism that captures not only execution state but also the corresponding code changes, enabling developers to explore programs in both space (code variants) and time (execution flow). As a proof of concept, we implemented a Python library supporting SpaceTime Programming and applied it in two contexts: a live omniscient debugger and a Pygame game development tool, showcased through a Flappy Bird-like game. We further evaluated SpaceTimePy on five real-world Python projects, finding performance overhead ranging from 35% to 150% on test suites.

- **Small Yet Configurable: Unveiling Null Variability in Software.** Xhevahire Tërnava, Georges Aaron Randrianaina, Luc Lesoil, and Mathieu Acher. *CoRR, abs/2604.15957*, 2026. [PDF](https://hal.science/hal-05097580v1/file/preprint20250604-NullVariability-HAL-arXiv.pdf) · [HAL](https://hal.science/hal-05097580) · [DOI](https://doi.org/10.48550/arXiv.2604.15957) · [arXiv](https://arxiv.org/abs/2604.15957)
  Abstract: Many small-scale software systems, that is, with limited codebase or binary size, are widely used in everyday tasks, yet their configurability remains largely unexplored. At the same time, studies on modern software systems show a trend toward increasing configurability, alongside growing interest in building immutable, specialized, and reproducible software. In this paper, we present the first empirical study on the extent of configurability in small-scale software systems. By analyzing 108 programs from GNU coreutils, we show that even small programs can exhibit significant compile-time and run-time variability, with up to 76 options per program. Then, there is a high correlation (0.78) between run-time variability and codebase size. Furthermore, an analysis of the 20 smallest programs across 85 releases reveals that variability tends to increase over time, primarily due to the added compile-time variability. This suggests that shifting options between run-time and compile-time, removing unnecessary run-time variability, or resolving compile-time variability early, can help reduce codebase complexity and size. We also introduce, for the first time, the concept of null-variable software system, one with no configurability beyond mandatory features. Our findings show that high configurability is not exclusive to largescale systems and that reducing unnecessary variability can lead to lightweight, smaller, and more maintainable software. We hope this effort contributes to designing new software by understanding how to balance its configurability with codebase size.

- **Do programming languages still matter to your AI coding agent teammate? Evidence at scale from chess engines.** Mathieu Acher and Jean-Marc Jézéquel. *CoRR, abs/2606.13763*, 2026. [DOI](https://doi.org/10.48550/arXiv.2606.13763) · [arXiv](https://arxiv.org/abs/2606.13763)
  Abstract: Frontier coding agents now promise end-to-end authorship of complete software systems. Two empirical questions follow: can AI coding-agent teammates program in any target language, including ones with no comparable prior open-source artefact? If so, does language choice still shape the artefact, and along which dimensions? We study both through a polyglot case study built around chess engines: non-trivial multi-component systems that admit a hierarchy of language-agnostic oracles, from exact move-generation correctness to a strength scale (Elo), observable from Rust to Brainfuck. We prompted two frontier agents (Claude Code and Codex) at the capability level, without chess knowledge or implementation guidance, under a documented intervention and stopping policy. The agents produced 34 chess engines spanning 17 primary programming languages, from mainstream to specialised, domain-specific, legacy, and esoteric targets. We combine per-engine feature analysis, independent Elo assessment, and session trajectories with qualitative analysis of code and transcripts. Frontier coding agents are genuinely polyglot: every language we tried produced at least one feature-rich working engine, several with no prior open-source counterpart of comparable scope (e.g., LaTeX), and the code is synthesised from scratch rather than copied. Yet language choice still matters: strong playing strength is only reachable in mainstream compiled languages, cost and engineering effort grow sharply as the language becomes more exotic, and feature choices shift across language families. Agents validate their own work unprompted, but their strength self-estimates are biased and a few engines cheated by calling a chess library. Programming language is no longer about whether AI teammates can build a working system, but about performance, cost, what gets built, and how much human supervision validation still needs.

- **Externalized CPDAG Summaries Improve LLM Causal Deduction.** Wentao Sun, João Paulo Nogueira, Dominique Verchère, Mathieu Acher, and Alonso Silva. *NeurIPS 2026 - 40th Annual Conference on Neural Information Processing Systems*, 2026. [arXiv](https://arxiv.org/abs/2609.31071)
  Abstract: Corr2Cause asks whether a causal claim holds in every DAG compatible with observed correlations and conditional independencies. We frame this as latent-object reasoning: the label is defined by a CPDAG query, but free-form chain-of-thought often collapses the Markov-equivalence-class problem into local pattern matching. We propose Structured Thinking, a two-turn pipeline that first externalizes a typed, schema-constrained CPDAG summary and then answers against that graph state. On the Corr2Cause full test, Structured Thinking raises Qwen3.5-27B from 73.0 to 86.4 F1(Yes) over a strong PC-instruction baseline in the primary paired run (+13.4 pp; McNemar p=2.4× 10^-6; bootstrap 95% CI [+8.4, +18.6]); across three full-ID seeds, the mean gain is +8.1 ± 5.3 pp. A PC-scaffolded two-turn prose control reaches only 67.6 F1, indicating that a detailed PC scaffold plus a schema-free prose intermediate is not sufficient. The same pattern holds on Qwen3.6-27B, Paraphrase-OOD, and GPT-5.4-mini. Scrambling the emitted CPDAG costs 12.0 pp F1, and a full-split audit shows close agreement with the reference CPDAG (ID skeleton F1 0.960; exact match 75.9%). These results support a bounded design principle: externalize the latent object that defines the label, constrain its form, and test whether downstream answers use it.

- **Coding Agents Can Develop COBOL Systems: Evidence from a Human-Guided Multi-Case Study.** Mathieu Acher, Zohra Kaouter Kebaili, Jean-Baptiste Espinasse, and Djamel Eddine Khelladi. *Preprint*, 2026. [PDF](https://inria.hal.science/hal-05743207v1/file/COBOL-codingagents.pdf) · [HAL](https://hal.science/hal-05743207)
  Abstract: Coding agents are routinely used in software engineering (SE) on mainstream languages, but their behavior on COBOL remains less understood. We report a retrospective multi-case study of 16 selected, human-guided development trajectories with Claude Code and Codex (high-reasoning settings, February-July 2026). The agents built from scratch and evolved non-trivial GnuCOBOL systems in eight domain families, spanning different SE and COBOL activities. Three exploratory pilot sessions with non-frontier agents failed, stalled, or delivered a plausible but incorrect program on the easiest task family, illustrating failure modes of the tested stacks and motivating stronger validation. In our study, Claude Code and Codex notably developed two COBOL-to-C compilers written in COBOL, a chess engine measured at about 1,630 Elo in its test pool, a CDCL SAT solver measured within 9× of MiniSat on the reported benchmark, two Doom-like games, two compressors, and two payroll systems whose final refactoring steps preserved the tested outputs. The delivered corpus contains 50,147 lines of COBOL code and uses up to 60 distinct constructs per system across ten languagefeature categories. The agents authored and ran much of the validation apparatus during the sessions, sometimes proactively and sometimes following brief human requests, both to guide development and to validate their code. Though the delivered systems can be incomplete or suboptimal, we provide evidence that coding agents deliver buildable and runnable systems, successfully checking their systems' behavior against published values, external implementations, visual assessment, performance measurements, or human feedback. Qualitative analysis also exposed false success, including a compiler that matched templates instead of parsing, a miscompile behind a suspicious speedup, and a fuzz-detected crash. Overall, our study provides evidence that frontier coding agents can develop in COBOL, a regime not represented in prior short-program COBOL evaluations. This has several implications for COBOL maintenance, for migration pipelines that presuppose COBOL understanding, and for benchmarks that do not yet measure COBOL authoring at this scale.

## 2025

- **Piloting Copilot, Codex, and StarCoder2: Hot temperature, cold prompts, or black magic?.** Jean-Baptiste Döderlein, Nguessan Hermann Kouadio, Mathieu Acher, Djamel Eddine Khelladi, and Benoît Combemale. *Journal of Systems and Software (JSS), 230*, 2025. [PDF](https://hal.science/hal-05474229v1/file/2210.14699v3.pdf) · [HAL](https://hal.science/hal-05474229) · [DOI](https://doi.org/10.1016/j.jss.2025.112562) · [arXiv](https://arxiv.org/abs/2210.14699)
  Abstract: Language models are promising solutions for tackling increasing complex problems. In software engineering, they recently gained attention in code assistants, which generate programs from a natural language task description (prompt). They have the potential to save time and effort but remain poorly understood, limiting their optimal use. In this article, we investigate the impact of input variations on two configurations of a language model, focusing on parameters such as task description, surrounding context, model creativity, and the number of generated solutions. We design specific operators to modify these inputs and apply them to three LLM-based code assistants (Copilot, Codex, StarCoder2) and two benchmarks representing algorithmic problems (HumanEval, LeetCode). Our study examines whether these variations significantly affect program quality and how these effects generalize across models. Our results show that varying input parameters can greatly improve performance, achieving up to 79.27% success in one-shot generation compared to 22.44% for Codex and 31.1% for Copilot in default settings. Actioning this potential in practice is challenging due to the complex interplay in our study-the optimal settings for temperature, prompt, and number of generated solutions vary by problem.

- **Prompting for Performance: Exploring LLMs for Configuring Software.** Helge Spieker, Théo Matricon, Nassim Belmecheri, Jørn Eirik Betten, Gauthier Le Bartz Lyan, Heraldo Borges, Quentin Mazouni, Dennis Gross, Arnaud Gotlieb, and Mathieu Acher. *37th IEEE International Conference on Tools with Artificial Intelligence, ICTAI 2025, Athens, Greece, November 3-5, 2025*, 2025. [PDF](https://hal.science/hal-05494832v1/file/LLM4Configuration%20%284%29.pdf) · [HAL](https://hal.science/hal-05494832) · [DOI](https://doi.org/10.1109/ictai66417.2025.00023) · [arXiv](https://arxiv.org/abs/2507.09790)
  Abstract: Software systems usually provide numerous configuration options that can affect performance metrics such as execution time, memory usage, binary size, or bitrate. On the one hand, making informed decisions is challenging and requires domain expertise in options and their combinations. On the other hand, machine learning techniques can search vast configuration spaces, but with a high computational cost, since concrete executions of numerous configurations are required. In this exploratory study, we investigate whether large language models (LLMs) can assist in performance-oriented software configuration through prompts. We evaluate several LLMs on tasks including identifying relevant options, ranking configurations, and recommending performant configurations across various configurable systems, such as compilers, video encoders, and SAT solvers. Our preliminary results reveal both positive abilities and notable limitations: depending on the task and systems, LLMs can well align with expert knowledge, whereas hallucinations or superficial reasoning can emerge in other cases. These findings represent a first step toward systematic evaluations and the design of LLM-based solutions to assist with software configuration.

- **Monitoring of Open Science practices: a survey of 10 major medical journals.** Constant Vinatier, Ayu Putu Madri Dewi, Guillaume Freyermuth, Margaux Millour, Maud Scheidecker, François-Joseph Arnault, Mathieu Acher, Vladislav Nachev, Tracey L. Weissgerber, Nicholas J. DeVito, Gwénaël Dumont, Gowri Gopalakrishna, Gauthier Le Bartz Lyan, Inge Stegeman, Mariska M. G. Leeflang, and Florian Naudet. *Preprint, medRxiv*, 2025. [DOI](https://doi.org/10.1101/2025.11.26.25341061) · [Published version](/publications/#vinatier2026open)
  Abstract: Abstract Objective: To evaluate open science policies of leading general medical journals and the extent to which open science practices are implemented and detectable using automated tools. Design: Cross-sectional audit of journal policies and retrospective observational study of journal articles, with diagnostic accuracy validation of automated screening tools against manual data extraction. Setting: Annals of Internal Medicine, BMC Medicine, The BMJ, CMAJ, JAMA, JAMA Network Open, The Lancet, Nature Medicine, New England Journal of Medicine, and PLOS Medicine. Participants:Research articles published between 2020 and 2023 and randomised controlled trials (RCTs) published before and after policy changes regarding registration and data-sharing. Main outcome measures: Journal policies were assessed using the TOP2025 framework, which rates journals’ transparency and openness standards using the TOP Factor (maximum score 27). At the article level, thirteen core open science practices were examined, including trial registration, protocol sharing, and intention to share data. Nine validated automated tools were applied to detect these practices and compared with manual extraction of 312 articles performed in duplicate. Changes in transparency practices following policy updates were analyzed. Results: Transparency policies varied considerably. TOP Factor scores ranged from 1 (NEJM) to 13 (PLOS Medicine), with many journals’ policies applying primarily to clinical trials rather than all research articles. Only one journal (BMC Medicine) proposed registered reports. At the article level, adoption of open science practices was highest in RCTs: trial registration (99% [95%–100%] vs 68% [55%–79%] in meta-analyses vs 15% [8%–27%] in other research), protocol sharing (95% [90%–98%] vs 67% [54%–78%] vs 19% [11%–32%]), and intention to share data (78% [67%–87%] vs 64% [49%–76%] vs 69% [55%–80%]). Performance across tools was very variable (F1 scores 0.16–1.00). Among all 15,624 research articles, tools detected registration in 20%, protocol sharing in 42%, and intention to share data in 48%, but these were generally underestimated. Policy changes such as mandatory registration or data-sharing requirements were associated with measurable improvements in the corresponding open science practices. Conclusions: Leading medical journals show only partial alignment with TOP2025, with stronger transparency observed for RCTs than for other study types. Triangulation with manual and automated assessments in articles confirms that key open science practices remain suboptimal especially for non-RCTs, highlighting the need for more robust journal policies. Policy changes are associated with observable improvements. Registration: OSF: https://doi.org/10.17605/OSF.IO/F2VW9

- **In the Search for Truth: Navigating Variability in Neuroimaging Software Pipelines.** Youenn Merel Jourdan, Mathieu Acher, and Camille Maumet. *Proceedings of the 29th ACM International Systems and Software Product Line Conference - Volume A, SPLC-A 2025, A Coruña, Spain, September 1-5, 2025*, 2025. [PDF](https://inria.hal.science/hal-05158426v1/file/neurovariants-sigconf.pdf) · [HAL](https://hal.science/hal-05158426) · [DOI](https://doi.org/10.1145/3744915.3748470)
  Abstract: Neuroimaging pipelines -software-driven analysis workflows of brain images -are characterized by a wide range of tools, parameters, and configuration choices. Such flexibility, while enabling diverse scientific inquiries, gives rise to analytical variability: different pipeline variants can lead to different outcomes. In practice, each neuroimaging pipeline variant produces a statistic map -a complex, structured 3D output whose relevance can only be assessed with specific domain expertise, unlike simple metrics such as execution time. And, in most cases, there is no ground truth against which to judge these outputs, making it unclear which variant yields the best result. In this paper, we introduce a "sampling, variant scoring, learning" methodology to study variability in the absence of a quantitative target -i.e. ground truth. We report our experience in developing an Universal Variability Language (UVL) feature model of 90 features representing the configuration space of a well-established open source neuroimaging analysis software (SPM). We sample and run 1000 valid configurations generating 1000 statistic maps as outputs. We studied various candidate proxy ground truths and computed Spearman correlations as a quantitative metric of the performance of each pipeline. We tested the following 12 proxy ground truths: the average statistic map (across variants), the output of an expertderived configuration, and a set of randomly selected outputs (as baseline). Then, we used a decision tree learning approach to inspect variability. We evaluated the sensitivity of our method to the choice of (proxy) ground truth, both in terms of predictive accuracy and in the identification of important features. These first results outline the challenge of choosing and validating a referential to assess our understanding of variability in the absence of ground truth.

- **On the Effect of Feature Reduction on Energy Consumption: An Exploratory Study.** Xhevahire Tërnava, Romain Lefeuvre, Quentin Perez, Djamel Eddine Khelladi, Mathieu Acher, and Benoît Combemale. *Proceedings of the 29th ACM International Systems and Software Product Line Conference - Volume A, SPLC-A 2025, A Coruña, Spain, September 1-5, 2025*, 2025. [PDF](https://hal.science/hal-05166140v1/file/preprint-SPLCA25-paper14.pdf) · [HAL](https://hal.science/hal-05166140) · [DOI](https://doi.org/10.1145/3744915.3748463)
  Abstract: Energy consumption is a growing concern for sustainable software. Although increasingly studied, it remains largely unexplored in configurable systems growing in complexity with features. Feature reduction can eliminate software bloat, but to our knowledge, its impact on energy use has not been investigated. To fill this gap, we investigated how both on-demand and built-in feature reduction (defined later) affect the energy consumption of configurable systems. We conducted a first exploratory study using 28 programs from three systems with built-in feature reduction, namely ToyBox, BusyBox, and GNU, as well as 6 GNU programs debloated on-demand using the Chisel, Debop, and Cov tools. In our results, built-in feature reduction led to statistically significant energy decreases in 7% of the cases, while on-demand reduction, despite achieving energy decreases in 67% of cases, showed no statistical significance. However, when energy consumption increased, it was often more substantial than the reductions observed (occurring in 25% of built-in cases and 11% of on-demand cases) showing the complex and sometimes counterintuitive interplay between feature reduction and energy. Additionally, the observed strong correlation between energy consumption and execution time motivates a shift from traditional debloating goals, centered on binary size/attack surface, to energy-aware strategies that prioritize performance concerns. Finally, we provide an in-depth analysis and discuss the perspective.

- **Software Variability for Replicable Science.** Mathieu Acher. *Invited talk, CBSoft 2025 - Congresso Brasileiro de Software: Teoria e Prática*, 2025. [PDF](https://hal.science/hal-05334168v1/file/VariabilityReplicabilityCBSOFT-AcherM.pdf) · [HAL](https://hal.science/hal-05334168)
  Abstract: The ability to recreate computational results provides a solid foundation for scientific research. Yet, reproducibility and getting identical results with the original data, code, and environment are challenging, due to many uncontrolled or undocumented variability factors. When reproduction is achieved, replicability can be envisioned to check whether conclusions still hold or generalize when well-controlled changes—created by inevitable software variability—are introduced. In this talk, I will first provide evidence that deep software variability — spanning operating systems, compilers, input data, versions, and configurations, etc. — is impacting reproducibility and replicability in numerous fields of computational science. I will then present an approach based on "modelling, sampling, measuring, learning" to systematically explore variability spaces of neuroimaging pipelines. I will also illustrate how Masters` students et INSA Rennes leverage variability to reproduce and replicate studies in soccer, chess, and energy consumption. Throughout this talk, I will try to convince the audience that software-engineering and variability researchers have a key role to play for truly replicable science. Keynote (invited talk) at CBSoft Brazilian Symposium on Software Components, Architectures, and Reuse https://cbsoft.sbc.org.br/2025/sbcars/palestras/?lang=en

- **Exploring the Computational Complexity of Uniform Random Sampling and SAT Counting with Phase Transitions.** Olivier Zeyen, Maxime Cordy, Gilles Perrouin, and Mathieu Acher. *Proceedings of the 29th ACM International Systems and Software Product Line Conference - Volume A, SPLC-A 2025, A Coruña, Spain, September 1-5, 2025*, 2025. [DOI](https://doi.org/10.1145/3744915.3748473)
  Abstract: Uniform Random Sampling (URS) and Model Counting (#SAT) are two intrinsically linked, theoretical problems with relevant practical applications in software engineering. In particular, in configurable system engineering, URS and #SAT can support studying configurations’ properties unbiasedly. Despite the community efforts to provide scalable URS and #SAT tools, solving these problems efficiently remains challenging for a large number of formulae. Contrary to the classical SAT problem, whose complexity has been an object of fundamental studies, little is known about what makes a formula hard to sample from. For the first time, we investigate how phase transitions can explain the practical complexity of sampling. Our results, computed on 11,409 synthetic formulae and 4656 real-world formulae, show that phase transitions occur in both cases, but at a different clause-to-variable ratio than for SAT tasks. We further reveal that low formula modularity is correlated with a higher URS/#SAT time. Overall, our work contributes to a principled understanding of URS and #SAT complexity.

- **Teaching Reproducibility and Embracing Variability: From Floating-Point Experiments to Replicating Research.** Mathieu Acher, Arnaud Gotlieb, Helge Spieker, and Gauthier Le Bartz Lyan. *Proceedings of the 3rd ACM Conference on Reproducibility and Replicability, ACM REP 2025, Vancouver, Canada, July 29-31, 2025*, 2025. [PDF](https://inria.hal.science/hal-05190848v1/file/REP_2025_TeachingAcherM.pdf) · [HAL](https://hal.science/hal-05190848) · [DOI](https://doi.org/10.1145/3736731.3746162)
  Abstract: Reproducibility is often discussed but rarely practiced in undergraduate computer science education. In this paper, we present the design, implementation, and evaluation of a 24-hour hands-on course entirely dedicated to reproducibility and variability in computational experiments. Taught to fourth-and fifth-year students at INSA Rennes in Fall 2024, the course combines scientific thinking, software engineering practices, and variability analysis. Students first explored the non-associativity of floating-point arithmetic as a reproducibility "Hello World" using Docker, GitHub Actions, and templated experimentation to analyze sources of variability across programming languages, compiler flags, and numerical precision. The second half of the course focused on reproducing and replicating actual research papers, including studies on large language models playing chess, home advantage in football during COVID-19, and energy efficiency across programming languages. Students successfully reproduced key results, identified subtle reproducibility issues such as changes in library defaults, and designed replications that extended or challenged original findings. We describe the course structure, pedagogical strategies, and lessons learned, including when students found reproducibility flaws in the instructor's own prior work. Our experience suggests that reproducibility and variability deserve a central place in computer science education and can be taught in a way that is both technically rigorous and scientifically engaging.

- **Prompting for Performance: Exploring LLMs for Configuring Software.** Helge Spieker, Théo Matricon, Nassim Belmecheri, Jørn Eirik Betten, Gauthier Le Bartz Lyan, Heraldo Borges, Quentin Mazouni, Dennis Gross, Arnaud Gotlieb, and Mathieu Acher. *CoRR, abs/2507.09790*, 2025. [DOI](https://doi.org/10.48550/arXiv.2507.09790) · [arXiv](https://arxiv.org/abs/2507.09790) · [Published version](/publications/#spieker2025prompting)
  Abstract: Software systems usually provide numerous configuration options that can affect performance metrics such as execution time, memory usage, binary size, or bitrate. On the one hand, making informed decisions is challenging and requires domain expertise in options and their combinations. On the other hand, machine learning techniques can search vast configuration spaces, but with a high computational cost, since concrete executions of numerous configurations are required. In this exploratory study, we investigate whether large language models (LLMs) can assist in performance-oriented software configuration through prompts. We evaluate several LLMs on tasks including identifying relevant options, ranking configurations, and recommending performant configurations across various configurable systems, such as compilers, video encoders, and SAT solvers. Our preliminary results reveal both positive abilities and notable limitations: depending on the task and systems, LLMs can well align with expert knowledge, whereas hallucinations or superficial reasoning can emerge in other cases. These findings represent a first step toward systematic evaluations and the design of LLM-based solutions to assist with software configuration.

- **Linux Kernel Configurations at Scale: A Dataset for Performance and Evolution Analysis.** Heraldo Borges, Juliana Alves Pereira, Djamel Eddine Khelladi, and Mathieu Acher. *Proceedings of the 29th International Conference on Evaluation and Assessment in Software Engineering, EASE 2025, Istanbul, Turkey, June 17-20, 2025*, 2025. [PDF](https://hal.science/hal-05063560v1/file/EASE2025_LinuxKernelDatapaper.pdf) · [HAL](https://hal.science/hal-05063560) · [DOI](https://doi.org/10.1145/3756681.3757004) · [arXiv](https://arxiv.org/abs/2505.07487)
  Abstract: Configuring the Linux kernel to meet specific requirements, such as binary size, is highly challenging due to its immense complexity—with over 15,000 interdependent options evolving rapidly across different versions. Although several studies have explored sampling strategies and machine learning methods to understand and predict the impact of configuration options, the literature still lacks a comprehensive and large-scale dataset encompassing multiple kernel versions along with detailed quantitative measurements. To bridge this gap, we introduce TuxKConfig, an accessible collection of kernel configurations spanning several kernel releases, specifically from versions 4.13 to 5.8. This dataset, gathered through automated tools and build processes, comprises over 240,000 kernel configurations systematically labeled with compilation outcomes and binary sizes. By providing detailed records of configuration evolution and capturing the intricate interplay among kernel options, our dataset enables innovative research in feature subset selection, prediction models based on machine learning, and transfer learning across kernel versions. Throughout this paper, we describe how the dataset has been made easily accessible via OpenML and illustrate how it can be leveraged using only a few lines of Python code to evaluate AI-based techniques, such as supervised machine learning. We anticipate that this dataset will significantly enhance reproducibility and foster new insights into configuration-space analysis at a scale that presents unique opportunities and inherent challenges, thereby advancing our understanding of the Linux kernel’s configurability and evolution.

- **Exploring Performance of Configurable Software Systems: the JHipster Case Study.** Édouard Guégain, Alexandre Bonvoisin, Mathieu Acher, Clément Quinton, and Romain Rouvoy. *Proceedings of the 29th International Conference on Evaluation and Assessment in Software Engineering, EASE 2025, Istanbul, Turkey, June 17-20, 2025*, 2025. [PDF](https://hal.science/hal-05003699v2/file/EASE2025.pdf) · [HAL](https://hal.science/hal-05003699) · [DOI](https://doi.org/10.1145/3756681.3756936) · [arXiv](https://arxiv.org/abs/2409.16480)
  Abstract: The performance of software systems remains a key concern in software engineering. Configurable software systems, with their numerous configurations, complicate the performance evaluation process. This paper investigates the impact of web stack configurations on performance, using the JHipster web stack generator as a case study. We analyze JHipster configurations to understand how component choices influence system performance and explore individual configuration options for their specific effects. Our study shows that correlations across performance indicators exist but are often weak, and different options affect performance unevenly, with some impacting one indicator minimally while significantly influencing another. We developed a performance model for JHipster to automate the identification of configurations optimized for specific metrics, identifying four configurations that outperform the current default. Overall, this study underscores JHipster’s relevance as a use case for studying component-level variability in software systems and highlights the importance of selecting configurations based on performance indicators rather than preferred technologies.

- **LLM Code Customization with Visual Results: A Benchmark on TikZ.** Charly Reux, Mathieu Acher, Djamel Eddine Khelladi, Clément Quinton, and Olivier Barais. *Proceedings of the 29th International Conference on Evaluation and Assessment in Software Engineering, EASE 2025, Istanbul, Turkey, June 17-20, 2025*, 2025. [PDF](https://hal.science/hal-05049250v2/file/main.pdf) · [HAL](https://hal.science/hal-05049250) · [DOI](https://doi.org/10.1145/3756681.3757003) · [arXiv](https://arxiv.org/abs/2505.04670)
  Abstract: With the rise of AI-based code generation, customizing existing code out of natural language instructions to modify visual results -such as figures or images -has become possible, promising to reduce the need for deep programming expertise. However, even experienced developers can struggle with this task, as it requires identifying relevant code regions (feature location), generating valid code variants, and ensuring the modifications reliably align with user intent. In this paper, we introduce vTikZ, the first benchmark designed to evaluate the ability of Large Language Models (LLMs) to customize code while preserving coherent visual outcomes. Our benchmark consists of carefully curated vTikZ editing scenarios, parameterized ground truths, and a reviewing tool that leverages visual feedback to assess correctness. Empirical evaluation with stateof-the-art LLMs shows that existing solutions struggle to reliably modify code in alignment with visual intent, highlighting a gap in current AI-assisted code editing approaches. We argue that vTikZ opens new research directions for integrating LLMs with visual feedback mechanisms to improve code customization tasks in various domains beyond TikZ, including image processing, art creation, Web design, and 3D modeling.

- **LLM Code Customization with Visual Results: A Benchmark on TikZ.** Charly Reux, Mathieu Acher, Djamel Eddine Khelladi, Olivier Barais, and Clément Quinton. *CoRR, abs/2505.04670*, 2025. [DOI](https://doi.org/10.48550/arXiv.2505.04670) · [arXiv](https://arxiv.org/abs/2505.04670) · [Published version](/publications/#reux2025llm)
  Abstract: With the rise of AI-based code generation, customizing existing code out of natural language instructions to modify visual results -such as figures or images -has become possible, promising to reduce the need for deep programming expertise. However, even experienced developers can struggle with this task, as it requires identifying relevant code regions (feature location), generating valid code variants, and ensuring the modifications reliably align with user intent. In this paper, we introduce vTikZ, the first benchmark designed to evaluate the ability of Large Language Models (LLMs) to customize code while preserving coherent visual outcomes. Our benchmark consists of carefully curated vTikZ editing scenarios, parameterized ground truths, and a reviewing tool that leverages visual feedback to assess correctness. Empirical evaluation with stateof-the-art LLMs shows that existing solutions struggle to reliably modify code in alignment with visual intent, highlighting a gap in current AI-assisted code editing approaches. We argue that vTikZ opens new research directions for integrating LLMs with visual feedback mechanisms to improve code customization tasks in various domains beyond TikZ, including image processing, art creation, Web design, and 3D modeling.

- **Linux Kernel Configurations at Scale: A Dataset for Performance and Evolution Analysis.** Heraldo Borges, Juliana Alves Pereira, Djamel Eddine Khelladi, and Mathieu Acher. *CoRR, abs/2505.07487*, 2025. [DOI](https://doi.org/10.48550/arXiv.2505.07487) · [arXiv](https://arxiv.org/abs/2505.07487) · [Published version](/publications/#borges2025linux)
  Abstract: Configuring the Linux kernel to meet specific requirements, such as binary size, is highly challenging due to its immense complexity-with over 15,000 interdependent options evolving rapidly across different versions. Although several studies have explored sampling strategies and machine learning methods to understand and predict the impact of configuration options, the literature still lacks a comprehensive and large-scale dataset encompassing multiple kernel versions along with detailed quantitative measurements. To bridge this gap, we introduce LinuxData, an accessible collection of kernel configurations spanning several kernel releases, specifically from versions 4.13 to 5.8. This dataset, gathered through automated tools and build processes, comprises over 240,000 kernel configurations systematically labeled with compilation outcomes and binary sizes. By providing detailed records of configuration evolution and capturing the intricate interplay among kernel options, our dataset enables innovative research in feature subset selection, prediction models based on machine learning, and transfer learning across kernel versions. Throughout this paper, we describe how the dataset has been made easily accessible via OpenML and illustrate how it can be leveraged using only a few lines of Python code to evaluate AI-based techniques, such as supervised machine learning. We anticipate that this dataset will significantly enhance reproducibility and foster new insights into configuration-space analysis at a scale that presents unique opportunities and inherent challenges, thereby advancing our understanding of the Linux kernel's configurability and evolution.

- **Unveiling the Impact of Sampling on Feature Selection for Performance Prediction in Configurable Systems.** João Marcello Bessal, Millena Cavalcanti, Mathieu Acher, Markus Endler, and Juliana Alves Pereira. *22nd IEEE/ACM International Conference on Software and Systems Reuse, ICSR 2025, Ottawa, ON, Canada, April 27-28, 2025*, 2025. [DOI](https://doi.org/10.1109/icsr66718.2025.00012)
  Abstract: Modern software systems are highly configurable, offering a vast number of configuration options that can be customized to meet specific functional and non-functional requirements. To support the configuration process, several automated software approaches based on machine learning have been proposed in the literature. These approaches aim to assist developers by predicting non-functional properties based on configuration settings. A recent study demonstrated the potential of leveraging a subset of configuration options (a.k.a. features) to achieve accurate performance predictions in the Linux kernel. The promise of learning over a reduced set of features – instead of all features – is to obtain performance models that are faster to compute, simpler to interpret, and still accurate. Despite the encouraging results of the original study, several questions remain unresolved: Can the findings be generalized to other configurable systems other than Linux? Which learning algorithms deliver the most efficient results when working with a reduced number of features? What are the most effective sampling strategies for building accurate and efficient models? In this work, we extend the original study by conducting an in-depth analysis across eight configurable systems. We evaluate the impact of sampling strategies and learning algorithms on model accuracy and training efficiency. Our goal is to understand whether there is a dominant sampling strategy and learning algorithm for varying systems and performance targets. Our results reveal variability in optimal strategies across systems and advocate for tailored approaches rather than universal solutions.

- **Poster: Quantification of Feature-Interaction Masking in JHipster.** Tim Jannik Schmidt, Sabrina Böhm, Sebastian Krieter, Thomas Thüm, and Mathieu Acher. *IEEE Conference on Software Testing, Verification and Validation, ICST 2025, Napoli, Italy, March 31 - April 4, 2025*, 2025. [DOI](https://doi.org/10.1109/icst62969.2025.10989017)
  Abstract: Configurable software systems, such as software product lines, enable the generation of products based on configurations tailored to specific requirements by combining reusable features. A key challenge in product lines lies in combinatorial interaction testing, which ensures that all possible feature combinations are tested to identify configurations that may fail. When a configuration fails, pinpointing the feature or the feature interaction causing the fault is crucial. However, fault masking - where faulty interactions remain undetected because other features or interactions could override their effects - potentially hinders the effective identification of faults in product lines. Despite the potential of missing critical interaction faults, fault masking in product lines has received limited attention in existing research. To address this gap, we investigate and analyze on already identified faults of the real-world product line JHipster and quantitatively analyze these faults in terms of masking. In our case study, we find evidence of the existence of fault masking in JHipster and how the detectability of masked faults is influenced. For one feature-interaction fault in JHipster, we miss to identify 17.6% of all configurations containing this fault due to masking effects. By analyzing masked faults of a real-world product line, we raise awareness of investigating feature-interaction masking further in software product lines.

- **Testing Uniform Random Samplers: Methods, Datasets and Protocols.** Olivier Zeyen, Maxime Cordy, Martin Gubri, Gilles Perrouin, and Mathieu Acher. *CoRR, abs/2503.14079*, 2025. [DOI](https://doi.org/10.48550/arXiv.2503.14079) · [arXiv](https://arxiv.org/abs/2503.14079) · [Published version](/publications/#zeyen2026testing)
  Abstract: Boolean formulae compactly encode huge, constrained search spaces. Thus, variability-intensive systems are often encoded with Boolean formulae. The search space of a variability-intensive system is usually too large to explore without statistical inference (e.g. testing). Testing every valid configuration is computationally expensive (if not impossible) for most systems. This leads most testing approaches to sample a few configurations before analyzing them. A desirable property of such samples is uniformity: Each solution should have the same selection probability. Uniformity is the property that facilitates statistical inference. This property motivated the design of uniform random samplers, relying on SAT solvers and counters and achieving different trade-offs between uniformity and scalability. Though we can observe their performance in practice, judging the quality of the generated samples is different. Assessing the uniformity of a sampler is similar in nature to assessing the uniformity of a pseudo-random number (PRNG) generator. However, sampling is much slower and the nature of sampling also implies that the hyperspace containing the samples is constrained. This means that testing PRNGs is subject to fewer constraints than testing samplers. We propose a framework that contains five statistical tests which are suited to test uniform random samplers. Moreover, we demonstrate their use by testing seven samplers. Finally, we demonstrate the influence of the Boolean formula given as input to the samplers under test on the test results.

- **Proceedings of the 19th International Working Conference on Variability Modelling of Software-Intensive Systems, VaMoS 2025, Rennes, France, February 4-6, 2025.** Mathieu Acher, Juliana Alves Pereira, and Clément Quinton (eds.). *Edited volume, ACM*, 2025. [DOI](https://doi.org/10.1145/3715340)

- **Re-evaluating metamorphic testing of chess engines: A replication study.** Axel Martin, Djamel Eddine Khelladi, Théo Matricon, and Mathieu Acher. *Information & Software Technology, 181*, 2025. [PDF](https://hal.science/hal-04943474v2/file/IST-StockfishMTTestingChessv2.pdf) · [HAL](https://hal.science/hal-04943474) · [DOI](https://doi.org/10.1016/j.infsof.2025.107679)
  Abstract: Context: This study aims to confirm, replicate and extend the findings of a previous article entitled ”Metamorphic Testing of Chess Engines” that reported inconsistencies in the analyses provided by Stockfish, the most widely used chess engine, for transformed chess positions that are fundamentally identical. Initial findings, under conditions strictly identical to those of the original study, corroborate the reported inconsistencies. Objective: However, the original article considers a specific dataset (including randomly generated chess positions, end-games, or checkmate problems) and very low analysis depth (10 plies,1 corresponding to 5 moves). These decisions pose threats that limit generalizability of the results, but also their practical usefulness both for chess players and maintainers of Stockfish. Thus, we replicate the original study. Methods: We consider this time (1) positions derived from actual chess games, (2) analyses at appropriate and larger depths, and (3) different versions of Stockfish. We conduct novel experiments on thousands of positions, employing significantly deeper searches. Results: The replication results show that the Stockfish chess engines demonstrate significantly greater consistency in its evaluations. The metamorphic relations are not as effective as in the original article, especially on realistic chess positions. We also demonstrate that, for any given position, there exists a depth threshold beyond which further increases in depth do not result in any evaluation differences for the studied metamorphic relations. We perform an in-depth analysis to identify and clarify the implementation reasons behind Stockfish’s inconsistencies when dealing with transformed positions. Conclusion: A first concrete result is thus that metamorphic testing of chess engines is not yet an effective technique for finding faults of Stockfish. Another result is the lessons learned through this replication effort: metamorphic relations must be verified in the context of the domain’s specificities; without such contextual validation, they may lead to misleading or irrelevant conclusions; changes in parameters and input dataset can drastically alter the effectiveness of a testing method.

- **Automated Co-Evolution of Metamodels and Code.** Zohra Kaouter Kebaili, Djamel Eddine Khelladi, Mathieu Acher, and Olivier Barais. *IEEE Transactions on Software Engineering (TSE), 51(4)*, 2025. [PDF](https://hal.science/hal-04973171v1/file/Automated_coevolution_of_metamodel_and_code_FINAL_TSE.pdf) · [HAL](https://hal.science/hal-04973171) · [DOI](https://doi.org/10.1109/tse.2025.3540545)
  Abstract: In Software Engineering, Model-Driven Engineering (MDE) is a methodology that considers Metamodels as a cornerstone. As an abstract artifact, a metamodel plays a significant role in the specification of a software language, particularly, in generating other artifacts of lower abstraction level, such as code. Developers then enrich the generated code to build their language services and tooling, e.g., editors, and checkers. Problem. When a metamodel evolves, the generated code is automatically updated. As a consequence, the developers' additional code is impacted and needs to be co-evolved accordingly. Contribution. This paper proposes a new fully automatic code co-evolution approach with the evolution of the Ecore metamodel. The approach relies on pattern matching of the additional code errors. This process aims to analyze the abstraction gap between the evolved metamodel elements and the code errors to co-evolve them. Evaluation and Results. We evaluated our approach on nine Eclipse projects from OCL, Modisco, and Papyrus over several evolved versions of three metamodels. Results show that we automatically co-evolved 771 errors due to metamodel evolution with 631 matched and applied resolutions. Our approach reached an average of 82% of precision and 81% of recall, varying from 48% to 100% for precision and recall respectively. To check the effect of the co-evolution and its behavioral correctness, we rely on generated test cases before and after co-evolution. We observed that the percentage of passing, failing, and erroneous tests remained the same with insignificant variations in some projects. Thus, suggesting the behavioral correctness of the co-evolution Moreover, we conducted a comparison with the use of quick fixes that represent a usual tool for correcting code errors in an IDE. We found that our automatic co-evolution approach outperforms the use of quick fixes that lacked the context of metamodel evolution. Finally, we also compared our approach with the state-of-the-art semi-automatic co-evolution approach. As expected, precision and recall are slightly better with semi-automation, but with the burden of manual intervention, which is alleviated with our automatic co-evolution.

- **Policy Testing with MDPFuzz (Replicability Study).** Quentin Mazouni, Helge Spieker, Arnaud Gotlieb, and Mathieu Acher. *CoRR, abs/2502.19116*, 2025. [DOI](https://doi.org/10.48550/arXiv.2502.19116) · [arXiv](https://arxiv.org/abs/2502.19116) · [Published version](/publications/#10.1145/3650212.3680382)
  Abstract: In recent years, following tremendous achievements in Reinforcement Learning, a great deal of interest has been devoted to ML models for sequential decision-making. Together with these scientific breakthroughs/advances, research has been conducted to develop automated functional testing methods for finding faults in black-box Markov decision processes. Pang et al. (ISSTA 2022) presented a black-box fuzz testing framework called MDPFuzz. The method consists of a fuzzer whose main feature is to use Gaussian Mixture Models (GMMs) to compute coverage of the test inputs as the likelihood to have already observed their results. This guidance through coverage evaluation aims at favoring novelty during testing and fault discovery in the decision model. Pang et al. evaluated their work with four use cases, by comparing the number of failures found after twelve-hour testing campaigns with or without the guidance of the GMMs (ablation study). In this paper, we verify some of the key findings of the original paper and explore the limits of MDPFuzz through reproduction and replication. We re-implemented the proposed methodology and evaluated our replication in a large-scale study that extends the original four use cases with three new ones. Furthermore, we compare MDPFuzz and its ablated counterpart with a random testing baseline. We also assess the effectiveness of coverage guidance for different parameters, something that has not been done in the original evaluation. Despite this parameter analysis and unlike Pang et al.'s original conclusions, we find that in most cases, the aforementioned ablated Fuzzer outperforms MDPFuzz, and conclude that the coverage model proposed does not lead to finding more faults.

- **Policy Testing with MDPFuzz (Replicability Study).** Quentin Mazouni, Helge Spieker, Arnaud Gotlieb, and Mathieu Acher. *Software Engineering 2025, Fachtagung des GI-Fachbereichs Softwaretechnik, Karlsruhe, Germany, February 24-28, 2025*, 2025. [DOI](https://doi.org/10.18420/SE2025-10)

- **Unify and Triumph: Polyglot, Diverse, and Self-Consistent Generation of Unit Tests with LLMs.** Djamel Eddine Khelladi, Charly Reux, and Mathieu Acher. *CoRR, abs/2503.16144*, 2025. [DOI](https://doi.org/10.48550/arXiv.2503.16144) · [arXiv](https://arxiv.org/abs/2503.16144)
  Abstract: Large language model (LLM)-based test generation has gained attention in software engineering, yet most studies evaluate LLMs' ability to generate unit tests in a single attempt for a given language, missing the opportunity to leverage LLM diversity for more robust testing. This paper introduces PolyTest, a novel approach that enhances test generation by exploiting polyglot and temperature-controlled diversity. PolyTest systematically leverages these properties in two complementary ways: (1) Cross-lingual test generation, where tests are generated in multiple languages at zero temperature and then unified; (2) Diverse test sampling, where multiple test sets are generated within the same language at a higher temperature before unification. A key insight is that LLMs can generate diverse yet contradicting tests – same input, different expected outputs – across languages and generations. PolyTest mitigates inconsistencies by unifying test sets, fostering self-consistency and improving overall test quality. Unlike single-language or single-attempt approaches, PolyTest enhances testing without requiring on-the-fly execution, making it particularly beneficial for weaker-performing languages. We evaluate PolyTest on Llama3-70B, GPT-4o, and GPT-3.5 using EvalPlus, generating tests in five languages (Java, C, Python, JavaScript, and a CSV-based format) at temperature 0 and sampling multiple sets at temperature 1. We observe that LLMs frequently generate contradicting tests across settings, and that PolyTest significantly improves test quality across all considered metrics – number of tests, passing rate, statement/branch coverage (up to +9.01%), and mutation score (up to +11.23%). Finally, PolyTest outperforms Pynguin in test generation, passing rate, and mutation score.

- **Efficiently Ranking Software Variants with Minimal Benchmarks.** Théo Matricon, Mathieu Acher, Helge Spieker, and Arnaud Gotlieb. *CoRR, abs/2509.06716*, 2025. [DOI](https://doi.org/10.48550/arXiv.2509.06716) · [arXiv](https://arxiv.org/abs/2509.06716)
  Abstract: Benchmarking is a common practice in software engineering to assess the qualities and performance of software variants, coming from multiple competing systems or from configurations of the same system. Benchmarks are used notably to compare and understand variant performance, fine-tune software, detect regressions, or design new software systems. The execution of benchmarks to get a complete picture of software variants is highly costly in terms of computational resources and time. In this paper, we propose a novel approach for reducing benchmarks while maintaining stable rankings, using test suite optimization techniques. That is, we remove instances from the benchmarks while trying to keep the same rankings of the variants on all tests. Our method, BISection Sampling, BISS, strategically retains the most critical tests and applies a novel divide-and-conquer approach to efficiently sample among relevant remaining tests. We experiment with datasets and use cases from LLM leaderboards, SAT competitions, and configurable systems for performance modeling. Our results show that our method outperforms baselines even when operating on a subset of variants. Using BISS, we reduce the computational cost of the benchmarks on average to 44% and on more than half the benchmarks by up to 99% without loss in ranking stability.

- **Automated testing of metamodels and code co-evolution.** Zohra Kaouter Kebaili, Djamel Eddine Khelladi, Mathieu Acher, and Olivier Barais. *Software and Systems Modeling, 24(2)*, 2025. [PDF](https://hal.science/hal-04932177v1/file/Automated_Testing_of_the_Metamodels_and_Code_Co_evolution_SOSYM23_final.pdf) · [HAL](https://hal.science/hal-04932177) · [DOI](https://doi.org/10.1007/s10270-024-01245-2)
  Abstract: Metamodels are cornerstone in MDE. They define the different domain concepts and the relations between them. A metamodel is also used to generate concrete artifacts such as code. Developers then rely on the generated code to build their language services and tooling, e.g., editors, checkers. To check the behavior of their client code, developers write or generate unit tests. As metamodels evolve between releases, the generated code is automatically updated. As a consequence, the additional developers' code is impacted and is co-evolved accordingly for each release. However, there is no guarantee that the co-evolution of the code is performed correctly. One way to do so is to re-run all the tests after each code co-evolution, which is expensive and time-consuming. This paper proposes an automatic solution for tracing impacted tests due to metamodel evolution. Thus, we end up matching metamodel changes with impacted code methods and their corresponding tests both in the original and evolved versions of a given project. After that, we map the two versions of the impacted tests and compare them to analyze the behavior of the code before and after its evolution due to the metamodel evolution. In particular, we implemented an Eclipse plugin that allows tracing, mapping, execution, and reporting back the results to the developers for easier in-depth analysis of the effect of metamodel evolutions rather than analyzing the whole test suite. We first ran a user study experiment to gain evidence on the difficulty or not of the manual task of tracing impacted tests. We found that manually tracing the 1 tests impacted by the evolution of the metamodel is a hard and error-prone task. Not only the participants could not trace all tests, but they even wrongly traced non-impacted tests. We then evaluated our approach on 18 Eclipse projects from OCL, Modisco, Papyrus, and EMF over several evolved versions of metamodels. For the 14 projects without manual tests, we generated a test suite for each release with the state-of-the-art tool EvoSuite. The results show that we successfully traced the impacted tests automatically by selecting 1608 out of 34612 tests due to 473 metamodel changes. When running the traced tests before and after coevolution, we observed cases indicating possibly both behaviorally correct and incorrect code co-evolution. Finally, we reached gains representing, on average, a reduction of 88% in the number of tests and 84% in the execution time.

- **Mutation-Guided Metamorphic Testing of Optimality in AI Planning.** Quentin Mazouni, Arnaud Gotlieb, Helge Spieker, Mathieu Acher, and Benoît Combemale. *Software Testing, Verification & Reliability (STVR), 35(1)*, 2025. [PDF](https://hal.science/hal-05494710v1/file/STVR_MT_for_AI_Planning-RIPOST.pdf) · [HAL](https://hal.science/hal-05494710) · [DOI](https://doi.org/10.1002/stvr.1898)
  Abstract: Autonomous systems such as space- or underwater-exploration robots or elderly people assistance robots often include an artificial intelligence (AI) planner as a component. Starting from the initial state of a system, an AI planner automatically generates sequential plans to reach final states that satisfy user-specified goals. Generating plans having a minimum number of intermediate steps or taking the least time to execute is usually strongly desired, as these plans exhibit minimal costs. Unfortunately, testing if an AI planner generates optimal plans is almost impossible because the expected cost of these plans is usually unknown. Based on mutation adequacy test suite selection, this article proposes a novel metamorphic testing framework for detecting the lack of optimality in AI planners. The general idea is to perform a systematic but non-exhaustive state space exploration from the initial state and to select mutant-adequate states to instantiate new planning tasks as follow-up test cases. We then check a metamorphic relation between the automatically generated solutions of the AI planner for these new test cases and the cost of the initial plan. We implemented this metamorphic testing framework in a tool called MorphinPlan. Our experimental evaluation shows that MorphinPlan can detect non-optimal behaviour in both mutated AI planners and off-the-shelf, configurable planners. It also shows that our proposed mutation adequacy test selection strategy outperforms three alternative test generation and selection strategies, including both random state selection and random walks through the state space in terms of mutation scores.

- **Un ordinateur, ça ne calcule jamais juste.** Mathieu Acher and Jean-Marc Jézéquel. *In Le calcul à découvert, CNRS Éditions*, 2025.

## 2024

- **Generative AI for Generative Programming: Automating Code Variants and Exploring the Boundaries of LLMs.** Mathieu Acher. *Invited talk, Normastic day on Large Language Models, Caen, France, 28 November 2024*, 2024. [PDF](https://hal.science/hal-04809253v1/file/Normastic-GenerativeAI4GenerativeProgramming-final.pdf) · [HAL](https://hal.science/hal-04809253)
  Abstract: Large language models (LLMs) can be used to automate software engineering tasks, with the hope of boosting developers' productivity without sacrificing reliability. In this talk, I will briefly present two initiatives: the défi Inria LLM4Code and the CodeCommons project around SoftwareHeritage, exemplifying ongoing research efforts. Then, I will show how LLMs can automatically generate software variants across different technological spaces (Python, Rust, JavaScript, etc.) and implement new features from simple prompts. I will also highlight how LLMs can assist in modernizing legacy applications, such as those written in COBOL or in deprecated technologies. I will further discuss the concept of programming without directly manipulating programs, relying almost entirely on AI to manage technical details and customize code. For all their potential, I will also demonstrate that LLMs can dramatically fail at times, making mistakes that human developers need to carefully verify and correct. I will conclude with an illustration of LLM prompt sensitivity in chess, showcasing how LLMs can be used both to generate variants (e.g., prompts, hypotheses, ideas) and to accelerate scientific discovery through software-based exploration and analysis. 28 november 2024 @ Caen, invited talk at Normastic https://www.normastic.fr/event/journee-de-laxe-donnees-apprentissage-connaissances-large-language-models-llms

- **Un ordinateur, ça ne calcule jamais juste.** Mathieu Acher. *Talk, Fête de la science, INSA Rennes*, 2024. [PDF](https://hal.science/hal-04736121v1/file/INSA-Science2425-final.pdf) · [HAL](https://hal.science/hal-04736121)
  Abstract: Un ordinateur ne calcule jamais parfaitement. Par exemple, si on additionne trois nombres de différentes façons, le résultat peut changer selon le langage de programmation ou l'ordinateur utilisé. Cela peut même amener des robots, voitures ou avions à prendre des chemins différents selon les conditions. Ou à votre application préférée de retourner une réponse, une image ou une vidéo différente ! En informatique, comme dans toutes les sciences, il est important de comprendre que les calculs ont toujours une petite marge d'erreur. Ce qui compte, ce n'est pas la perfection, mais d'en être conscient, de savoir s'adapter et corriger le tir quand c'est nécessaire ! Un ordinateur, ça ne calcule jamais juste… Ou pourquoi les ordinateurs nous trompent parfois Fête de la science, INSA Rennes

- **Exploring Performance Trade-offs in JHipster.** Edouard Guégain, Alexandre Bonvoisin, Clément Quinton, Mathieu Acher, and Romain Rouvoy. *CoRR, abs/2409.16480*, 2024. [DOI](https://doi.org/10.48550/arXiv.2409.16480) · [arXiv](https://arxiv.org/abs/2409.16480) · [Published version](/publications/#guegain2025exploring)
  Abstract: The performance of software systems remains a persistent concern in the field of software engineering. While traditional metrics like binary size and execution time have long been focal points for developers, the power consumption concern has gained significant attention, adding a layer of complexity to performance evaluation. Configurable software systems, with their potential for numerous configurations, further complicate this evaluation process. In this experience paper, we examine the impact of configurations on performance, specifically focusing on the web stack generator JHipster. Our goal is to understand how configuration choices within JHipster influence the performance of the generated system. We undertake an exhaustive analysis of JHipster by examining its configurations and their effects on system performance. Additionally, we explore individual configuration options to gauge their specific influence on performance. Through this process, we develop a comprehensive performance model for JHipster, enabling us to automate the identification of configurations that optimize specific performance metrics. In particular, we identify configurations that demonstrate near-optimal performance across multiple indicators and report on significant correlations between configuration choices within JHipster and the performance of generated systems.

- **An Empirical Study on Leveraging LLMs for Metamodels and Code Co-evolution.** Zohra Kaouter Kebaili, Djamel Eddine Khelladi, Mathieu Acher, and Olivier Barais. *Journal of Object Technology, 23(3)*, 2024. [PDF](https://hal.science/hal-04667772v1/file/article6.pdf) · [HAL](https://hal.science/hal-04667772) · [DOI](https://doi.org/10.5381/jot.2024.23.3.a6)
  Abstract: Metamodels play an important role in MDE and in specifying a software language. They are cornerstone to generate other artifacts of lower abstraction level, such as code. Developers then enrich the generated code to build their language services and tooling, e.g., editors, and checkers. When a metamodel evolves, part of the code is regenerated and all the additional developers’ code can be impacted, thus requiring erroneous code to be co-evolved accordingly. In this paper, we explore a novel approach to mitigate the challenge of metamodel evolution impacts on the code using LLMs. In fact, LLMs stand as promising tools for tackling increasingly complex problems and support developers in various tasks of writing, correcting, and documenting source code, models, and other artifacts. However, while there is an extensive empirical assessment of the LLMs capabilities in generating models, code, and tests, there is a lack of work on their ability to support their maintenance. In this paper, we focus on the particular problem of metamodels and code co-evolution. We first designed a prompt template structure that contains contextual information about metamodel changes, the abstraction gap between the metamodel and the code, and the erroneous code to co-evolve. To investigate the usefulness of this template, we generated three more variations of the prompts. The generated prompts are then given to the LLM to co-evolve the impacted code. We evaluated our generated prompts and other three of their variations with ChatGPT version 3.5 on seven Eclipse projects from OCL and Modisco evolved metamodels. Results show that ChatGPT can co-evolve correctly 88.7% of the errors due to metamodel evolution, varying from 75% to 100% of correctness rate. When varying the prompts, we observed increased correctness in two variants and decreased correctness in another variant. We also observed that varying the temperature hyperparameter yields better results with lower temperatures. Our results are observed on a total of 5320 generated prompts. Finally, when compared to the quick fixes of the IDE, the generated prompts co-evolutions completely outperform the quick fixes.

- **Embracing Deep Variability For Reproducibility and Replicability.** Mathieu Acher, Benoît Combemale, Georges Aaron Randrianaina, and Jean-Marc Jézéquel. *REP 2024 - ACM Conference on Reproducibility and Replicability*, 2024. [PDF](https://hal.science/hal-04582287v1/file/REP_ACM_ReproducibleScienceDeepVariability24.pdf) · [HAL](https://hal.science/hal-04582287) · [DOI](https://doi.org/10.1145/3641525.3663621)
  Abstract: Reproducibility (aka determinism in some cases) constitutes a fundamental aspect in various fields of computer science, such as floating-point computations in numerical analysis and simulation, concurrency models in parallelism, reproducible builds for third parties integration and packaging, and containerization for execution environments. These concepts, while pervasive across diverse concerns, often exhibit intricate inter-dependencies, making it challenging to achieve a comprehensive understanding. In this short and vision paper we delve into the application of software engineering techniques, specifically variability management, to systematically identify and explicit points of variability that may give rise to reproducibility issues (eg language, libraries, compiler, virtual machine, OS, environment variables, etc). The primary objectives are: i) gaining insights into the variability layers and their possible interactions, ii) capturing and documenting configurations for the sake of reproducibility, and iii) exploring diverse configurations to replicate, and hence validate and ensure the robustness of results. By adopting these methodologies, we aim to address the complexities associated with reproducibility and replicability in modern software systems and environments, facilitating a more comprehensive and nuanced perspective on these critical aspects.

- **Deep Software Variability and Frictionless Reproducibility.** Mathieu Acher. *Invited talk, Journées Nationales du GDR GPL 2024*, 2024. [PDF](https://hal.science/hal-04601752v1/file/FrictionlessReproducibilityDeepSoftwareVariability-GDRGPL24.pdf) · [HAL](https://hal.science/hal-04601752)
  Abstract: The ability to recreate computational results with minimal effort and actionable metrics provides a solid foundation for scientific research and software development. When people can replicate an analysis at the touch of a button using open-source software, open data, and methods to assess and compare proposals, it significantly eases verification of results, engagement with a diverse range of contributors, and progress. However, we have yet to fully achieve this; there are still many sociotechnical frictions. Inspired by David Donoho's vision, this talk aims to revisit the three crucial pillars of frictionless reproducibility (data sharing, code sharing, and competitive challenges) with the perspective of deep software variability. Our observation is that multiple layers — hardware, operating systems, third-party libraries, software versions, input data, compile-time options, and parameters — are subject to variability that exacerbates frictions but is also essential for achieving robust, generalizable results and fostering innovation. I will first review the literature, providing evidence of how the complex variability interactions across these layers affect qualitative and quantitative software properties, thereby complicating the reproduction and replication of scientific studies in various fields. I will then present some software engineering and AI techniques that can support the strategic exploration of variability spaces. These include the use of abstractions and models (e.g., feature models), sampling strategies (e.g., uniform, random), cost-effective measurements (e.g., incremental build of software configurations), and dimensionality reduction methods (e.g., transfer learning, feature selection, software debloating). I will finally argue that deep variability is both the problem and solution of frictionless reproducibility, calling the software science community to develop new methods and tools to manage variability and foster reproducibility in software systems.

- **Options Matter: Documenting and Fixing Non-Reproducible Builds in Highly-Configurable Systems.** Georges Aaron Randrianaina, Djamel Eddine Khelladi, Olivier Zendra, and Mathieu Acher. *MSR 2024 - 21st International Conference on Mining Software Repository*, 2024. [PDF](https://inria.hal.science/hal-04441579v2/file/msr24.pdf) · [HAL](https://hal.science/hal-04441579) · [DOI](https://doi.org/10.1145/3643991.3644913)
  Abstract: A critical aspect of software development, build reproducibility, ensures the dependability, security, and maintainability of software systems. Although several factors, including the build environment, have been investigated in the context of non-reproducible builds, to the best of our knowledge the precise influence of configuration options in configurable systems has not been thoroughly investigated. This paper aims at filling this gap. This paper thus proposes an approach for the automatic identification of configuration options causing non-reproducibility of builds. It begins by building a set of builds in order to detect non-reproducible ones through binary comparison. We then develop automated techniques that combine statistical learning with symbolic reasoning to analyze over 20,000 configuration options. Our methods are designed to both detect options causing non-reproducibility, and remedy non-reproducible configurations, two tasks that are challenging and costly to perform manually. We evaluate our approach on three case studies, namely Toybox, Busybox, and Linux, analyzing more than 2,000 configurations for each of them. Toybox and Busybox come exempt from nonreproducibility. In contrast, 47% of Linux configurations lead to non-reproducible builds. The approach we propose in this paper is capable of identifying 10 configuration options that caused this non-reproducibility. When confronted to the Linux documentation, none of these are documented as non-reproducible. Thus, our identified non-reproducible configuration options are novel knowledge and constitutes a direct, actionable information improvement for the Linux community. Finally, we demonstrate that our methodology effectively identifies a set of undesirable option values, enabling the enhancement and expansion of the Linux kernel documentation while automatically rectifying 96% of encountered non-reproducible builds.

- **Testing for Fault Diversity in Reinforcement Learning.** Quentin Mazouni, Helge Spieker, Arnaud Gotlieb, and Mathieu Acher. *CoRR, abs/2403.15065*, 2024. [DOI](https://doi.org/10.48550/arXiv.2403.15065) · [arXiv](https://arxiv.org/abs/2403.15065) · [Published version](/publications/#DBLP:conf/ast/MazouniSGA24)
  Abstract: Reinforcement Learning is the premier technique to approach sequential decision problems, including complex tasks such as driving cars and landing spacecraft. Among the software validation and verification practices, testing for functional fault detection is a convenient way to build trustworthiness in the learned decision model. While recent works seek to maximise the number of detected faults, none consider fault characterisation during the search for more diversity. We argue that policy testing should not find as many failures as possible (e.g., inputs that trigger similar car crashes) but rather aim at revealing as informative and diverse faults as possible in the model. In this paper, we explore the use of quality diversity optimisation to solve the problem of fault diversity in policy testing. Quality diversity (QD) optimisation is a type of evolutionary algorithm to solve hard combinatorial optimisation problems where high-quality diverse solutions are sought. We define and address the underlying challenges of adapting QD optimisation to the test of action policies. Furthermore, we compare classical QD optimisers to state-of-the-art frameworks dedicated to policy testing, both in terms of search efficiency and fault diversity. We show that QD optimisation, while being conceptually simple and generally applicable, finds effectively more diverse faults in the decision model, and conclude that QD-based policy testing is a promising approach.

- **A Demonstration of End-User Code Customization Using Generative AI.** Mathieu Acher. *VAMOS 2024 - 18th International Working Conference on Variability Modelling of Software-Intensive Systems*, 2024. [PDF](https://hal.science/hal-04312909v1/file/DemonstrationVariabilityGPTVaMoS-preprint.pdf) · [HAL](https://hal.science/hal-04312909) · [DOI](https://doi.org/10.1145/3634713.3634732)
  Abstract: Producing a variant of code is highly challenging, particularly for individuals unfamiliar with programming. This demonstration introduces a novel use of generative AI to aid end-users in customizing code. We first describe how generative AI can be used to customize code through prompts and instructions, and further demonstrate its potential in building end-user tools for configuring code. We showcase how to transform an undocumented, technical, low-level TikZ into a user-friendly, configurable, Web-based customization tool written in Python, HTML, CSS, and JavaScript and itself configurable. We discuss how generative AI can support this transformation process and traditional variability engineering tasks, such as identification and implementation of features, synthesis of a template code generator, and development of end-user configurators. We believe it is a first step towards democratizing variability programming, opening a path for end-users to adapt code to their needs.

- **Learning input-aware performance models of configurable systems: An empirical evaluation.** Luc Lesoil, Helge Spieker, Arnaud Gotlieb, Mathieu Acher, Paul Temple, Arnaud Blouin, and Jean-Marc Jézéquel. *Journal of Systems and Software, 208*, 2024. [PDF](https://hal.science/hal-04271476v1/file/JSS_2023___Data_efficient_performance_model-preprint.pdf) · [HAL](https://hal.science/hal-04271476) · [DOI](https://doi.org/10.1016/j.jss.2023.111883)
  Abstract: Modern software-based systems are highly configurable and come with a number of configuration options that impact the performance of the systems. However, selecting inappropriate values for these options can cause long response time, high CPU load, downtime, RAM exhaustion, resulting in performance degradation and poor software reliability. Consequently, considerable effort has been carried out to predict key performance metrics (execution time, program size, energy consumption, etc.) from the user's choice of configuration options values. The selection of inputs (e.g., JavaScript scripts embedded in a web page interpreted by Node.js or input videos encoded with x264 by a streaming platform) also impacts software performance, and there is a complex interplay between inputs and configurations. Unfortunately, owing to the huge variety of existing inputs, it is yet challenging to automate the prediction of software performance whatever their configuration and input. In this article, we empirically evaluate how supervised and transfer learning methods can be leveraged to efficiently learn performance models based on configuration options and input data. Our study over 1,941,075 data points empirically shows that measuring the performance of configurations on multiple inputs allows one to reuse this knowledge and train performance models robust to the change of input data. To the best of our knowledge, this is the first domain-agnostic empirical evaluation of machine learning methods addressing the input-aware performance prediction problem.

- **Policy Testing with MDPFuzz (Replicability Study).** Quentin Mazouni, Helge Spieker, Arnaud Gotlieb, and Mathieu Acher. *Proceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis*, 2024. **Distinguished Paper Award.** [DOI](https://doi.org/10.1145/3650212.3680382) · [arXiv](https://arxiv.org/abs/2502.19116)
  Abstract: In recent years, following tremendous achievements in Reinforcement Learning, a great deal of interest has been devoted to ML models for sequential decision-making. Together with these scientific breakthroughs/advances, research has been conducted to develop automated functional testing methods for finding faults in black-box Markov decision processes. Pang et al. (ISSTA 2022) presented a black-box fuzz testing framework called MDPFuzz. The method consists of a fuzzer whose main feature is to use Gaussian Mixture Models (GMMs) to compute coverage of the test inputs as the likelihood to have already observed their results. This guidance through coverage evaluation aims at favoring novelty during testing and fault discovery in the decision model. Pang et al. evaluated their work with four use cases, by comparing the number of failures found after twelve-hour testing campaigns with or without the guidance of the GMMs (ablation study). In this paper, we verify some of the key findings of the original paper and explore the limits of MDPFuzz through reproduction and replication. We re-implemented the proposed methodology and evaluated our replication in a large-scale study that extends the original four use cases with three new ones. Furthermore, we compare MDPFuzz and its ablated counterpart with a random testing baseline. We also assess the effectiveness of coverage guidance for different parameters, something that has not been done in the original evaluation. Despite this parameter analysis and unlike Pang et al.’s original conclusions, we find that in most cases, the aforementioned ablated Fuzzer outperforms MDPFuzz, and conclude that the coverage model proposed does not lead to finding more faults.

- **Exploring the Computational Complexity of SAT Counting and Uniform Sampling with Phase Transitions.** Olivier Zeyen, Maxime Cordy, Gilles Perrouin, and Mathieu Acher. *Proceedings of the 2024 IEEE/ACM 46th International Conference on Software Engineering: Companion Proceedings, ICSE Companion 2024, Lisbon, Portugal, April 14-20, 2024*, 2024. [DOI](https://doi.org/10.1145/3639478.3643097)
  Abstract: Uniform Random Sampling (URS) is the problem of selecting solutions (models) from a Boolean formula such that each solution gets the same probability of being selected. URS has many applications. In large configurable software systems, one wants an unbiased sample of configurations to look for bugs at an affordable cost [12, 13]. Other applications of URS include deep learning verification (to sample inputs from unknown distributions) [2] and evolutionary algorithms (to initialize the input population) [4].

- **Preprocessing is What You Need: Understanding and Predicting the Complexity of SAT-based Uniform Random Sampling.** Olivier Zeyen, Maxime Cordy, Gilles Perrouin, and Mathieu Acher. *Proceedings of the 2024 IEEE/ACM 12th International Conference on Formal Methods in Software Engineering (FormaliSE), Lisbon, Portugal, April 14-15, 2024*, 2024. [DOI](https://doi.org/10.1145/3644033.3644371)
  Abstract: Despite its NP-completeness, the Boolean satisfiability problem gave birth to highly efficient tools that are able to find solutions to a Boolean formula and compute their number. Boolean formulae compactly encode huge, constrained search spaces for variability-intensive systems, e.g., the possible configurations of the Linux kernel. These search spaces are generally too big to explore exhaustively, leading most testing approaches to sample a few solutions before analysing them. A desirable property of such samples is uniformity: each solution should get the same selection probability. This property motivated the design of uniform random samplers, relying on SAT solvers and counters and achieving different tradeoffs between uniformity and scalability. Though we can observe their performance in practice, understanding the complexity these tools face and accurately predicting it is an under-explored problem. Indeed, structural metrics such as the number of variables and clauses involved in a formula poorly predict the sampling complexity. More elaborated ones, such as minimal independent support (MIS), are intractable to compute on large formulae. We provide an efficient parallel algorithm to compute a related metric, the number of equivalence classes, and demonstrate that this metric is highly correlated to time and memory usage of uniform random sampling and model counting tools. We explore the role of formula preprocessing on various metrics and show its positive influence on correlations. Relying on these correlations, we train an efficient classifier (F1-score 0.97) to predict whether uniformly sampling a given formula will exceed a specified budget. Our results allow us to characterise the similarities and differences between (uniform) sampling, solving and counting.

- **Proceedings of the 28th ACM International Systems and Software Product Line Conference - Volume B, SPLC 2024, Dommeldange, Luxembourg, September 2-6, 2024.** Maxime Cordy, Daniel Strüber, Mónica Pinto, Iris Groher, Deepak Dhungana, Jacob Krüger, Juliana Alves Pereira, Mathieu Acher, Thomas Thüm, Maurice H. ter Beek, Jessie Galasso-Carbonnel, Paolo Arcaini, Mohammad Reza Mousavi, Xhevahire Tërnava, José A. Galindo, Tao Yue, Lidia Fuentes, and José Miguel Horcas (eds.). *Edited volume, ACM*, 2024. [DOI](https://doi.org/10.1145/3646548)

- **Proceedings of the 28th ACM International Systems and Software Product Line Conference - Volume A, SPLC 2024, Dommeldange, Luxembourg, September 2-6, 2024.** Maxime Cordy, Daniel Strüber, Mónica Pinto, Iris Groher, Deepak Dhungana, Jacob Krüger, Juliana Alves Pereira, Mathieu Acher, Thomas Thüm, Maurice H. ter Beek, Jessie Galasso-Carbonnel, Paolo Arcaini, Mohammad Reza Mousavi, Xhevahire Tërnava, José A. Galindo, Tao Yue, Lidia Fuentes, and José Miguel Horcas (eds.). *Edited volume, ACM*, 2024. [DOI](https://doi.org/10.1145/3646548)

- **Testing for Fault Diversity in Reinforcement Learning.** Quentin Mazouni, Helge Spieker, Arnaud Gotlieb, and Mathieu Acher. *Proceedings of the 5th ACM/IEEE International Conference on Automation of Software Test (AST 2024), Lisbon, Portugal, April 15-16, 2024*, 2024. **Best Paper Award.** [DOI](https://doi.org/10.1145/3644032.3644458) · [arXiv](https://arxiv.org/abs/2403.15065)
  Abstract: Reinforcement Learning is the premier technique to approach sequential decision problems, including complex tasks such as driving cars and landing spacecraft. Among the software validation and verification practices, testing for functional fault detection is a convenient way to build trustworthiness in the learned decision model. While recent works seek to maximise the number of detected faults, none consider fault characterisation during the search for more diversity. We argue that policy testing should not find as many failures as possible (e.g., inputs that trigger similar car crashes) but rather aim at revealing as informative and diverse faults as possible in the model. In this paper, we explore the use of quality diversity optimisation to solve the problem of fault diversity in policy testing. Quality diversity (QD) optimisation is a type of evolutionary algorithm to solve hard combinatorial optimisation problems where high-quality diverse solutions are sought. We define and address the underlying challenges of adapting QD optimisation to the test of action policies. Furthermore, we compare classical QD optimisers to state-of-the-art frameworks dedicated to policy testing, both in terms of search efficiency and fault diversity. We show that QD optimisation, while being conceptually simple and generally applicable, finds effectively more diverse faults in the decision model, and conclude that QD-based policy testing is a promising approach.

## 2023

- **Experience in Specializing a Generic Realization Language for SPL Engineering at Airbus.** Damien Foures, Mathieu Acher, Olivier Barais, Benoit Combemale, Jean-Marc Jézéquel, and Jörg Kienzle. *MODELS 2023 - 26th International Conference on Model-Driven Engineering Languages and Systems*, 2023. **Best Paper Award.** [PDF](https://inria.hal.science/hal-04216627/file/Experience_in_Specializing_a_Generic_Realization_Language_for_SPL_Engineering_at_Airbus%20%285%29.pdf) · [HAL](https://hal.science/hal-04216627) · [DOI](https://doi.org/10.1109/models58315.2023.00035)
  Abstract: In software product line (SPL) engineering, feature models are the de facto standard for modeling variability. A user can derive products out of a base model by selecting features of interest. Doing it automatically, however, requires a realization model, which is a description of how a base model should be modified when a given feature is selected/unselected. A realization model then necessarily depends on the base metamodel, asking for ad hoc solutions that have flourished in recent years. In this paper, we propose Greal, a generic solution to this problem in the form of (1) a generic declarative realization language that can be automatically composed with one or more base metamodels to yield a domain-specific realization language and (2) a product derivation algorithm applying a realization model to a base model and a resolved model to yield a derived product. We describe how, on top of Greal, we specialized a realization language to support both positive and negative variability, fit the syntax and semantics of the targeted language (BPMN) and take into account modeling practices at Airbus. We report on lessons learned of applying this approach on Program Development Plans based on business process models and discuss open problems.

- **On Programming Variability with Large Language Model-based Assistant.** Mathieu Acher, José Galindo Duarte, and Jean-Marc Jézéquel. *SPLC 2023 - 27th ACM International Systems and Software Product Lines Conference*, 2023. [PDF](https://inria.hal.science/hal-04153310/file/ProgrammingVariabilityGPT-SPLC23.pdf) · [HAL](https://hal.science/hal-04153310) · [DOI](https://doi.org/10.1145/3579027.3608972) · [Slides](https://www.slideshare.net/acher/on-programming-variability-with-large-language-modelbased-assistant)
  Abstract: Programming variability is central to the design and implementation of software systems that can adapt to a variety of contexts and requirements, providing increased flexibility and customization. Managing the complexity that arises from having multiple features, variations, and possible configurations is known to be highly challenging for software developers. In this paper, we explore how large language model (LLM)-based assistants can support the programming of variability. We report on new approaches made possible with LLM-based assistants, like: features and variations can be implemented as prompts; augmentation of variability out of LLM-based domain knowledge; seamless implementation of variability in different kinds of artefacts, programming languages, and frameworks, at different binding times (compile-time or run-time). We are sharing our data (prompts, sessions, generated code, etc.) to support the assessment of the effectiveness and robustness of LLMs for variability-related tasks.

- **Generative AI for Reengineering Variants into Software Product Lines: An Experience Report.** Mathieu Acher and Jabier Martinez. *SPLC 2023 - 27th ACM International Systems and Software Product Lines Conference*, 2023. [PDF](https://inria.hal.science/hal-04160693/file/FromVariants2SPLWithLLM%20%282%29.pdf) · [HAL](https://hal.science/hal-04160693) · [DOI](https://doi.org/10.1145/3579028.3609016) · [Slides](https://www.slideshare.net/acher/generative-ai-for-reengineering-variants-into-software-product-lines-an-experience-report)
  Abstract: The migration and reengineering of existing variants into a software product line (SPL) is an error-prone and time-consuming activity. Many extractive approaches have been proposed, spanning different activities from feature identification and naming to the synthesis of reusable artefacts. In this paper, we explore how large language model (LLM)-based assistants can support domain analysts and developers. We revisit four illustrative cases of the literature where the challenge is to migrate variants written in different formalism (UML class diagrams, Java, GraphML, statecharts). We systematically report on our experience with ChatGPT-4, describing our strategy to prompt LLMs and documenting positive aspects but also failures. We compare the use of LLMs with state-of-the-art approach, BUT4Reuse. While LLMs offer potential in assisting domain analysts and developers in transitioning software variants into SPLs, their intrinsic stochastic nature and restricted ability to manage large variants or complex structures necessitate a semiautomatic approach, complete with careful review, to counteract inaccuracies.

- **Reproducible Science and Software Engineering.** Mathieu Acher, Paul Temple, and Olivier Barais. *Lecture, École Jeunes Chercheurs en Programmation (EJCP 2023), Valence, France*, 2023. [PDF](https://inria.hal.science/hal-04152637v2/file/EJCP2023ReproducibleVariabilitySE-v2.pdf) · [HAL](https://hal.science/hal-04152637)
  Abstract: One of the main promises of software is that a result obtained from an experiment (e.g. a simulation) can be reproduced with a high degree of concordance. The quest for reproducibility has an impact on different scientific fields, takes different forms and requires making all the data and code available so that calculations can be run again with identical results. In this course, we will first review terminologies (e.g. reproducible vs replication vs repeatability), basic tools (e.g. versioning systems, build systems, package managers, notebooks), and techniques (e.g. automated testing, continuous integration and deployment, configuration management) related to reproducible science. We will then program a relatively simple feature in different variants and demonstrate that many factors (including programming languages, library versions, compilers, variable types, randomness management, etc.) can have an impact on the final result. Through this exercise, we aim to present and discuss software techniques, methodologies and tools that developers or scientists can use to address and mitigate reproducibility issues, hopefully leading to more robust and general results.

- **Towards Leveraging Tests to Identify Impacts of Metamodel and Code Co-evolution.** Zohra Kaouter Kebaili, Djamel Eddine Khelladi, Mathieu Acher, and Olivier Barais. *Intelligent Information Systems - CAiSE Forum 2023 (35th International Conference on Advanced Information Systems Engineering)*, 2023. [PDF](https://inria.hal.science/hal-04126496/file/Towards_Leveraging_Tests_to_Identify_Impacts_of_Metamodel_and_Code_Co_evolution_CAISE23_forum.pdf) · [HAL](https://hal.science/hal-04126496) · [DOI](https://doi.org/10.1007/978-3-031-34674-3_16)
  Abstract: Models play a significant role in Model-Driven Engineering (MDE) and metamodels are commonly transformed into code. Developers intensively rely on the generated code to build language services and tooling, such as editors and views which are also tested to ensure their behavior. The metamodel evolution between releases updates the generated code, and this may impact the developers' additional, client code. Accordingly, the impacted code must be co-evolved too, but there is no guarantee of preserving its behavior correctness. This paper envisions an automatic approach for ensuring code co-evolution correctness. It first aims to trace the tests impacted by the metamodel evolution before and after the code co-evolution, and then compares them to analyze the behavior of the code. Preliminary evaluation on two implementations of OCL and Modisco Eclipse projects. showed that we can successfully traced the impacted tests automatically by selecting 738 and 412 tests, before and after co-evolution respectively, based on 303 metamodel changes. By running these impacted tests, we observed both behaviorally correct and incorrect code co-evolution.

- **PyroBuildS: Enabling Efficient Exploration of Linux Configuration Space with Incremental Build.** Georges Aaron Randrianaina, Djamel Eddine Khelladi, Olivier Zendra, and Mathieu Acher. *Preprint, HAL*, 2023. [PDF](https://hal.science/hal-04130361/document) · [HAL](https://hal.science/hal-04130361) · [Published version](/publications/#randrianaina2026pyrobuilds)
  Abstract: Software engineers are acutely aware that the build of software is an essential but resource-intensive step in any software development process. This is especially true when building large systems or highly configurable systems whose vast number of configuration options results in a space explosion in the number of versions that should ideally be built and evaluated. Linux is precisely one such large and highly configurable system with thousands of options that can be combined. Previous study showed the benefit of incremental build, however, only on small-sized configurable software systems, unlike Linux. Although incremental compilation for post-commit is used in Linux, we show in this paper that the build of large numbers of random Linux configurations does not benefit from incremental build. Thus, we introduce and detail PyroBuildS, our new approach to efficiently explore, with incremental builds, the very large configuration space of Linux. Very much like fireworks, PyroBuildS starts from several base configurations ("rockets") and generates mutated configurations ("sparks") derived from each of the base ones. This enables exploring the configuration space with an efficient incremental build of the mutants, while keeping a good amount of diversity. We show on a total of 2520 builds that our PyroBuildS approach does trigger synergies with the caching capabilities of Make, hence significantly decreasing builds time with gains up to 85%, while having a diversity of 33% of options and 15 out of 17 subsystems. Overall, individual contributors and continuous integration services can leverage PyroBuildS to efficiently augment their configuration builds, or reduce the cost of building numerous configurations.

- **Specialization of Run-time Configuration Space at Compile-time: An Exploratory Study.** Xhevahire Tërnava, Mathieu Acher, and Benoit Combemale. *SAC 2023 - The 38th ACM/SIGAPP Symposium on Applied Computing*, 2023. [PDF](https://hal.science/hal-03916459v1/file/SAC2023-forHAL.pdf) · [HAL](https://hal.science/hal-03916459) · [DOI](https://doi.org/10.1145/3555776.3578613) · [arXiv](https://arxiv.org/abs/2210.14082)
  Abstract: Numerous software systems are highly configurable through runtime options (e.g., command-line parameters). Users can tune some of the options to meet various functional and non-functional requirements such as footprint, security, or execution time. However, some options are never set for a given system instance, and their values remain the same whatever the use cases of the system. Herein, we design a controlled experiment in which the system's run-time configuration space can be specialized at compile-time and combinations of options can be removed on demand. We perform an in-depth study of the well-known x264 video encoder and quantify the effects of its specialization to its non-functional properties, namely on binary size, attack surface, and performance while ensuring its validity. Our exploratory study suggests that the configurable specialization of a system has statistically significant benefits on most of its analysed non-functional properties, which benefits depend on the number of the debloated options. While our empirical results and insights show the importance of removing code related to unused run-time options to improve software systems, an open challenge is to further automate the specialization process.

- **A Call for Removing Variability.** Mathieu Acher, Luc Lesoil, Georges Aaron Randrianaina, Xhevahire Tërnava, and Olivier Zendra. *VaMoS 2023 - 17th International Working Conference on Variability Modelling of Software-Intensive Systems*, 2023. [PDF](https://hal.science/hal-03882594/file/CR-HAL-paper13.pdf) · [HAL](https://hal.science/hal-03882594) · [DOI](https://doi.org/10.1145/3571788.3571801)
  Abstract: Software variability is largely accepted and explored in software engineering and seems to have become a norm and a must, if only in the context of product lines. Yet, the removal of superfluous or unneeded software artefacts and functionalities is an inevitable trend. It is frequently investigated in relation to software bloat. This paper is essentially a call to the community on software variability to devise methods and tools that will facilitate the removal of unneeded variability from software systems. The advantages are expected to be numerous in terms of functional and non-functional properties, such as maintainability (lower complexity), security (smaller attack surface), reliability, and performance (smaller binaries).

- **BURST: Benchmarking Uniform Random Sampling Techniques.** Mathieu Acher, Gilles Perrouin, and Maxime Cordy. *Science of Computer Programming, 226*, 2023. [PDF](https://hal.science/hal-03897639/file/BURST_SCPJournalOSP-CR.pdf) · [HAL](https://hal.science/hal-03897639) · [DOI](https://doi.org/10.1016/j.scico.2022.102914)
  Abstract: BURST is a benchmarking platform for uniform random sampling (URS) techniques. Given: i) the description of a sampling space provided as a Boolean formula (DIMACS), and ii) a sampling budget (time and strength of uniformity), BURST evaluates ten samplers for scalability and uniformity. BURST measures scalability based on the time required to produce a sample, and uniformity based on the state-of-the-art and proven statistical test Barbarik. BURST is easily extendable to new samplers and offers: i) 128 feature models (for highly-configurable systems), ii) many other models mined from the artificial intelligence/satisfiability solving benchmarks. BURST envisions supporting URS assessment and design across multiple research communities.

- **Input Sensitivity on the Performance of Configurable Systems: An Empirical Study.** Luc Lesoil, Mathieu Acher, Arnaud Blouin, and Jean-Marc Jézéquel. *Journal of Systems and Software, 201*, 2023. [PDF](https://inria.hal.science/hal-03476464v2/file/main.pdf) · [HAL](https://hal.science/hal-03476464) · [DOI](https://doi.org/10.1016/j.jss.2023.111671)
  Abstract: Widely used software systems such as video encoders are by necessity highly configurable, with hundreds or even thousands of options to choose from. Their users often have a hard time finding suitable values for these options (i.e., finding a proper configuration of the software system) to meet their goals for the tasks at hand, e.g., compress a video down to a certain size. One dimension of the problem is of course that performance depends on the input data: e.g., a video as input to an encoder like x264 or a file fed to a tool like xz. To achieve good performance, users should therefore take into account both dimensions of (1) software variability and (2) input data. This paper details a large study over 8 configurable systems that quantifies the existing interactions between input data and configurations of software systems. The results exhibit that (1) inputs fed to software systems can interact with their configuration options in non-monotonous ways, significantly impacting their performance properties (2) input sensitivity can challenge our knowledge of software variability and question the relevance of performance predictive models for a field deployment. Given the results of our study, we call researchers to address the problem of input sensitivity when tuning, predicting, understanding, and benchmarking configurable systems.

- **A Review of Validation and Verification of Neural Network-based Policies for Sequential Decision Making.** Quentin Mazouni, Helge Spieker, Arnaud Gotlieb, and Mathieu Acher. *CoRR, abs/2312.09680*, 2023. [DOI](https://doi.org/10.48550/ARXIV.2312.09680) · [arXiv](https://arxiv.org/abs/2312.09680)
  Abstract: In sequential decision making, neural networks (NNs) are nowadays commonly used to represent and learn the agent's policy. This area of application has implied new software quality assessment challenges that traditional validation and verification practises are not able to handle. Subsequently, novel approaches have emerged to adapt those techniques to NN-based policies for sequential decision making. This survey paper aims at summarising these novel contributions and proposing future research directions. We conducted a literature review of recent research papers (from 2018 to beginning of 2023), whose topics cover aspects of the test or verification of NN-based policies. The selection has been enriched by a snowballing process from the previously selected papers, in order to relax the scope of the study and provide the reader with insight into similar verification challenges and their recent solutions. 18 papers have been finally selected. Our results show evidence of increasing interest for this subject. They highlight the diversity of both the exact problems considered and the techniques used to tackle them.

- **Handbook of Re-Engineering Software Intensive Systems into Software Product Lines.** Roberto Lopez-Herrejon, Jabier Martinez, Tewfik Ziadi, Mathieu Acher, K.G. Wesley Assunção, and Silvia Vergilio (eds.). *Springer International Publishing*, 2023. [HAL](https://hal.science/hal-03885628) · [DOI](https://doi.org/10.1007/978-3-031-11686-5) · [Thread](https://twitter.com/wesleyklewerton/status/1597174694259888128)
  Abstract: This handbook distils the wealth of expertise and knowledge from a large community of researchers and industrial practitioners in Software Product Lines (SPLs) gained through extensive and rigorous theoretical, empirical, and applied research. It is a timely compilation of well-established and cutting-edge approaches that can be leveraged by those facing the prevailing and daunting challenge of re-engineering their systems into SPLs. The selection of chapters provides readers with a wide and diverse perspective that reflects the complementary and varied expertise of the chapter authors. This perspective covers the re-engineering processes, from planning to execution. SPLs are families of systems that share common assets, allowing a disciplined software reuse. The adoption of SPL practices has shown to enable significant technical and economic benefits for the companies that employ them. However, successful SPLs rarely start from scratch, but instead, they usually start from a set of existing systems that must undergo well-defined re-engineering processes to unleash new levels of productivity and competitiveness. Practitioners will benefit from the lessons learned by the community, captured in the array of methodological and technological alternatives presented in the chapters of the handbook, and will gain the confidence for undertaking their own re-engineering challenges. Researchers and educators will find a valuable single-entry point to quickly become familiar with the state-of-the-art on the topic and the open research opportunities; including undergraduate, graduate students, and R&D engineers who want to have a comprehensive understanding of techniques in reverse engineering and re-engineering of variability-rich software systems.

- **Machine Learning for Feature Constraints Discovery.** Hugo Martin, Paul Temple, Mathieu Acher, Juliana Alves Pereira, and Jean-Marc Jézéquel. *Chapter in Handbook of Re-Engineering Software Intensive Systems into Software Product Lines, Springer International Publishing*, 2023. [HAL](https://hal.science/hal-03921905) · [DOI](https://doi.org/10.1007/978-3-031-11686-5_7)
  Abstract: Constraints among features are central to the success and quality of software product lines (SPLs). Unfortunately, the number of potential interactions and dependencies, materialized as logical constraints, grows as the number of features increases in an SPL. In particular, it is easy to forget a constraint and thus mistakenly authorizes invalid products. Developers thus struggle to identify and track constraints throughout the engineering of more and more complex SPLs. In this chapter, we show how to leverage statistical machine learning (and more specifically decision trees) to automatically prevent the derivation of invalid products through the synthesis of constraints. The key principle is to try and test some product of an SPL and then identify what individual features or combinations of features (if any) are causing their non-validity (e.g., a product does not compile). A sample of derived products is used to train a classifier (here a decision tree but other classifiers might also be used as long as constraints can be easily extracted) that can classify any remaining products of the SPL. We illustrate the chapter through different application domains and software systems (a video generator, parametric programs for 3D printing, or the Linux kernel). We also discuss the cost, benefits, and applicability of the method.

## 2022

- **Empirical Assessment of Generating Adversarial Configurations for Software Product Lines.** Paul Temple, Gilles Perrouin, Mathieu Acher, Battista Biggio, Jean-Marc Jézéquel, and Fabio Roli. *International Conference on Software Architecture (ICSA), Journal First Track*, 2022.
  Abstract: Software product line (SPL) engineers put a lot of effort to ensure that, through the setting of a large number of possible configuration options, products are acceptable and well-tailored to customers' needs. Unfortunately, options and their mutual interactions create a huge configuration space which is intractable to exhaustively explore. Instead of testing all products, machine learning is increasingly employed to approximate the set of acceptable products out of a small training sample of configurations. Machine learning (ML) techniques can refine a software product line through learned constraints and a priori prevent non-acceptable products to be derived. In this paper, we use adversarial ML techniques to generate adver-sarial configurations fooling ML classifiers and pinpoint incorrect classifications of products (videos) derived from an industrial video generator. Our attacks yield (up to) a 100% misclassification rate and a drop in accuracy of 5%. We discuss the implications these results have on SPL quality assurance.

- **Feature Subset Selection for Learning Huge Configuration Spaces: The case of Linux Kernel Size.** Mathieu Acher, Hugo Martin, Juliana Alves Pereira, Luc Lesoil, Arnaud Blouin, Jean-Marc Jézéquel, Djamel Eddine Khelladi, and Olivier Barais. *SPLC 2022 - 26th ACM International Systems and Software Product Line Conference*, 2022. [PDF](https://hal.science/hal-03720273/file/SPLC_2022___Linux_Kernel_Size.pdf) · [HAL](https://hal.science/hal-03720273) · [DOI](https://doi.org/10.1145/3546932.3546997) · [Slides](https://www.slideshare.net/acher/feature-subset-selection-for-learning-huge-configuration-spaces-the-case-of-linux-kernel-size)
  Abstract: Linux kernels are used in a wide variety of appliances, many of them having strong requirements on the kernel size due to constraints such as limited memory or instant boot. With more than nine thousands of configuration options to choose from, developers and users of Linux actually spend significant effort to document, understand, and eventually tune (combinations of) options for meeting a kernel size. In this paper, we describe a large-scale endeavour automating this task and predicting a given Linux kernel binary size out of unmeasured configurations. We first experiment that state-of-theart solutions specifically made for configurable systems such as performance-influence models cannot cope with that number of options, suggesting that software product line techniques may need to be adapted to such huge configuration spaces. We then show that tree-based feature selection can learn a model achieving low prediction errors over a reduced set of options. The resulting model, trained on 95 854 kernel configurations, is fast to compute, simple to interpret and even outperforms the accuracy of learning without feature selection.

- **From feature models to feature toggles in practice.** Jean-Marc Jézéquel, Jörg Kienzle, and Mathieu Acher. *SPLC 2022 - 26th ACM International Systems and Software Product Line Conference*, 2022. [PDF](https://hal.science/hal-03788437/file/Unifying_SPL_and_Feature_Flags%282%29.pdf) · [HAL](https://hal.science/hal-03788437) · [DOI](https://doi.org/10.1145/3546932.3547009)
  Abstract: Feature Toggles (often also referred to as Feature Flags) are a powerful technique, providing an alternative to maintaining multiple feature branches in source code. A condition within the code enables or disables a feature at runtime, hence providing a kind of runtime variability resolution. Several works have already identified the proximity of this concept with the notion of Feature found in Software Product Lines. In this paper, we propose to go one step further in unifying these concepts to provide a seamless transition between design time and runtime variability resolutions. We propose to model all the variability using a feature model. Then this feature model can be partially resolved at design time (yielding an incomplete product derivation), the unresolved variability being used to generate feature toggles that can be enabled/disabled at runtime. We first demonstrate these ideas on the toy example of the Expression Product Line, and then show how it can scale to build a configurable authentication system, where a partially resolved feature model can interface with popular feature toggle frameworks such as Togglz.

- **Scratching the Surface of ./configure: Learning the Effects of Compile-Time Options on Binary Size and Gadgets.** Xhevahire Tërnava, Mathieu Acher, Luc Lesoil, Arnaud Blouin, and Jean-Marc Jézéquel. *ICSR 2022 - 20th International Conference on Software and Systems Reuse*, 2022. **Best Paper Award.** [PDF](https://hal.science/hal-03627246/file/paper32-ICSR2022_v03.pdf) · [HAL](https://hal.science/hal-03627246) · [DOI](https://doi.org/10.1007/978-3-031-08129-3_3)
  Abstract: Numerous software systems are configurable through compile-time options and the widely used ./configure. However, the combined effects of these options on binary's non-functional properties (size and attack surface) are often not documented, and or not well understood, even by experts. Our goal is to provide automated support for exploring and comprehending the configuration space (a.k.a., surface) of compile-time options using statistical learning techniques. In this paper, we perform an empirical study on four C-based configurable systems. We measure the variation of binary size and attack surface (by quantifying the number of code reuse gadgets) in over 400 compile-time configurations of a subject system. We then apply statistical learning techniques on top of our build infrastructure to identify how compile-time options relate to non-functional properties. Our results show that, by changing the default configuration, the system's binary size and gadgets vary greatly (roughly −79% to 244% and −77% to 30%, respectively). Then, we found out that identifying the most influential options can be accurately learned with a small training set, while their relative importance varies across size and attack surface for the same system. Practitioners can use our approach and artifacts to explore the effects of compile-time options in order to take informed decisions when configuring a system with ./configure.

- **On the Benefits and Limits of Incremental Build of Software Configurations: An Exploratory Study.** Georges Aaron Randrianaina, Xhevahire Tërnava, Djamel Eddine Khelladi, and Mathieu Acher. *ICSE 2022 - 44th International Conference on Software Engineering*, 2022. [PDF](https://hal.science/hal-03547219v2/file/ICSE22_Incremental_Build_HAL.pdf) · [HAL](https://hal.science/hal-03547219) · [DOI](https://doi.org/10.1145/3510003.3510190)
  Abstract: Software projects use build systems to automate the compilation, testing, and continuous deployment of their software products. As software becomes increasingly configurable, the build of multiple configurations is a pressing need, but expensive and challenging to implement. The current state of practice is to build independently (aka clean build) a software for a subset of configurations. While incremental build has been studied for software evolution and relatively small changes of the source code, it has surprisingly not been considered for software configurations. In this exploratory study, we examine the benefits and limits of building software configurations incrementally, rather than always building them cleanly. By using five real-life configurable systems as subjects, we explore whether incremental build works, outperforms a sequence of clean builds, is correct wrt clean build, and can be used to find an optimal ordering for building configurations. Our results show that incremental build is feasible in 100% of the times in four subjects and in 78% of the times in one subject. In average, 88.5% of the configurations could be built faster with incremental build while also finding several alternatives faster incremental builds. However, only 60% of faster incremental builds are correct. Still, when considering those correct incremental builds with clean builds, we could always find an optimal order that is faster than just a collection of clean builds with a gain up to 11.76%.

- **Towards Incremental Build of Software Configurations.** Georges Aaron Randrianaina, Djamel Eddine Khelladi, Olivier Zendra, and Mathieu Acher. *ICSE-NIER 2022 - 44th International Conference on Software Engineering – New Ideas and Emerging Results*, 2022. [PDF](https://hal.science/hal-03558479/file/ICSE22_NIER_HAL.pdf) · [HAL](https://hal.science/hal-03558479) · [DOI](https://doi.org/10.1145/3510455.3512792)
  Abstract: Building software is a crucial task to compile, test, and deploy software systems while continuously ensuring quality. As software is more and more configurable, building multiple configurations is a pressing need, yet, costly and challenging to instrument. The common practice is to independently build (a.k.a., clean build) a software for a subset of configurations. While incremental build has been considered for software evolution and relatively small modifications of the source code, it has surprisingly not been considered for software configurations. In this vision paper, we formulate the hypothesis that incremental build can reduce the cost of exploring the configuration space of software systems. We detail how we apply incremental build for two real-world application scenarios and conduct a preliminary evaluation on two case studies, namely x264 and Linux Kernel. For x264, we found that one can incrementally build configurations in an order such that overall build time is reduced. Nevertheless, we could not find any optimal order with the Linux Kernel, due to a high distance between random configurations. Therefore, we show it is possible to control the process of generating configurations: we could reuse commonality and gain up to 66% of build time compared to only clean builds.

- **Beware of the Interactions of Variability Layers When Reasoning about Evolution of MongoDB.** Luc Lesoil, Mathieu Acher, Arnaud Blouin, and Jean-Marc Jézéquel. *ICPE 2022 - 13th ACM/SPEC International Conference on Performance Engineering*, 2022. [PDF](https://hal.science/hal-03624309/file/ICPE_2022___Data_challenge.pdf) · [HAL](https://hal.science/hal-03624309) · [DOI](https://doi.org/10.1145/3491204.3527489)
  Abstract: With commits and releases, hundreds of tests are run on varying conditions (e.g., over different hardware and workloads) that can help to understand evolution and ensure non-regression of software performance. We hypothesize that performance is not only sensitive to evolution of software, but also to different variability layers of its execution environment, spanning the hardware, the operating system, the build, or the workload processed by the software. Leveraging the MongoDB dataset, our results show that changes in hardware and workload can drastically impact performance evolution and thus should be taken into account when reasoning about evolution. An open problem resulting from this study is how to manage the variability layers in order to efficiently test the performance evolution of a software.

- **Reproducible Science and Deep Software Variability.** Mathieu Acher. *VaMoS 2022 - 16th International Working Conference on Variability Modelling of Software-Intensive Systems*, 2022. [PDF](https://hal.science/hal-03528889/file/KeynoteVaMoSReproducibleScienceDeepVariability.pdf) · [HAL](https://hal.science/hal-03528889) · [DOI](https://doi.org/10.1145/3510466.3510481)
  Abstract: Biology, medicine, physics, astrophysics, chemistry: all these scientific domains need to process large amount of data with more and more complex software systems. For achieving reproducible science, there are several challenges ahead involving multidisciplinary collaboration and socio-technical innovation with software at the center of the problem. Despite the availability of data and code, several studies report that the same data analyzed with different software can lead to different results. I am seeing this problem as a manifestation of deep software variability: many factors (operating system, third-party libraries, versions, workloads, compile-time options and flags, etc.) themselves subject to variability can alter the results, up to the point it can dramatically change the conclusions of some scientific studies. In this keynote, I argue that deep software variability is a threat and also an opportunity for reproducible science. I first outline some works about (deep) software variability, reporting on preliminary evidence of complex interactions between variability layers. I then link the ongoing works on variability modelling and deep software variability in the quest for reproducible science.

- **Transferring Performance between Distinct Configurable Systems : A Case Study.** Luc Lesoil, Hugo Martin, Mathieu Acher, Arnaud Blouin, and Jean-Marc Jézéquel. *VaMoS 2022 - 16th International Working Conference on Variability Modelling of Software-Intensive Systems*, 2022. [PDF](https://hal.science/hal-03514984/file/VaMoS_22_tracsoft.pdf) · [HAL](https://hal.science/hal-03514984) · [DOI](https://doi.org/10.1145/3510466.3510486)
  Abstract: Many research studies predict the performance of configurable software using machine learning techniques, thus requiring large amounts of data. Transfer learning aims to reduce the amount of data needed to train these models and has been successfully applied on different executing environments (hardware) or software versions. In this paper we investigate for the first time the idea of applying transfer learning between distinct configurable systems. We design a study involving two video encoders (namely x264 and x265) coming from different code bases. Our results are encouraging since transfer learning outperforms traditional learning for two performance properties (out of three). We discuss the open challenges to overcome for a more general application.

- **On the Interaction of Feature Toggles.** Xhevahire Tërnava, Luc Lesoil, Georges Aaron Randrianaina, Djamel Eddine Khelladi, and Mathieu Acher. *VaMoS 2022 - 16th International Working Conference on Variability Modelling of Software-Intensive Systems*, 2022. [PDF](https://hal.science/hal-03527250v2/file/VaMoS22-paper8-HAL.pdf) · [HAL](https://hal.science/hal-03527250) · [DOI](https://doi.org/10.1145/3510466.3510485)
  Abstract: Feature toggling is a technique for enabling branching-in-code. It is increasingly used during continuous deployment to incrementally test and integrate new features before their release. In principle, feature toggles tend to be light, that is, they are defined as simple Boolean flags and used in conditional statements to condition the activation of some software features. However, there is a lack of knowledge on whether and how they may interact with each other, in that case their enabling and testing become complex. We argue that finding the interactions of feature toggles is valuable for developers to know which of them should be enabled at the same time, which are impacted by a removed toggle, and to avoid their mis-configurations. In this work, we mine feature toggles and their interactions in five open-source projects. We then analyse how they are realized and whether they tend to be multiplied over time. Our results show that 7% of feature toggles interact with each other, 33% of them interact with another code expression, and their interactions tend to increase over time (22%, on average). Further, their interactions are expressed by simple logical operators (i.e., and and or) and nested if statements. We propose to model them into a Feature Toggle Model, and believe that our results are helpful towards robust management approaches of feature toggles.

- **Specialization of Run-time Configuration Space at Compile-time: An Exploratory Study.** Xhevahire Tërnava, Mathieu Acher, and Benoît Combemale. *CoRR, abs/2210.14082*, 2022. [DOI](https://doi.org/10.48550/arXiv.2210.14082) · [arXiv](https://arxiv.org/abs/2210.14082) · [Published version](/publications/#ternava:hal-03916459)
  Abstract: Numerous software systems are highly configurable through run-time options, such as command-line parameters. Users can tune some of the options to meet various functional and non-functional requirements such as footprint, security, or execution time. However, some options are never set for a given system instance, and their values remain the same whatever the use cases of the system. Herein, we design a controlled experiment in which the system's run-time configuration space can be specialized at compile-time and combinations of options can be removed on demand. We perform an in-depth study of the well-known x264 video encoder and quantify the effects of its specialization to its non-functional properties, namely on binary size, attack surface, and performance while ensuring its validity. Our exploratory study suggests that the configurable specialization of a system has statistically significant benefits on most of its analysed non-functional properties, which benefits depend on the number of the debloated options. While our empirical results and insights show the importance of removing code related to unused run-time options to improve software systems, an open challenge is to further automate the specialization process.

- **Piloting Copilot and Codex: Hot Temperature, Cold Prompts, or Black Magic?.** Jean-Baptiste Döderlein, Mathieu Acher, Djamel Eddine Khelladi, and Benoît Combemale. *CoRR, abs/2210.14699*, 2022. [DOI](https://doi.org/10.48550/arXiv.2210.14699) · [arXiv](https://arxiv.org/abs/2210.14699) · [Published version](/publications/#doderlein2025piloting)
  Abstract: Language models are promising solutions for tackling increasing complex problems. In software engineering, they recently attracted attention in code assistants, with programs automatically written in a given programming language from a programming task description in natural language. They have the potential to save time and effort when writing code. However, these systems are currently poorly understood, preventing them from being used optimally. In this paper, we investigate the various input parameters of two language models, and conduct a study to understand if variations of these input parameters (e.g. programming task description and the surrounding context, creativity of the language model, number of generated solutions) can have a significant impact on the quality of the generated programs. We design specific operators for varying input parameters and apply them over two code assistants (Copilot and Codex) and two benchmarks representing algorithmic problems (HumanEval and LeetCode). Our results showed that varying the input parameters can significantly improve the performance of language models. However, there is a tight dependency when varying the temperature, the prompt and the number of generated solutions, making potentially hard for developers to properly control the parameters to obtain an optimal result. This work opens opportunities to propose (automated) strategies for improving performance.

- **Transfer Learning Across Variants and Versions: The Case of Linux Kernel Size.** Hugo Martin, Mathieu Acher, Juliana Alves Pereira, Luc Lesoil, Jean-Marc Jézéquel, and Djamel Eddine Khelladi. *IEEE Transactions on Software Engineering, 48(11)*, 2022. [PDF](https://hal.science/hal-03358817/file/TransferLinux__hal.pdf) · [HAL](https://hal.science/hal-03358817) · [DOI](https://doi.org/10.1109/tse.2021.3116768) · [Thread](https://twitter.com/acherm/status/1446399342236078080)
  Abstract: With large scale and complex configurable systems, it is hard for users to choose the right combination of options (i.e., configurations) in order to obtain the wanted trade-off between functionality and performance goals such as speed or size. Machine learning can help in relating these goals to the configurable system options, and thus, predict the effect of options on the outcome, typically after a costly training step. However, many configurable systems evolve at such a rapid pace that it is impractical to retrain a new model from scratch for each new version. In this paper, we propose a new method to enable transfer learning of binary size predictions among versions of the same configurable system. Taking the extreme case of the Linux kernel with its ≈ 14, 500 configuration options, we first investigate how binary size predictions of kernel size degrade over successive versions. We show that the direct reuse of an accurate prediction model from 2017 quickly becomes inaccurate when Linux evolves, up to a 32% mean error by August 2020. We thus propose a new approach for transfer evolution-aware model shifting (TEAMS). It leverages the structure of a configurable system to transfer an initial predictive model towards its future versions with a minimal amount of extra processing for each version. We show that TEAMS vastly outperforms state of the art approaches over the 3 years history of Linux kernels, from 4.13 to 5.8.

## 2021

- **Modelling, Reverse Engineering, and Learning Software Variability.** Mathieu Acher. *Habilitation à diriger des recherches, Université de Rennes 1*, 2021. [PDF](https://hal.science/tel-03521806/file/HDRAcherVariability.pdf) · [HAL](https://hal.science/tel-03521806)
  Abstract: The society expects software to deliver the right functionality, in a short amount of time and with fewer resources, in every possible circumstance whatever are the hardware, the operating systems, the compilers, or the data fed as input. For fitting such a diversity of needs, it is common that software comes in many variants and is highly configurable through configuration options, runtime parameters, conditional compilation directives, menu preferences, configuration files, plugins, etc. As there is no one-size-fits-all solution, software variability ("the ability of a software system or artifact to be efficiently extended, changed, customized or configured for use in a particular context") has been studied the last two decades and is a discipline of its own. Though highly desirable, software variability also introduces an enormous complexity due to the combinatorial explosion of possible variants. For example, the Linux kernel has 15000+ options and most of them can have 3 values: "yes", "no", or "module". Variability is challenging for maintaining, verifying, and configuring software systems (Web applications, Web browsers, video tools, etc.). It is also a source of opportunities to better understand a domain, create reusable artefacts, deploy performance-wise optimal systems, or find specialized solutions to many kinds of problems. In many scenarios, a model of variability is either beneficial or mandatory to explore, observe, and reason about the space of possible variants. For instance, without a variability model, it is impossible to establish a sampling strategy that would satisfy the constraints among options and meet coverage or testing criteria. I address a central question in this HDR manuscript: How to model software variability? I detail several contributions related to modelling, reverse engineering, and learning software variability. I first contribute to support the persons in charge of manually specifying feature models, the de facto standard for modeling variability. I develop an algebra together with a language for supporting the composition, decomposition, diff, refactoring, and reasoning of feature models. I further establish the syntactic and semantic relationships between feature models and product comparison matrices, a large class of tabular data. I then empirically investigate how these feature models can be used to test in the large configurable systems with different sampling strategies. Along this effort, I report on the attempts and lessons learned when defining the "right" variability language. From a reverse engineering perspective, I contribute to synthesize variability information into models and from various kinds of artefacts. I develop foundations and methods for reverse engineering feature models from satisfiability formulae, product comparison matrices, dependencies files and architectural information, and from Web configurators. I also report on the degree of automation and show that the involvement of developers and domain experts is beneficial to obtain high-quality models. Thirdly, I contribute to learning constraints and non-functional properties (performance) of a variability-intensive system. I describe a systematic process "sampling, measuring, learning" that aims to enforce or augment a variability model, capturing variability knowledge that domain experts can hardly express. I show that supervised, statistical machine learning can be used to synthesize rules or build prediction models in an accurate and interpretable way. This process can even be applied to huge configuration space, such as the Linux kernel one. Despite a wide applicability and observed benefits, I show that each individual line of contributions has limitations. I defend the following answer: a supervised, iterative process (1) based on the combination of reverse engineering, modelling, and learning techniques; (2) capable of integrating multiple variability information (eg expert knowledge, legacy artefacts, dynamic observations). Finally, this work opens different perspectives related to so-called deep software variability, security, smart build of configurations, and (threats to) science.

- **The Interplay of Compile-time and Run-time Options for Performance Prediction.** Luc Lesoil, Mathieu Acher, Xhevahire Tërnava, Arnaud Blouin, and Jean-Marc Jézéquel. *SPLC 2021 - 25th ACM International Systems and Software Product Line Conference - Volume A*, 2021. [PDF](https://hal.science/hal-03286127/file/Interplay_compile_runtime.pdf) · [HAL](https://hal.science/hal-03286127) · [DOI](https://doi.org/10.1145/3461001.3471149) · [Video](https://www.youtube.com/watch?v=kVh4VwQUzv8) · [Thread](https://twitter.com/acherm/status/1435965581904146439)
  Abstract: Many software projects are configurable through compile-time options (e.g., using ./configure) and also through run-time options (e.g., command-line parameters, fed to the software at execution time). Several works have shown how to predict the effect of run-time options on performance. However it is yet to be studied how these prediction models behave when the software is built with different compile-time options. For instance, is the best run-time configuration always the best w.r.t. the chosen compilation options? In this paper, we investigate the effect of compile-time options on the performance distributions of 4 software systems. There are cases where the compiler layer effect is linear which is an opportunity to generalize performance models or to tune and measure runtime performance at lower cost. We also prove there can exist an interplay by exhibiting a case where compile-time options significantly alter the performance distributions of a configurable system.

- **A comparison of performance specialization learning for configurable systems.** Hugo Martin, Mathieu Acher, Juliana Alves Pereira, and Jean-Marc Jézéquel. *SPLC 2021 - 25th ACM International Systems and Software Product Line Conference*, 2021. **Best Paper Award.** [PDF](https://hal.science/hal-03335263/file/PerformanceSpecialization.pdf) · [HAL](https://hal.science/hal-03335263) · [DOI](https://doi.org/10.1145/3461001.3471155) · [Video](https://www.youtube.com/watch?v=DC6GeqISf6E) · [Thread](https://twitter.com/acherm/status/1435611528154189828)
  Abstract: The specialization of the configuration space of a software system has been considered for targeting specific configuration profiles, usages, deployment scenarios, or hardware settings. The challenge is to find constraints among options' values that only retain configurations meeting a performance objective. Since the exponential nature of configurable systems makes a manual specialization unpractical, several approaches have considered its automation using machine learning, i.e., measuring a sample of configurations and then learning what options' values should be constrained. Even focusing on learning techniques based on decision trees for their built-in explainability, there is still a wide range of possible approaches that need to be evaluated, i.e., how accurate is the specialization with regards to sampling size, performance thresholds, and kinds of configurable systems. In this paper, we compare six learning techniques: three variants of decision trees (including a novel algorithm) with and without the use of model-based feature selection. We first perform a study on 8 configurable systems considered in previous related works and show that the accuracy reaches more than 90% and that feature selection can improve the results in the majority of cases. We then perform a study on the Linux kernel and show that these techniques performs as well as on the other systems. Overall, our results show that there is no one-size-fits-all learning variant (though high accuracy can be achieved): we present guidelines and discuss tradeoffs.

- **Fourth International Workshop on Languages for Modelling Variability (MODEVAR@SPLC 2021).** Thomas Thüm, Philippe Collet, and Mathieu Acher. *SPLC '21: 25th ACM International Systems and Software Product Line Conference, Leicester, United Kingdom, September 6-11, 2021, Volume A*, 2021. [DOI](https://doi.org/10.1145/3461001.3473056)
  Abstract: Feature models were invented in 1990 and have been recognised as one of the main contributions to the Software Product Line community. Although there have been several attempts to establish and study a sort of standard variability modelling language, there is still no consensus on a simple feature modelling language. There can be many motivations to have one but among others, there is one that is very important: information sharing among researchers, tools or developers. Following the spirit of the first three editions, this workshop is an interactive event where all participants shall share knowledge, but also ongoing realizations about how to build up a simple feature modelling language that all the community can agree on.

- **Learning Software Configuration Spaces: A Systematic Literature Review.** Juliana Alves Pereira, Hugo Martin, Mathieu Acher, Jean-Marc Jézéquel, Goetz Botterweck, and Anthony Ventresque. *Journal of Systems and Software, 182*, 2021. [PDF](https://hal.science/hal-02148791v2/file/Survey_MachineLearningConfiguration_RevisedJSS.pdf) · [HAL](https://hal.science/hal-02148791) · [DOI](https://doi.org/10.1016/j.jss.2021.111044) · [arXiv](https://arxiv.org/abs/1906.03018) · [Thread](https://twitter.com/acherm/status/1445731364888666117)
  Abstract: Most modern software systems (operating systems like Linux or Android, Web browsers like Firefox or Chrome, video encoders like ffmpeg, x264 or VLC, mobile and cloud applications, etc.) are highly configurable. Hundreds of configuration options, features, or plugins can be combined, each potentially with distinct functionality and effects on execution time, security, energy consumption, etc. Due to the combinatorial explosion and the cost of executing software, it is quickly impossible to exhaustively explore the whole configuration space. Hence, numerous works have investigated the idea of learning it from a small sample of configurations' measurements. The pattern “sampling, measuring, learning" has emerged in the literature, with several practical interests for both software developers and end-users of configurable systems. In this systematic literature review, we report on the different application objectives (e.g., performance prediction, configuration optimization, constraint mining), use-cases, targeted software systems, and application domains. We review the various strategies employed to gather a representative and cost-effective sample. We describe automated software techniques used to measure functional and non-functional properties of configurations. We classify machine learning algorithms and how they relate to the pursued application. Finally, we also describe how researchers evaluate the quality of the learning process. The findings from this systematic review show that the potential application objective is important; there are a vast number of case studies reported in the literature related to particular domains or software systems. Yet, the huge variant space of configurable systems is still challenging and calls to further investigate the synergies between artificial intelligence and software engineering.

- **Empirical Assessment of Multimorphic Testing.** Paul Temple, Mathieu Acher, and Jean-Marc Jézéquel. *IEEE Transactions on Software Engineering (TSE), 47(7)*, 2021. [PDF](https://hal.science/hal-02177158/file/Leveraging_performance_variations_with_Multimorphic_Testing-TempleAcherJezequel-TSE.pdf) · [HAL](https://hal.science/hal-02177158) · [DOI](https://doi.org/10.1109/TSE.2019.2926971)
  Abstract: The performance of software systems (such as speed, memory usage, correct identification rate) tends to be an evermore important concern, often nowadays on par with functional correctness for critical systems.Systematically testing these performance concerns is however extremely difficult, in particular because there exists no theory underpinning the evaluation of a performance test suite, i.e., to tell the software developer whether such a test suite is "good enough" or even whether a test suite is better than another one. This paper proposes to apply Multimorphic testing and empirically assess the effectiveness of performance test suites of software systems coming from various domains. By analogy with mutation testing, our core idea is to leverage the typical configurability of these systems, and to check whether it makes any difference in the outcome of the tests: i.e., are some tests able to "kill" underperforming system configurations? More precisely, we propose a framework for defining and evaluating the coverage of a test suite with respect to a quantitative property of interest. Such properties can be the execution time, the memory usage or the success rate in tasks performed by a software system. This framework can be used to assess whether a new test case is worth adding to a test suite or to select an optimal test suite with respect to a property of interest. We evaluate several aspects of our proposal through 3 empirical studies carried out in different fields: object tracking in videos, object recognition in images, and code generators.

- **Deep Software Variability: Towards Handling Cross-Layer Configuration.** Luc Lesoil, Mathieu Acher, Arnaud Blouin, and Jean-Marc Jézéquel. *VaMoS 2021 - 15th International Working Conference on Variability Modelling of Software-Intensive Systems*, 2021. [PDF](https://hal.science/hal-03084276v2/file/vision_paper_deep_software_variability.pdf) · [HAL](https://hal.science/hal-03084276) · [DOI](https://doi.org/10.1145/3442391.3442402) · [Thread](https://twitter.com/lesoil_l/status/1489062896977989635)
  Abstract: Configuring software is a powerful means to reach functional and performance goals of a system. However, many layers (hardware, operating system, input data, etc.), themselves subject to variability, can alter performances of software configurations. For instance, configurations' options of the x264 video encoder may have very different effects on x264's encoding time when used with different input videos, depending on the hardware on which it is executed. In this vision paper, we coin the term deep software variability to refer to the interaction of all external layers modifying the behavior or non-functional properties of a software. Deep software variability challenges practitioners and researchers: the combinatorial explosion of possible executing environments complicates the understanding, the configuration, the maintenance, the debug, and the test of configurable systems. There are also opportunities: harnessing all variability layers (and not only the software layer) can lead to more efficient systems and configuration knowledge that truly generalizes to any usage and context.

- **The Interaction between Inputs and Configurations fed to Software Systems: an Empirical Study.** Luc Lesoil, Mathieu Acher, Arnaud Blouin, and Jean-Marc Jézéquel. *CoRR, abs/2112.07279*, 2021. [DOI](https://doi.org/10.48550/arXiv.2112.07279) · [arXiv](https://arxiv.org/abs/2112.07279) · [Thread](https://twitter.com/lesoil_l/status/1491599457074528257) · [Published version](/publications/#lesoil:hal-03476464)
  Abstract: Widely used software systems such as video encoders are by necessity highly configurable, with hundreds or even thousands of options to choose from. Their users often have a hard time finding suitable values for these options (i.e. finding a proper configuration of the software system) to meet their goals for the tasks at hand, e.g. compress a video down to a certain size. One dimension of the problem is of course that performance depends on the input data: a video as input to an encoder like x264 or a file system fed to a tool like xz. To achieve good performance, users should therefore take into account both dimensions of (1) software variability and (2) input data. In this problem-statement paper, we conduct a large study over 8 configurable systems that quantifies the existing interactions between input data and configurations of software systems. The results exhibit that (1) inputs fed to software systems interact with their configuration options in non monotonous ways, significantly impacting their performance properties (2) tuning a software system for its input data makes it possible to multiply its performance by up to ten (3) input variability can jeopardize the relevance of performance predictive models for a field deployment.

- **BURST: A Benchmarking Platform for Uniform Random Sampling Techniques.** Mathieu Acher, Gilles Perrouin, and Maxime Cordy. *Proceedings of the 25th ACM International Systems and Software Product Line Conference - Volume B*, 2021. [DOI](https://doi.org/10.1145/3461002.3473070) · [Video](https://www.youtube.com/watch?v=sSKosyrfitA) · [Thread](https://twitter.com/acherm/status/1436360161061392385)
  Abstract: We present BURST, a benchmarking platform for uniform random sampling techniques. With BURST, researchers have a flexible, controlled environment in which they can evaluate the scalability and uniformity of their sampling. BURST comes with an extensive — and extensible — benchmark dataset comprising 128 feature models, including challenging, real-world models of the Linux kernel. BURST takes as inputs a sampling tool, a set of feature models and a sampling budget. It automatically translates any feature model of the set in DIMACS and invokes the sampling tool to generate the budgeted number of samples. To evaluate the scalability of the sampling tool, BURST measures the time the tool needs to produce the requested sample. To evaluate the uniformity of the produced sample, BURST integrates the state-of-the-art and proven statistical test Barbarik. We envision BURST to become the starting point of a standardisation initiative of sampling tool evaluation. Given the huge interest of research for sampling algorithms and tools, this initiative would have the potential to reach and crosscut multiple research communities including AI, ML, SAT and SPL.

## 2020

- **Empirical Assessment of Generating Adversarial Configurations for Software Product Lines.** Paul Temple, Gilles Perrouin, Mathieu Acher, Battista Biggio, Jean-Marc Jézéquel, and Fabio Roli. *Empirical Software Engineering (ESE), 26(1)*, 2020. [PDF](https://inria.hal.science/hal-03045797v1/file/Extension_SPLC2019_AdversConfig_EMSE.pdf) · [HAL](https://hal.science/hal-03045797) · [DOI](https://doi.org/10.1007/s10664-020-09915-7)
  Abstract: Software product line (SPL) engineers put a lot of effort to ensure that, through the setting of a large number of possible configuration options, products are acceptable and well-tailored to customers' needs. Unfortunately, options and their mutual interactions create a huge configuration space which is intractable to exhaustively explore. Instead of testing all products, machine learning is increasingly employed to approximate the set of acceptable products out of a small training sample of configurations. Machine learning (ML) techniques can refine a software product line through learned constraints and a priori prevent non-acceptable products to be derived. In this paper, we use adversarial ML techniques to generate adver-sarial configurations fooling ML classifiers and pinpoint incorrect classifications of products (videos) derived from an industrial video generator. Our attacks yield (up to) a 100% misclassification rate and a drop in accuracy of 5%. We discuss the implications these results have on SPL quality assurance.

- **Third International Workshop on Languages for Modelling Variability (MODEVAR@SPLC 2020).** Mathieu Acher, Philippe Collet, David Benavides, and Rick Rabiser. *SPLC '20: 24th ACM International Systems and Software Product Line Conference, Montreal, Quebec, Canada, October 19-23, 2020, Volume A*, 2020. [DOI](https://doi.org/10.1145/3382025.3414948)
  Abstract: Feature models were invented in 1990 and have been recognised as one of the main contributions to the Software Product Line community. Although there have been several attempts to establish a sort of standard variability modelling language, there is still no consensus on a simple feature modelling language. There can be many motivations to have one but among others, there is one that is very important: information sharing among researchers, tools or developers. Following the spirit of the first two editions, this workshop is an interactive event where all participants shall share knowledge, but also first realizations about how to build up a simple feature modelling language that all the community can agree on.

- **REVE 2020: 8th International Workshop on Reverse Variability Engineering.** Wesley K. G. Assunção, Mathieu Acher, Tewfik Ziadi, and Jabier Martinez. *SPLC '20: 24th ACM International Systems and Software Product Line Conference, Montreal, Quebec, Canada, October 19-23, 2020, Volume A*, 2020. [HAL](https://hal.science/hal-02978997) · [DOI](https://doi.org/10.1145/3382025.3414947)
  Abstract: Software Product Line (SPL) migration remains a challenging endeavour. From organizational issues to purely technical challenges, there is a wide range of barriers that complicates SPL adoption. This workshop aims to foster research about making the most of the two main inputs for SPL migration: 1) domain knowledge and 2) legacy assets. Domain knowledge, usually implicit and spread across an organization, is key to define the SPL scope and to validate the variability model and its semantics. At the technical level, domain expertise is also needed to create or extract the reusable software components. Legacy assets can be, for instance, similar product variants (e.g., requirements, models, source code, etc.) that were implemented using ad-hoc reuse techniques such as clone-and-own. More generally, the workshop REverse Variability Engineering attracts researchers and practitioners contributing to processes, techniques, tools, or empirical studies related to the automatic, semi-automatic or manual extraction or refinement of SPL assets.

- **Test them all, is it worth it?: assessing configuration sampling on the JHipster web development stack.** Axel Halin, Alexandre Nuttinck, Mathieu Acher, Xavier Devroey, Gilles Perrouin, and Benoit Baudry. *SPLC '20: 24th ACM International Systems and Software Product Line Conference, Montreal, Quebec, Canada, October 19-23, 2020, Volume A*, 2020. [DOI](https://doi.org/10.1145/3382025.3414985)
  Abstract: This is an extended abstract of the article: Axel Halin, Alexandre Nuttinck, Mathieu Acher, Xavier Devroey, Gilles Perrouin, and Benoit Baudry. 2018. Test them all, is it worth it? Assessing configuration sampling on the JHipster Web development stack. In Empirical Software Engineering (17 Jul 2018). https://doi.org/10.1007/s10664-018-9635-4.

- **VaMoS '20: 14th International Working Conference on Variability Modelling of Software-Intensive Systems, Magdeburg Germany, February 5-7, 2020.** Maxime Cordy, Mathieu Acher, Danilo Beuche, and Gunter Saake (eds.). *Edited volume, ACM*, 2020. [DOI](https://doi.org/10.1145/3377024)

- **Co-evolving code with evolving metamodels.** Djamel Eddine Khelladi, Benoit Combemale, Mathieu Acher, Olivier Barais, and Jean-Marc Jézéquel. *ICSE '20: 42nd International Conference on Software Engineering, Seoul, South Korea, 27 June - 19 July, 2020*, 2020. [PDF](https://inria.hal.science/hal-03029429v1/file/temp_icse.pdf) · [HAL](https://hal.science/hal-03029429) · [DOI](https://doi.org/10.1145/3377811.3380324) · [Video](https://www.youtube.com/watch?v=zqiG-tEDJKk)
  Abstract: Metamodels play a significant role to describe and analyze the relations between domain concepts. They are also cornerstone to build a software language (SL) for a domain and its associated tooling. Metamodel definition generally drives code generation of a core API. The latter is further enriched by developers with additional code implementing advanced functionalities, e.g., checkers, recommenders, etc. When a SL is evolved to the next version, the metamodels are evolved as well before to regenerate the core API code. As a result, the developers added code both in the core API and the SL toolings may be impacted and thus may need to be co-evolved accordingly. Many approaches support the co-evolution of various artifacts when metamodels evolve. However, not the co-evolution of code. This paper fills this gap. We propose a semi-automatic co-evolution approach based on change propagation. The premise is that knowledge of the metamodel evolution changes can be propagated by means of resolutions to drive the code co-evolution. Our approach leverages on the abstraction level of metamodels where a given metamodel element has often different usages in the code. It supports alternative co-evaluations to meet different developers needs. Our work is evaluated on three Eclipse SL implementations, namely OCL, Modisco, and Papyrus over several evolved versions of metamodels and code. In response to five different evolved metamodels, we co-evolved 976 impacts over 18 projects.A comparison of our co-evolved code with the versioned ones shows the usefulness of our approach. Our approach was able to reach a weighted average of 87.4% and 88.9% respectively of precision and recall while supporting useful alternative co-evolution that developers have manually performed.

- **On the power of abstraction: a model-driven co-evolution approach of software code.** Djamel Eddine Khelladi, Benoit Combemale, Mathieu Acher, and Olivier Barais. *ICSE-NIER 2020: 42nd International Conference on Software Engineering, New Ideas and Emerging Results, Seoul, South Korea, 27 June - 19 July, 2020*, 2020. [PDF](https://inria.hal.science/hal-03029426v1/file/temp_nier.pdf) · [HAL](https://hal.science/hal-03029426) · [DOI](https://doi.org/10.1145/3377816.3381727) · [Video](https://www.youtube.com/watch?v=aTesF4Oazvs)
  Abstract: Model-driven software engineering fosters abstraction through the use of models and then automation by transforming them into various artefacts, in particular to code, for example: 1) from architectural models to code, 2) from metamodels to API code (with EMF in Eclipse), 3) from entity models to front-end and back-end code in Web stack application (with JHispter), etc. In all these examples, the generated code is usually enriched by developers with additional code implementing advanced functionalities (e.g., checkers, recommenders, etc.) to build a full coherent system. When the system must evolve, so are the models to regenerate the code. As a result, the developers' enriched code may be impacted and thus need to co-evolve accordingly. Many approaches support the co-evolution of various artifacts, but not the co-evolution of code. This paper sheds light on this issue and envisions to fill this gap. We formulate the hypothesis that the code co-evolution can be driven by the model changes by means of change propagation. To investigate this hypothesis, we implemented a prototype for the case of metamodels and their accompanying code in EMF Eclipse. As a preliminary evaluation, we considered the case of the OCL Pivot metamodel evolution and its code co-evolution in two projects from version 3.2.2 to 3.4.4. Preliminary results confirms our hypothesis that model-driven evolution changes can effectively drive the code co-evolution. On 562 impacts in two projects' code by 221 metamodel changes, our approach was able to reach the average of 89% and 92,5% respectively of precision and recall.

- **Machine learning and configurable systems: a gentle introduction.** Juliana Alves Pereira, Hugo Martin, Paul Temple, and Mathieu Acher. *SPLC '20: 24th ACM International Systems and Software Product Line Conference, Montreal, Quebec, Canada, October 19-23, 2020, Volume A*, 2020. [HAL](https://hal.science/hal-02287459) · [DOI](https://doi.org/10.1145/3382025.3414976)
  Abstract: The goal of this tutorial is to give an introduction to how machine learning can be used to support activities related to the engineering of con gurable systems and software product lines. To the best of our knowledge, this is the rst practical tutorial in this trending eld. The tutorial is based on a systematic literature review and includes practical tasks (specialization, performance prediction) on real-world systems (VaryLaTeX, x264).

- **Characterizing Black-box Composition Operators via Generated Tailored Benchmarks.** Benjamin Benni, Sébastien Mosser, Mathieu Acher, and Mathieu Paillart. *J. Object Technol., 19(2)*, 2020. [DOI](https://doi.org/10.5381/jot.2020.19.2.a7) · [Video](https://www.youtube.com/watch?v=9Z3lmoH6g38)
  Abstract: The integration of a model composition operator into a system is a challenging task: the properties associated with such operators can drastically change how the developers will be able to use it. In this paper, we describe a modelling framework that allows a software developer, who is not an expert in model composition, to describe the interface of the operators she wants to use, and describe the properties she expects from them to fit her needs (e.g., idempotence, commutativity, associativity). This abstract description is used to pilot a property-based testing approach on generated code. We applied the approach to two case studies: feature model composition and Git merging.

- **MALTESQUE 2019 Workshop Summary.** Francesca Arcelli Fontana, Gilles Perrouin, Apostolos Ampatzoglou, Mathieu Acher, Bartosz Walter, Maxime Cordy, Fabio Palomba, and Xavier Devroey. *ACM SIGSOFT Softw. Eng. Notes, 45(1)*, 2020. [PDF](https://inria.hal.science/hal-02471302v1/file/MALTESQUE19_WorkshopSummary.pdf) · [HAL](https://hal.science/hal-02471302) · [DOI](https://doi.org/10.1145/3375572.3375582)
  Abstract: Welcome to the third edition of the workshop on Machine Learning Techniques for Software Quality Evaluation (MaLTeSQuE 2019), held in Tallinn, Estonia, August 27th, 2019, co-located with ESEC / FSE 2019. This year MALTESQUE merged with the MASES (Machine Learning and Software Engineering in Symbiosis) workshop, co-located with the ASE 2018 conference. Ten papers from all over the world were submitted, seven of them were accepted. The program also featured a keynote by Lionel Briand on the use of machine learning to improve software testing.

- **Sampling Effect on Performance Prediction of Configurable Systems: A Case Study.** Juliana Alves Pereira, Mathieu Acher, Hugo Martin, and Jean-Marc Jézéquel. *International Conference on Performance Engineering (ICPE 2020)*, 2020. **Best Paper Award.** [PDF](https://inria.hal.science/hal-02356290v3/file/ICPE2020_x264_withAppendix.pdf) · [HAL](https://hal.science/hal-02356290) · [DOI](https://doi.org/10.1145/3358960.3379137) · [Video](https://www.youtube.com/watch?v=jtXoYdHhVtI)
  Abstract: Numerous software systems are highly configurable and provide a myriad of configuration options that users can tune to fit their functional and performance requirements (e.g., execution time). Measuring all configurations of a system is the most obvious way to understand the effect of options and their interactions, but is too costly or infeasible in practice. Numerous works thus propose to measure only a few configurations (a sample) to learn and predict the performance of any combination of options’ values. A challenging issue is to sample a small and representative set of configurations that leads to a good accuracy of performance prediction models. A recent study devised a new algorithm, called distance-based sampling, that obtains state-of-the-art accurate performance predictions on different subject systems. In this paper, we replicate this study through an in-depth analysis of x264, a popular and configurable video encoder. We systematically measure 1,152 configurations of x264 with 17 input videos and two quantitative properties (encoding time and encoding size). Our goal is to understand whether there is a dominant sampling strategy over the very same subject system (x264), i.e., whatever the workload and targeted performance properties. The findings from this study show that random sampling leads to more accurate performance models. However, without considering random, there is no single “dominant" sampling, instead different strategies perform best on different inputs and non-functional properties, further challenging practitioners and researchers.

## 2019

- **Learning Very Large Configuration Spaces: What Matters for Linux Kernel Sizes.** Mathieu Acher, Hugo Martin, Juliana Alves Pereira, Arnaud Blouin, Jean-Marc Jézéquel, Djamel Eddine Khelladi, Luc Lesoil, and Olivier Barais. *Research Report, Inria Rennes - Bretagne Atlantique*, 2019. [PDF](https://hal.science/hal-02314830/file/LinuxSizePrediction.pdf) · [HAL](https://hal.science/hal-02314830)
  Abstract: Linux kernels are used in a wide variety of appliances, many of them having strong requirements on the kernel size due to constraints such as limited memory or instant boot. With more than ten thousands of configuration options to choose from, obtaining a suitable trade off between kernel size and functionality is an extremely hard problem. Developers, contributors, and users actually spend significant effort to document, understand, and eventually tune (combinations of) options for meeting a kernel size. In this paper, we investigate how machine learning can help explain what matters for predicting a given Linux kernel size. Unveiling what matters in such very large configuration space is challenging for two reasons: (1) whatever the time we spend on it, we can only build and measure a tiny fraction of possible kernel configurations; (2) the prediction model should be both accurate and interpretable. We compare different machine learning algorithms and demonstrate the benefits of specific feature encoding and selection methods to learn an accurate model that is fast to compute and simple to interpret. Our results are validated over 95,854 kernel configurations and show that we can achieve low prediction errors over a reduced set of options. We also show that we can extract interpretable information for refining documentation and experts' knowledge of Linux, or even assigning more sensible default values to options.

- **Learning the Linux Kernel Configuration Space: Results and Challenges.** Mathieu Acher. *ELC Europe 2019 - Embedded Linux Conference Europe 2019*, 2019. [PDF](https://hal.science/hal-02342130/file/TuxML-OSS2019-final.pdf) · [HAL](https://hal.science/hal-02342130) · [Video](https://www.youtube.com/watch?v=UBghs-cwQX4)

- **Machine Learning and Configurable Systems: A Gentle Introduction.** Hugo Martin, Juliana Alves Pereira, Paul Temple, and Mathieu Acher. *SPLC 2019 - 23rd International Systems and Software Product Line Conference*, 2019. [PDF](https://inria.hal.science/hal-02287459v2/file/SPLC_Tuto_ML_config_systems2019Ack.pdf) · [HAL](https://hal.science/hal-02287459) · [DOI](https://doi.org/10.1145/3336294.3342383)
  Abstract: The goal of this tutorial is to give an introduction to how machine learning can be used to support activities related to the engineering of con gurable systems and software product lines. To the best of our knowledge, this is the rst practical tutorial in this trending eld. The tutorial is based on a systematic literature review and includes practical tasks (specialization, performance prediction) on real-world systems (VaryLaTeX, x264).

- **Seventh international workshop on reverse variability engineering (REVE 2019).** Mathieu Acher, Tewfik Ziadi, Roberto E Lopez-Herrejon, and Jabier Martinez. *SPLC 2019 - 23rd International Systems and Software Product Line Conference*, 2019. [HAL](https://hal.science/hal-02268373) · [DOI](https://doi.org/10.1145/3336294.3342365)
  Abstract: Software Product Line (SPL) migration remains a challenging endeavour. From organizational issues to purely technical challenges, there is a wide range of barriers that complicates SPL adoption. This workshop aims to foster research about making the most of the two main inputs for SPL migration: 1) domain knowledge and 2) legacy assets. Domain knowledge, usually implicit and spread across an organization, is key to define the SPL scope and to validate the variability model and its semantics. At the technical level, domain expertise is also needed to create or extract the reusable software components. Legacy assets can be, for instance, similar product variants (e.g., requirements, models, source code etc.) that were implemented using ad-hoc reuse techniques such as clone-and-own. More generally, the workshop REverse Variability Engineering (REVE) attracts researchers and practitioners contributing to processes, techniques, tools, or empirical studies related to the automatic, semi-automatic or manual extraction or refinement of SPL assets.

- **Towards Quality Assurance of Software Product Lines with Adversarial Configurations.** Paul Temple, Mathieu Acher, Gilles Perrouin, Battista Biggio, Jean-Marc Jézéquel, and Fabio Roli. *23rd International Systems and Software Product Line Conference*, 2019. [PDF](https://hal.science/hal-02287616/file/Adversarial_Constraints_for_Variability_Models_SPLC2019%20%286%29.pdf) · [HAL](https://hal.science/hal-02287616) · [DOI](https://doi.org/10.1145/3336294.3336309) · [arXiv](https://arxiv.org/abs/1909.07283)
  Abstract: Software product line (SPL) engineers put a lot of effort to ensure that, through the setting of a large number of possible configuration options, products are acceptable and well-tailored to customers' needs. Unfortunately, options and their mutual interactions create a huge configuration space which is intractable to exhaustively explore. Instead of testing all products, machine learning is increasingly employed to approximate the set of acceptable products out of a small training sample of configurations. Machine learning (ML) techniques can refine a software product line through learned constraints and a priori prevent non-acceptable products to be derived. In this paper, we use adversarial ML techniques to generate adver-sarial configurations fooling ML classifiers and pinpoint incorrect classifications of products (videos) derived from an industrial video generator. Our attacks yield (up to) a 100% misclassification rate and a drop in accuracy of 5%. We discuss the implications these results have on SPL quality assurance.

- **Fourth international workshop on software product line teaching (SPLTea 2019).** Mathieu Acher, Rick Rabiser, and Roberto E. Lopez-Herrejon. *Proceedings of the 23rd International Systems and Software Product Line Conference, SPLC 2019, Volume A, Paris, France, September 9-13, 2019*, 2019. [DOI](https://doi.org/10.1145/3336294.3342363)
  Abstract: Education has a key role to play for disseminating the constantly growing body of Software Product Line (SPL) knowledge. In a sense, every researcher in SPL should think about how to teach SPL. This workshop aims to explore and explain the current status and ongoing work on teaching SPLs at universities, colleges, and in industry (e.g., by consultants). This fourth edition will continue the effort made at SPLTea'14, SPLTea'15 and SPLTea'18. In particular we seek to better understand how to build a curriculum for teaching SPLs - a central issue as reported in surveys and as informally discussed at SPLTea'18. We expect several lightning talks that report on traditional questions like: what is the targeted audience? What is the place in the curriculum? What is the material (slides, tools, books, etc) used? As there is hardly a one-size-fits-all curriculum, the workshop aims to collectively identify commonality and variability when building SPL curriculums. As a concrete outcome, we expect to elaborate a variability model of SPL teaching that could be actuated to derive custom curriculum in various contexts.

- **First international workshop on languages for modelling variability (MODEVAR 2019).** David Benavides, Rick Rabiser, Don S. Batory, and Mathieu Acher. *Proceedings of the 23rd International Systems and Software Product Line Conference, SPLC 2019, Volume A, Paris, France, September 9-13, 2019*, 2019. [DOI](https://doi.org/10.1145/3336294.3342364)
  Abstract: Feature models were invented in 1990 and have been recognised as one of the main contributions to the software product line community. Although there have been several attempts to establish a sort of standard variability modelling language, there is still no consensus. There can be many motivations to have one but there is one that is very important: information sharing among researchers, tools or developers. This first international workshop is an interactive event where all participants shall share knowledge about how to build up a simple variability modelling language that all the community can agree on.

- **Towards Quality Assurance of Software Product Lines with Adversarial Configurations.** Paul Temple, Mathieu Acher, Gilles Perrouin, Battista Biggio, Jean-marc Jezequel, and Fabio Roli. *CoRR, abs/1909.07283*, 2019. [DOI](https://doi.org/10.48550/arXiv.1909.07283) · [arXiv](https://arxiv.org/abs/1909.07283) · [Published version](/publications/#temple:hal-02287616)
  Abstract: Software product line (SPL) engineers put a lot of effort to ensure that, through the setting of a large number of possible configuration options, products are acceptable and well-tailored to customers' needs. Unfortunately, options and their mutual interactions create a huge configuration space which is intractable to exhaustively explore. Instead of testing all products, machine learning techniques are increasingly employed to approximate the set of acceptable products out of a small training sample of configurations. Machine learning (ML) techniques can refine a software product line through learned constraints and a priori prevent non-acceptable products to be derived. In this paper, we use adversarial ML techniques to generate adversarial configurations fooling ML classifiers and pinpoint incorrect classifications of products (videos) derived from an industrial video generator. Our attacks yield (up to) a 100% misclassification rate and a drop in accuracy of 5%. We discuss the implications these results have on SPL quality assurance.

- **Discovering Indicators for Classifying Wikipedia Articles in a Domain: A Case Study on Software Languages.** Marcel Heinz, Ralf Lämmel, and Mathieu Acher. *SEKE 2019 - The 31st International Conference on Software Engineering and Knowledge Engineering*, 2019. [PDF](https://hal.science/hal-02129131/file/Discovering_Indicators_for_Classifying_Wikipedia_Articles_in_a_Domain_subtitle_A_Case_Study_on_Software_Languages%20%2812%29.pdf) · [HAL](https://hal.science/hal-02129131) · [DOI](https://doi.org/10.18293/seke2019-126)
  Abstract: Wikipedia is a rich source of information across many knowledge domains. Yet, recovering articles relevant to a specific domain is a difficult problem since such articles may be rare and tend to cover multiple topics. Furthermore, Wikipedia's categories provide an ambiguous classification of articles as they relate to all topics and thus are of limited use. In this paper, we develop a new methodology to isolate Wikipedia's articles that describe a specific topic within the scope of relevant categories; the methodology uses supervised machine learning to retrieve a decision tree classifier based on articles' features (URL patterns, summary text, infoboxes, links from list articles). In a case study, we retrieve 3000+ articles that describe software (computer) languages. Available fragments of ground truths serve as an essential part of the training set to detect relevant articles. The results of the classification are thoroughly evaluated through a survey, in which 31 domain experts participated.

- **Test them all, is it worth it? Assessing configuration sampling on the JHipster Web development stack.** Axel Halin, Alexandre Nuttinck, Mathieu Acher, Xavier Devroey, Gilles Perrouin, and Benoit Baudry. *Empirical Software Engineering (ESE), 24(2)*, 2019. [PDF](https://inria.hal.science/hal-01829928v1/file/10.1007%252Fs10664-018-9635-4.pdf) · [HAL](https://hal.science/hal-01829928) · [DOI](https://doi.org/10.1007/s10664-018-9635-4) · [arXiv](https://arxiv.org/abs/1710.07980) · [Video](https://www.youtube.com/watch?v=mjBmarVDBBo)
  Abstract: Many approaches for testing configurable software systems start from the same assumption: it is impossible to test all configurations. This motivated the definition of variability-aware abstractions and sampling techniques to cope with large configuration spaces. Yet, there is no theoretical barrier that prevents the exhaustive testing of all configurations by simply enumerating them, if the effort required to do so remains acceptable. Not only this: we believe there is lots to be learned by systematically and exhaustively testing a configurable system. In this case study, we report on the first ever endeavour to test all possible configurations of an industry-strength, open source configurable software system, JHipster, a popular code generator for web applications. We built a testing scaffold for the 26,000+ configurations of JHipster using a cluster of 80 machines during 4 nights for a total of 4,376 hours (182 days) CPU time. We find that 35.70% configurations fail and we identify the feature interactions that cause the errors. We show that sampling strategies (like dissimilarity and 2-wise): (1) are more effective to find faults than the 12 default configurations used in the JHipster continuous integration; (2) can be too costly and exceed the available testing budget. We cross this quantitative analysis with the qualitative assessment of JHipster's lead developers.

- **Learning From Thousands of Build Failures of Linux Kernel Configurations.** Mathieu Acher, Hugo Martin, Juliana Alves Pereira, Arnaud Blouin, Djamel Eddine Khelladi, and Jean-Marc Jézéquel. *Technical Report, Inria ; IRISA*, 2019. [PDF](https://hal.science/hal-02147012/file/LinuxCompilation_BuildFailures.pdf) · [HAL](https://hal.science/hal-02147012)
  Abstract: The Linux kernel offers more than ten thousands configuration options that can be combined to build an almost infinite number of kernel variants. Developers and contributors spend significant effort and computational resources to continuously track and hopefully fix configurations that lead to build failures. In this experience paper, we report on our endeavor to develop an infrastructure, called TuxML, able to build any kernel configuration and learn what could explain or even prevent configurations' failures. Our results over 95,000+ configurations show that TuxML can accurately cluster 3,600+ failures, automatically trace the responsible configuration options, and learn by itself to avoid unnecessary and costly builds. Our large qualitative and quantitative analysis reveals insights about Linux itself (e.g., we only found 16 configuration bugs) and the difficulty to engineer a build infrastructure for configurable systems (e.g., a false positive failure may mask true configuration bugs).

- **Learning Software Configuration Spaces: A Systematic Literature Review.** Juliana Alves Pereira, Hugo Martin, Mathieu Acher, Jean-Marc Jézéquel, Goetz Botterweck, and Anthony Ventresque. *CoRR, abs/1906.03018*, 2019. [DOI](https://doi.org/10.48550/arXiv.1906.03018) · [arXiv](https://arxiv.org/abs/1906.03018) · [Published version](/publications/#alvespereira:hal-02148791)
  Abstract: Most modern software systems (operating systems like Linux or Android, Web browsers like Firefox or Chrome, video encoders like ffmpeg, x264 or VLC, mobile and cloud applications, etc.) are highly-configurable. Hundreds of configuration options, features, or plugins can be combined, each potentially with distinct functionality and effects on execution time, security, energy consumption, etc. Due to the combinatorial explosion and the cost of executing software, it is quickly impossible to exhaustively explore the whole configuration space. Hence, numerous works have investigated the idea of learning it from a small sample of configurations' measurements. The pattern "sampling, measuring, learning" has emerged in the literature, with several practical interests for both software developers and end-users of configurable systems. In this survey, we report on the different application objectives (e.g., performance prediction, configuration optimization, constraint mining), use-cases, targeted software systems and application domains. We review the various strategies employed to gather a representative and cost-effective sample. We describe automated software techniques used to measure functional and non-functional properties of configurations. We classify machine learning algorithms and how they relate to the pursued application. Finally, we also describe how researchers evaluate the quality of the learning process. The findings from this systematic review show that the potential application objective is important; there are a vast number of case studies reported in the literature from the basis of several domains and software systems. Yet, the huge variant space of configurable systems is still challenging and calls to further investigate the synergies between artificial intelligence and software engineering.

- **Uniform Sampling of SAT Solutions for Configurable Systems: Are We There Yet?.** Quentin Plazar, Mathieu Acher, Gilles Perrouin, Xavier Devroey, and Maxime Cordy. *ICST 2019 - 12th International Conference on Software Testing, Verification, and Validation*, 2019. [PDF](https://hal.science/hal-01991857/file/Uniform_Sampling_of_SAT_Solutions_for_Configurable_Systems__Are_We_There_Yet____footnotesize_textsuperscript__%20%283%29.pdf) · [HAL](https://hal.science/hal-01991857) · [DOI](https://doi.org/10.1109/icst.2019.00032)
  Abstract: Uniform or near-uniform generation of solutions for large satisfiability formulas is a problem of theoretical and practical interest for the testing community. Recent works proposed two algorithms (namely UniGen and QuickSampler) for reaching a good compromise between execution time and uniformity guarantees, with empirical evidence on SAT benchmarks. In the context of highly-configurable software systems (e.g., Linux), it is unclear whether UniGen and QuickSampler can scale and sample uniform software configurations. In this paper, we perform a thorough experiment on 128 real-world feature models. We find that UniGen is unable to produce SAT solutions out of such feature models. Furthermore, we show that QuickSampler does not generate uniform samples and that some features are either never part of the sample or too frequently present. Finally, using a case study, we characterize the impacts of these results on the ability to find bugs in a configurable system. Overall, our results suggest that we are not there: more research is needed to explore the cost-effectiveness of uniform sampling when testing large configurable systems.

- **Towards Learning-Aided Configuration in 3D Printing: Feasibility Study and Application to Defect Prediction.** Benoit Amand, Maxime Cordy, Patrick Heymans, Mathieu Acher, Paul Temple, and Jean-Marc Jézéquel. *VaMoS 2019 - 13th International Workshop on Variability Modelling of Software-Intensive Systems*, 2019. [PDF](https://hal.science/hal-01990767/file/Towards_Learning_Aided_Configuration_in_3D_Printing%20%2811%29.pdf) · [HAL](https://hal.science/hal-01990767) · [DOI](https://doi.org/10.1145/3302333.3302338)
  Abstract: Configurators rely on logical constraints over parameters to aid users and determine the validity of a configuration. However, for some domains, capturing such configuration knowledge is hard, if not infeasible. This is the case in the 3D printing industry, where parametric 3D object models contain the list of parameters and their value domains, but no explicit constraints. This calls for a complementary approach that learns what configurations are valid based on previous experiences. In this paper, we report on preliminary experiments showing the capability of state-of-the-art classification algorithms to assist the configuration process. While machine learning holds its promises when it comes to evaluation scores, an in-depth analysis reveals the opportunity to combine the classifiers with constraint solvers.

- **Proceedings of the 3rd ACM SIGSOFT International Workshop on Machine Learning Techniques for Software Quality Evaluation, MaLTeSQuE@ESEC/SIGSOFT FSE 2019, Tallinn, Estonia, August 27, 2019.** Francesca Arcelli Fontana, Bartosz Walter, Apostolos Ampatzoglou, Fabio Palomba, Gilles Perrouin, Mathieu Acher, Maxime Cordy, and Xavier Devroey (eds.). *Edited volume, ACM*, 2019. [DOI](https://doi.org/10.1145/3340482)

- **Special issue on systems and software product line engineering.** Mathieu Acher and Myra B. Cohen. *Journal of Systems and Software (JSS), 154*, 2019. [DOI](https://doi.org/10.1016/j.jss.2019.04.054)

- **Modeling Variability in the Video Domain: Language and Experience Report.** Mauricio Alférez, Mathieu Acher, José A Galindo, Benoit Baudry, and David Benavides. *Software Quality Journal, 27(1)*, 2019. [PDF](https://hal.science/hal-01688247/file/modeling-variability-video%20%2828%29.pdf) · [HAL](https://hal.science/hal-01688247) · [DOI](https://doi.org/10.1007/s11219-017-9400-8)
  Abstract: [Context] In an industrial project, we addressed the challenge of developing a software-based video generator such that consumers and providers of video processing algorithms can benchmark them on a wide range of video variants. [Objective] This article aims to report on our positive experience in modeling, controlling, and implementing software variability in the video domain. [Method] We describe how we have designed and developed a variability modeling language, called VM, resulting from the close collaboration with industrial partners during two years. We expose the specific requirements and advanced variability constructs we developed and used to characterize and derive variations of video sequences. [Results] The results of our experiments and industrial experience show that our solution is effective to model complex variability information and supports the synthesis of hundreds of realistic video variants. [Conclusions] From the software language perspective, we learned that basic variability mechanisms are useful but not enough; attributes and multi-features are of prior importance; meta-information and specific constructs are relevant for scalable and purposeful reasoning over variability models. From the video domain and software perspective, we report on the practical benefits of a variability approach. With more automation and control, practitioners can now envision benchmarking video algorithms over large, diverse, controlled, yet realistic datasets (videos that mimic real recorded videos) – something impossible at the beginning of the project.

## 2018

- **Teaching Software Product Lines: A Snapshot of Current Practices and Challenges (Journal-First Abstract).** Mathieu Acher, Roberto E Lopez-Herrejon, and Rick Rabiser. *SPLC2018 - 22nd International Systems and Software Product Line Conference*, 2018. [HAL](https://hal.science/hal-01829933) · [DOI](https://doi.org/10.1145/3233027.3236393)
  Abstract: This extended abstract summarizes our article entitled " Teaching Software Product Lines: A Snapshot of Current Practices and Challenges " published in the ACM Transactions on Computing Education , vol. 18 in 2017 (http://doi.acm.org/10.1145/3088440). The article reports on three initiatives we have conducted with scholars, educators, industry practitioners, and students to understand the connection between software product lines and education and to derive recommendations for educators to continue improving the state of practice of teaching SPLs.

- **SPLtea 2018: third international workshop on software product line teaching.** Mathieu Acher, Rick Rabiser, and Roberto E. Lopez-Herrejon. *Proceeedings of the 22nd International Systems and Software Product Line Conference - Volume 1, SPLC 2018, Gothenburg, Sweden, September 10-14, 2018*, 2018. [DOI](https://doi.org/10.1145/3233027.3241370)
  Abstract: Education has a key role to play for disseminating the constantly growing body of Software Product Line (SPL) knowledge. In a sense, every researcher in SPL should think about how to teach SPL. This workshop aims to explore and explain the current status and ongoing work on teaching SPLs at universities, colleges, and in industry (e.g., by consultants). This third edition will continue the effort made at SPLTea'14 and SPLTea'15. In particular we seek to attract experience reports of teaching SPLs. We expect several lightning talks that report on traditional questions like: what is the targeted audience? What is the place in the curriculum? What is the material (slides, tools, books, etc) used? What are the benefits of teaching SPLs? What are the difficulties and barriers? We also welcome opinionated and provocative talks that encourage discussions about the topic. Another goal of the workshop is to populate an open repository of resources dedicated to SPL teaching: http://teaching.variability.io

- **REVE 2018: 6th international workshop on reverse variability engineering.** Tewfik Ziadi, Roberto E. Lopez-Herrejon, Mathieu Acher, and Jabier Martinez. *Proceeedings of the 22nd International Systems and Software Product Line Conference - Volume 1, SPLC 2018, Gothenburg, Sweden, September 10-14, 2018*, 2018. [HAL](https://hal.science/hal-01879396) · [DOI](https://doi.org/10.1145/3233027.3241371)
  Abstract: Software Product Line (SPL) migration remains a challenging endeavour. From organizational issues to purely technical challenges, there is a wide range of barriers that complicates SPL adoption. The workshop REverse Variability Engineering (REVE) aims to foster research about making the most of the two main inputs for SPL migration: 1) domain knowledge and 2) legacy assets. Domain knowledge, usually implicit and spread across an organization, is key to define the SPL scope and to validate the variability model and its semantics. At the technical level, domain expertise is also needed to create or extract the reusable software components. Legacy assets can be, for instance, similar product variants (e.g., requirements, models, source code) that were implemented using ad-hoc reuse techniques such as clone-and-own. More generally, the workshop attracts researchers and practitioners contributing to processes, techniques, tools, or empirical studies related to the automatic, semi-automatic or manual extraction or refinement of SPL assets.

- **Multimorphic Testing.** Paul Temple, Mathieu Acher, and Jean-Marc Jézéquel. *ACM/IEEE 40th International Conference on Software Engineering: Companion Proceedings*, 2018. [PDF](https://hal.science/hal-01730163/file/Multimorphic.pdf) · [HAL](https://hal.science/hal-01730163) · [DOI](https://doi.org/10.1145/3183440.3195043)
  Abstract: The functional correctness of a software application is, of course, a prime concern, but other issues such as its execution time, precision , or energy consumption might also be important in some contexts. Systematically testing these quantitative properties is still extremely difficult, in particular, because there exists no method to tell the developer whether such a test set is "good enough" or even whether a test set is better than another one. This paper proposes a new method, called Multimorphic testing, to assess the relative effectiveness of a test suite for revealing performance variations of a software system. By analogy with mutation testing, our core idea is to vary software parameters, and to check whether it makes any difference on the outcome of the tests: i.e. are some tests able to " kill " bad morphs (configurations)? Our method can be used to evaluate the quality of a test suite with respect to a quantitative property of interest, such as execution time or computation accuracy.

- **Towards Estimating and Predicting User Perception on Software Product Variants.** Jabier Martinez, Jean-Sébastien Sottet, Alfonso Garcia Frey, Tegawendé Bissyandé, Tewfik Ziadi, Jacques Klein, Paul Temple, Mathieu Acher, and Yves Le Traon. *ICSR 2018 - International Conference on Software Reuse*, 2018. [PDF](https://hal.sorbonne-universite.fr/hal-01720519/file/Martinez_et_al_ICSR2018.pdf) · [HAL](https://hal.science/hal-01720519) · [DOI](https://doi.org/10.1007/978-3-319-90421-4_2) · [Link](https://hal.sorbonne-universite.fr/hal-01720519)
  Abstract: Estimating and predicting user subjective perceptions on software products is a challenging, yet increasingly important, endeavour. As an extreme case study, we consider the problem of exploring computer-generated art object combinations that will please the maximum number of people. Since it is not feasible to gather feedbacks for all art products because of a combinatorial explosion of possible configurations as well as resource and time limitations, the challenging objective is to rank and identify optimal art product variants that can be generated based on their average likability. We present the use of Software Product Line (SPL) techniques for gathering and leveraging user feedbacks within the boundaries of a variability model. Our approach is developed in two phases: 1) the creation of a data set using a genetic algorithm and real feedback and 2) the application of a data mining technique on this data set to create a ranking enriched with confidence metrics. We perform a case study of a real-world computer-generated art system. The results of our approach on the arts domain reveal interesting directions for the analysis of user-specific qualities of SPLs.

- **VaryLaTeX: Learning Paper Variants That Meet Constraints.** Mathieu Acher, Paul Temple, Jean-Marc Jézéquel, José Angel Galindo Duarte, Jabier Martinez, and Tewfik Ziadi. *12th International Workshop on Variability Modelling of Software-intensive Systems (VaMoS'18)*, 2018. [PDF](https://inria.hal.science/hal-01659161v1/file/varyLaTeX.pdf) · [HAL](https://hal.science/hal-01659161) · [DOI](https://doi.org/10.1145/3168365.3168372) · [Video](https://www.youtube.com/watch?v=u1ralqbHCyM)
  Abstract: How to submit a research paper, a technical report, a grant proposal, or a curriculum vitae that respect imposed constraints such as formatting instructions and page limits? It is a challenging task, especially with time pressure and deadlines. In this paper, we present a solution based on variability, constraint programming, and machine learning techniques for documents written in LaTeX. Users simply have to annotate LaTeX source files with variability information for e.g., (de)activating portions of text, tuning the figures' sizes, or tweaking line spacing. Then, a fully automated procedure learns constraints among Boolean and numerical features for avoiding non-acceptable paper variants. As a result, users can configure their papers (e.g., for controlling the aesthetics) or pick a (random) paper variant that meets constraints e.g., page limits. We describe our implementation and report on some experiences with VaryLaTeX.

- **Proceedings of the 1st International Workshop on Machine Learning and Software Engineering in Symbiosis, MASES@ASE 2018, Montpellier, France, September 3, 2018.** Gilles Perrouin, Mathieu Acher, Maxime Cordy, and Xavier Devroey (eds.). *Edited volume, ACM*, 2018. [DOI](https://doi.org/10.1145/3243127)

- **Towards Adversarial Configurations for Software Product Lines.** Paul Temple, Mathieu Acher, Battista Biggio, Jean-Marc Jézéquel, and Fabio Roli. *CoRR, abs/1805.12021*, 2018. [DOI](https://doi.org/10.48550/arXiv.1805.12021) · [arXiv](https://arxiv.org/abs/1805.12021)
  Abstract: Ensuring that all supposedly valid configurations of a software product line (SPL) lead to well-formed and acceptable products is challenging since it is most of the time impractical to enumerate and test all individual products of an SPL. Machine learning classifiers have been recently used to predict the acceptability of products associated with unseen configurations. For some configurations, a tiny change in their feature values can make them pass from acceptable to non-acceptable regarding users' requirements and vice-versa. In this paper, we introduce the idea of leveraging these specific configurations and their positions in the feature space to improve the classifier and therefore the engineering of an SPL. Starting from a variability model, we propose to use Adversarial Machine Learning techniques to create new, adversarial configurations out of already known configurations by modifying their feature values. Using an industrial video generator we show how adversarial configurations can improve not only the classifier, but also the variability model, the variability implementation, and the testing oracle.

## 2017

- **Learning Contextual-Variability Models.** Paul Temple, Mathieu Acher, Jean-Marc Jézéquel, and Olivier Barais. *IEEE Software, 34(6)*, 2017. [PDF](https://inria.hal.science/hal-01659137v1/file/Learning_Contextual_Variability_Models.pdf) · [HAL](https://hal.science/hal-01659137) · [DOI](https://doi.org/10.1109/ms.2017.4121211)
  Abstract: Modeling how contextual factors relate to a software system’s configuration space is usually a manual, error-prone task that depends highly on expert knowledge. Machine-learning techniques can automatically predict the acceptable software configurations for a given context. Such an approach executes and observes a sample of software configurations within a sample of contexts. It then learns what factors of each context will likely discard or activate some of the software’s features. This lets developers and product managers automatically extract the rules that specialize highly configurable systems for specific contexts.

- **REVE 2017: 5th International Workshop on REverse Variability Engineering.** Jabier Martinez, Roberto E. Lopez-Herrejon, Tewfik Ziadi, and Mathieu Acher. *Proceedings of the 21st International Systems and Software Product Line Conference, SPLC 2017, Volume A, Sevilla, Spain, September 25-29, 2017*, 2017. [HAL](https://hal.science/hal-01628956) · [DOI](https://doi.org/10.1145/3106195.3106199)
  Abstract: Software Product Line (SPL) migration remains a challenging endeavour. From organizational issues to purely technical challenges, there is a wide range of barriers that complicates SPL adoption. The workshop REverse Variability Engineering (REVE) aims to foster research about making the most of the two main inputs for SPL migration: 1) domain knowledge and 2) legacy assets. Domain knowledge, usually implicit and spread across an organization, is key to define the SPL scope and to validate the variability model and its semantics. At the technical level, domain expertise is also needed to create or extract the reusable software components. Legacy assets can be, for instance, similar product variants (e.g., requirements, models, source code) that were implemented using ad-hoc reuse techniques such as clone-and-own. More generally, the workshop attracts researchers and practitioners contributing to processes, techniques, tools, or empirical studies related to the automatic, semi-automatic or manual extraction or refinement of SPL assets.

- **Efficient and Complete FD-Solving for Extended Array Constraints.** Quentin Plazar, Mathieu Acher, Sébastien Bardin, and Arnaud Gotlieb. *IJCAI 2017*, 2017. [PDF](https://hal.science/hal-01545557/file/camera_ready.pdf) · [HAL](https://hal.science/hal-01545557) · [DOI](https://doi.org/10.24963/ijcai.2017/171)
  Abstract: Array constraints are essential for handling data structures in automated reasoning and software verification. Unfortunately, the use of a typical finite domain (FD) solver based on local consistency-based filtering has strong limitations when constraints on indexes are combined with constraints on array elements and size. This paper proposes an efficient and complete FD-solving technique for extended constraints over (possibly unbounded) arrays. We describe a simple but particularly powerful transformation for building an equisatisfiable formula that can be efficiently solved using standard FD reasoning over arrays, even in the unbounded case. Experiments show that the proposed solver significantly outperforms FD solvers, and successfully competes with the best SMT-solvers.

- **Yo Variability! JHipster: A Playground for Web-Apps Analyses.** Axel Halin, Alexandre Nuttinck, Mathieu Acher, Xavier Devroey, Gilles Perrouin, and Patrick Heymans. *11th International Workshop on Variability Modelling of Software-intensive Systems (VaMoS'17)*, 2017. [PDF](https://hal.science/hal-01468084/file/vamos-2017%20%2810%29.pdf) · [HAL](https://hal.science/hal-01468084) · [DOI](https://doi.org/10.1145/3023956.3023963)
  Abstract: Though variability is everywhere, there has always been a shortage of publicly available cases for assessing variability-aware tools and techniques as well as supports for teaching variability-related concepts. Historical software product lines contains industrial secrets their owners do not want to disclose to a wide audience. The open source community contributed to large-scale cases such as Eclipse, Linux kernels, or web-based plugin systems (Drupal, WordPress). To assess accuracy of sampling and prediction approaches (bugs, performance), a case where all products can be enumerated is desirable. As configuration issues do not lie within only one place but are scattered across technologies and assets, a case exposing such diversity is an additional asset. To this end, we present in this paper our efforts in building an explicit product line on top of JHipster, an industrial open-source Web-app configurator that is both manageable in terms of configurations (≈ 163,000) and diverse in terms of technologies used. We present our efforts in building a variability-aware chain on top of JHipster's configurator and lessons learned using it as a teaching case at the University of Rennes. We also sketch the diversity of analyses that can be performed with our infrastructure as well as early issues found using it. Our long term goal is both to support students and researchers studying variability analysis and JHipster developers in the maintenance and evolution of their tools.

- **Learning-Based Performance Specialization of Configurable Systems.** Paul Temple, Mathieu Acher, Jean-Marc Jézéquel, Léo Noel-Baron, and José A. Galindo. *Research Report, IRISA, Inria Rennes ; University of Rennes 1*, 2017. [PDF](https://hal.science/hal-01467299/file/TSE-ML.pdf) · [HAL](https://hal.science/hal-01467299)
  Abstract: A large scale configurable system typically offers thousands of options or parameters to let the engineers customize it for specific needs. Among the resulting many billions possible configurations, relating option and parameter values to desired performance is then a daunting task relying on a deep know how of the internals of the configurable system. In this paper, we propose a staged configuration process to narrow the space of possible configurations to a good approximation of those satisfying the wanted high level customer requirements. Based on an oracle (e.g. a runtime test) that tells us whether a given configuration meets the requirements (e.g. speed or memory footprint), we leverage machine learning to retrofit the acquired knowledge into a variability model of the system that can be used to automatically specialize the configurable system. We validate our approach on a set of well-known configurable software systems. Our results show that, for many different kinds of objectives and performance qualities, the approach has interesting accuracy, precision and recall after a learning stage based on a relative small number of random samples.

- **Test them all, is it worth it? A ground truth comparison of configuration sampling strategies.** Axel Halin, Alexandre Nuttinck, Mathieu Acher, Xavier Devroey, Gilles Perrouin, and Benoit Baudry. *CoRR, abs/1710.07980*, 2017. [arXiv](https://arxiv.org/abs/1710.07980) · [Published version](/publications/#halin:hal-01829928)
  Abstract: Many approaches for testing configurable software systems start from the same assumption: it is impossible to test all configurations. This motivated the definition of variability-aware abstractions and sampling techniques to cope with large configuration spaces. Yet, there is no theoretical barrier that prevents the exhaustive testing of all configurations by simply enumerating them, if the effort required to do so remains acceptable. Not only this: we believe there is lots to be learned by systematically and exhaustively testing a configurable system. In this article, we report on the first ever endeavor to test all possible configurations of an industry-strength, open source configurable software system, JHipster, a popular code generator for web applications. We built a testing scaffold for the 26,000+ configurations of JHipster using a cluster of 80 machines during 4 nights for a total of 4,376 hours (182 days) CPU time. We find that 35.70% configurations fail and we identify the feature interactions that cause the errors. We show that sampling testing strategies (like dissimilarity and 2-wise) (1) are more effective to find faults than the 12 default configurations used in the JHipster continuous integration; (2) can be too costly and exceed the available testing budget. We cross this quantitative analysis with the qualitative assessment of JHipster's lead developers.

- **Proceedings of the 21st International Systems and Software Product Line Conference, SPLC 2017, Volume A, Sevilla, Spain, September 25-29, 2017.** Myra B. Cohen, Mathieu Acher, Lidia Fuentes, Daniel Schall, Jan Bosch, Rafael Capilla, Ebrahim Bagheri, Yingfei Xiong, Javier Troya, Antonio Ruiz Cortes, and David Benavides (eds.). *Edited volume, ACM*, 2017. [DOI](https://doi.org/10.1145/3106195)

- **Teaching Software Product Lines: A Snapshot of Current Practices and Challenges.** Mathieu Acher, Roberto Erick Lopez-Herrejon, and Rick Rabiser. *ACM Transactions on Computing Education (TOCE), 18(1)*, 2017. [PDF](https://inria.hal.science/hal-01522779v1/file/TOCE.pdf) · [HAL](https://hal.science/hal-01522779) · [DOI](https://doi.org/10.1145/3088440)
  Abstract: Software Product Line (SPL) engineering has emerged to provide the means to efficiently model, produce, and maintain multiple similar software variants, exploiting their common properties, and managing their variabilities (differences). With over two decades of existence, the community of SPL researchers and practitioners is thriving as can be attested by the extensive research output and the numerous successful industrial projects. Education has a key role to support the next generation of practitioners to build highly complex, variability-intensive systems. Yet, it is unclear how the concepts of variability and SPLs are taught, what are the possible missing gaps and difficulties faced, what are the benefits, or what is the material available. Also, it remains unclear whether scholars teach what is actually needed by industry. In this article we report on three initiatives we have conducted with scholars, educators, industry practitioners, and students to further understand the connection between SPLs and education, i.e., an online survey on teaching SPLs we performed with 35 scholars, another survey on learning SPLs we conducted with 25 students, as well as two workshops held at the International Software Product Line Conference in 2014 and 2015 with both researchers and industry practitioners participating. We build upon the two surveys and the workshops to derive recommendations for educators to continue improving the state of practice of teaching SPLs, aimed at both individual educators as well as the wider community.

- **Automated Extraction of Product Comparison Matrices From Informal Product Descriptions.** Sana Ben Nasr, Guillaume Bécan, Mathieu Acher, João Bosco Ferreira Filho, Nicolas Sannier, Benoit Baudry, and Jean-Marc Davril. *Journal of Systems and Software (JSS), 124*, 2017. [PDF](https://hal.science/hal-01427218/file/spedoc.pdf) · [HAL](https://hal.science/hal-01427218) · [DOI](https://doi.org/10.1016/j.jss.2016.11.018)
  Abstract: Domain analysts, product managers, or customers aim to capture the important features and differences among a set of related products. A case-by-case reviewing of each product description is a laborious and time-consuming task that fails to deliver a condense view of a family of product. In this article, we investigate the use of automated techniques for synthesizing a product comparison matrix (PCM) from a set of product descriptions written in natural language. We describe a tool-supported process, based on term recognition, information extraction, clustering, and similarities, capable of identifying and organizing features and values in a PCM – despite the informality and absence of structure in the textual descriptions of products. We evaluate our proposal against numerous categories of products mined from BestBuy. Our empirical results show that the synthesized PCMs exhibit numerous quantitative, comparable information that can potentially complement or even refine technical descriptions of products. The user study shows that our automatic approach is capable of extracting a significant portion of correct features and correct values. This approach has been implemented in MatrixMiner a web environment with an interactive support for automatically synthesizing PCMs from informal product descriptions. MatrixMiner also maintains traceability with the original descriptions and the technical specifications for further refinement or maintenance by users.

## 2016

- **A Decision-making Process for Exploring Architectural Variants in Systems Engineering.** Jérome Le Noir, Sébastien Madelénat, Christophe Labreuche, Olivier Constant, Grégory Gailliard, Mathieu Acher, and Olivier Barais. *Software Product Lines Conference (SPLC)*, 2016. [PDF](https://hal.science/hal-01374140/file/SPLC2016-ArchiComp.pdf) · [HAL](https://hal.science/hal-01374140) · [DOI](https://doi.org/10.1145/2934466.2946045)
  Abstract: In systems engineering, practitioners shall explore numerous architectural alternatives until choosing the most adequate variant. The decision-making process is most of the time a manual, time-consuming, and error-prone activity. The exploration and justification of architectural solutions is ad-hoc and mainly consists in a series of tries and errors on the mod-eling assets. In this paper, we report on an industrial case study in which we apply variability modeling techniques to automate the assessment and comparison of several candidate architectures (variants). We first describe how we can use a model-based approach such as the Common Variability Language (CVL) to specify the architectural variability. We show that the selection of an architectural variant is a multi-criteria decision problem in which there are numerous interactions (veto, favor, complementary) between criteria. We present a tooled process for exploring architectural variants integrating both CVL and the MYRIAD method for assessing and comparing variants based on an explicit preference model coming from the elicitation of stakeholders' concerns. This solution allows understanding differences among variants and their satisfactions with respect to criteria. Beyond variant selection automation improvement, this experiment results highlight that the approach improves rationality in the assessment and provides decision arguments when selecting the preferred variants.

- **Using Machine Learning to Infer Constraints for Product Lines.** Paul Temple, José Angel Galindo Duarte, Mathieu Acher, and Jean-Marc Jézéquel. *Software Product Line Conference (SPLC'16)*, 2016. **Most Influential Paper Award at VARIABILITY 2026.** [PDF](https://hal.science/hal-01323446/file/SPLC_2016_Paper.pdf) · [HAL](https://hal.science/hal-01323446) · [DOI](https://doi.org/10.1145/2934466.2934472)
  Abstract: Variability intensive systems may include several thousand features allowing for an enormous number of possible configurations , including wrong ones (e.g. the derived product does not compile). For years, engineers have been using constraints to a priori restrict the space of possible configurations , i.e. to exclude configurations that would violate these constraints. The challenge is to find the set of constraints that would be both precise (allow all correct configurations) and complete (never allow a wrong configuration with respect to some oracle). In this paper, we propose the use of a machine learning approach to infer such product-line constraints from an oracle that is able to assess whether a given product is correct. We propose to randomly generate products from the product line, keeping for each of them its resolution model. Then we classify these products according to the oracle, and use their resolution models to infer cross-tree constraints over the product-line. We validate our approach on a product-line video generator, using a simple computer vision algorithm as an oracle. We show that an interesting set of cross-tree constraint can be generated, with reasonable precision and recall.

- **Exploiting the Enumeration of All Feature Model Configurations: A New Perspective with Distributed Computing.** José A. Galindo, Mathieu Acher, Juan Manuel Tirado, Cristian Vidal, Benoit Baudry, and David Benavides. *Software Product Line Conference (SPLC'16)*, 2016. [PDF](https://hal.science/hal-01334851/file/paper.pdf) · [HAL](https://hal.science/hal-01334851) · [DOI](https://doi.org/10.1145/2934466.2934478) · [Slides](https://www.slideshare.net/acher/exploiting-the-enumeration-of-all-feature-model-configurations-a-new-perspective-with-distributed-computing)
  Abstract: Feature models are widely used to encode the configurations of a software product line in terms of mandatory, optional and exclusive features as well as propositional constraints over the features. Numerous computationally expensive procedures have been developed to model check, test, configure, debug, or compute relevant information of feature models. In this paper we explore the possible improvement of relying on the enumeration of all configurations when performing automated analysis operations. The key idea is to pre-compile configurations so that reasoning operations (queries and transformations) can then be performed in polytime. We tackle the challenge of how to scale the existing enu-meration techniques. We show that the use of distributed computing techniques might offer practical solutions to previously unsolvable problems and opens new perspectives for the automated analysis of software product lines.

- **Featured model types: Towards Systematic Reuse in Modelling Language Engineering.** Gilles Perrouin, Moussa Amrani, Mathieu Acher, Benoit Combemale, Axel Legay, and Pierre-Yves Schobbens. *MiSE '16 - 8th International Workshop on Modeling in Software Engineering*, 2016. [PDF](https://hal.science/hal-01406507/file/c171.pdf) · [HAL](https://hal.science/hal-01406507) · [DOI](https://doi.org/10.1145/2896982.2896987)
  Abstract: By analogy with software product reuse, the ability to reuse (meta)models and model transformations is key to achieve better quality and productivity. To this end, various op-portunistic reuse techniques have been developed, such as higher-order transformations, metamodel adaptation, and model types. However, in contrast to software product development that has moved to systematic reuse by adopting (model-driven) software product lines, we are not quite there yet for modelling languages, missing economies of scope and automation opportunities. Our vision is to transpose the product line paradigm at the metamodel level, where reusable assets are formed by metamodel and transformation fragments and " products " are reusable language building blocks (model types). We introduce featured model types to concisely model variability amongst metamodelling elements, enabling configuration, automated analysis, and derivation of tailored model types.

- **A Complexity Tale: Web Configurators.** Gilles Perrouin, Mathieu Acher, Jean-Marc Davril, Axel Legay, and Patrick Heymans. *VACE 2016 - 1st International Workshop on Variability and Complexity in Software Design Pages (co-located with ICSE'16)*, 2016. [PDF](https://hal.science/hal-01427165/file/VACE16-WebConfigurators.pdf) · [HAL](https://hal.science/hal-01427165) · [DOI](https://doi.org/10.1145/2897045.2897051)
  Abstract: Online configurators are basically everywhere. From physical goods (cars, clothes) to services (cloud solutions, insurances, etc.) such configurators have pervaded many areas of everyday life, in order to provide the customers products tailored to their needs. Being sometimes the only interfaces between product suppliers and consumers, much care has been devoted to the HCI aspects of configurators, aiming at offering an enjoyable buying experience. However, at the backend, the management of numerous and complex configuration options results from ad-hoc process rather than a systematic variability-aware engineering approach. We present our experience in analysing web configurators and formalising configuration options in terms of feature models or product configuration matrices. We also consider behavioural issues and perspectives on their architectural design.

- **Large-scale Analysis of Chess Games with Chess Engines: A Preliminary Report.** Mathieu Acher and François Esnault. *Technical Report RT-0479, Inria Rennes Bretagne Atlantique*, 2016. [PDF](https://hal.science/hal-01307091/file/RT-479%20%281%29.pdf) · [HAL](https://hal.science/hal-01307091)
  Abstract: The strength of chess engines together with the availability of numerous chess games have attracted the attention of chess players, data scientists, and researchers during the last decades. State-of-the-art engines now provide an authoritative judgement that can be used in many applications like cheating detection, intrinsic ratings computation, skill assessment, or the study of human decision-making. A key issue for the research community is to gather a large dataset of chess games together with the judgement of chess engines. Unfortunately the analysis of each move takes lots of times. In this paper, we report our effort to analyse almost 5 millions chess games with a computing grid. During summer 2015, we processed 270 millions unique played positions using the Stockfish engine with a quite high depth (20). We populated a database of 1+ tera-octets of chess evaluations, representing an estimated time of 50 years of computation on a single machine. Our effort is a first step towards the replication of research results, the supply of open data and procedures for exploring new directions, and the investigation of software engineering/scalability issues when computing billions of moves.

- **Software Unbundling: Challenges and Perspectives.** João Bosco Ferreira Filho, Mathieu Acher, and Olivier Barais. *Trans. Modularity and Composition, 1*, 2016. [PDF](https://hal.science/hal-01427560/file/UnbundlingExtension.pdf) · [HAL](https://hal.science/hal-01427560) · [DOI](https://doi.org/10.1007/978-3-319-46969-0_6)
  Abstract: Unbundling is a phenomenon that consists of dividing an existing software artifact into smaller ones. It can happen for different reasons , one of them is the fact that applications tend to grow in func-tionalities and sometimes this can negatively influence the user experience. For example, mobile applications from well-known companies are being divided into simpler and more focused new ones. Despite its current importance, little is known or studied about unbundling or about how it relates to existing software engineering approaches, such as modularization. Consequently, recent cases point out that it has been performed unsystematically and arbitrarily. In this article, our main goal is to present this novel and relevant concept and its underlying challenges in the light of software engineering, also exemplifying it with recent cases. We relate un-bundling to standard software modularization, presenting the new motivations behind it, the resulting problems, and drawing perspectives for future support in the area.

- **Fourth international workshop on reverse variability engineering (REVE 2016).** Roberto Erick Lopez-Herrejon, Jabier Martinez, Tewfik Ziadi, and Mathieu Acher. *Proceedings of the 20th International Systems and Software Product Line Conference, SPLC 2016, Beijing, China, September 16-23, 2016*, 2016. [DOI](https://doi.org/10.1145/2934466.2962734)
  Abstract: From organizational issues to purely technical challenges, there is a wide range of barriers that complicates Software Product Line (SPL) adoption. This workshop aims to foster research about making the most of two main inputs for SPL migration: 1) domain knowledge and 2) existing legacy assets. Domain knowledge, usually implicit and spread across an organization, is key to define the SPL scope and to validate the variability model and its semantics. At the technical level, domain expertise is also needed to create reusable software components. Regarding legacy assets, they use to be similar product variants (e.g. requirements, models, source code etc.) that were implemented using ad-hoc reuse techniques such as clone-and-own. These assets can be leveraged in extractive SPL adoption processes. The workshop REverse Variability Engineering (REVE) attracts researchers and practitioners contributing processes, techniques, tools, or empirical studies related to the automatic, semi-automatic or manual extraction or refinement of SPL assets.

- **A Formal Modeling and Analysis Framework for Software Product Line of Preemptive Real-Time Systems.** Jin Hyung Kim, Axel Legay, Louis-Marie Traonouez, Mathieu Acher, and Sungwon Kang. *Symposium on Applied Computing (SAC'16), software engineering track*, 2016. [PDF](https://hal.science/hal-01241673v2/file/main.pdf) · [HAL](https://hal.science/hal-01241673) · [DOI](https://doi.org/10.1145/2851613.2851977)
  Abstract: Adapting real-time embedded software for various variants of an application and usage contexts is highly demanded. However, the question of how to analyze real-time properties for a family of products (rather than for a single one) has not drawn much attention from researchers. In this paper , we present a formal analysis framework to analyze a family of platform products w.r.t. real-time properties. To this end, we rst propose an extension of the widely-used feature model, called Property Feature Model (PFM), that distinguishes features and properties explicitly, so that the scope of properties restricted to features can be explicitly dened. Then we present formal behavioral models of components of a real-time scheduling unit, i.e. tasks, resources, and resource schedulers, such that all real-time scheduling units implied by a PFM are automatically composed with the components to be analyzed against the properties given by the PFM. We apply our approach to the verication of the schedulability of a family of scheduling units using the symbolic and statistical model checkers of Uppaal.

- **Breathing Ontological Knowledge Into Feature Model Synthesis: An Empirical Study.** Guillaume Bécan, Mathieu Acher, Benoit Baudry, and Sana Ben Nasr. *Empirical Software Engineering (ESE), 21(4)*, 2016. [PDF](https://inria.hal.science/hal-01096969v1/file/ESE-KSynthesis.pdf) · [HAL](https://hal.science/hal-01096969) · [DOI](https://doi.org/10.1007/s10664-014-9357-1)
  Abstract: Feature Models (FMs) are a popular formalism for modeling and reasoning about the configurations of a software product line. As the manual construction of an FM is time-consuming and error-prone, management operations have been developed for reverse engineering, merging, slicing, or refactoring FMs from a set of configurations/dependencies. Yet the synthesis of meaningless ontological relations in the FM – as defined by its feature hierarchy and feature groups – may arise and cause severe difficulties when reading, maintaining or exploiting it. Numerous synthesis techniques and tools have been proposed, but only a few consider both configuration and ontolog-ical semantics of an FM. There are also few empirical studies investigating ontological aspects when synthesizing FMs. In this article, we define a generic, ontologic-aware synthesis procedure that computes the likely siblings or parent candidates for a given feature. We develop six heuristics for clustering and weighting the logical, syntactical and semantical relationships between feature names. We then perform an empirical evaluation on hundreds of FMs, coming from the SPLOT repository and Wikipedia. We provide evidence that a fully automated synthesis (i.e., without any user intervention) is likely to produce FMs far from the ground truths. As the role of the user is crucial, we empirically analyze the strengths and weak-nesses of heuristics for computing ranking lists and different kinds of clusters. We show that a hybrid approach mixing logical and ontological techniques outperforms state-of-the-art solutions. We believe our approach, environment, and empirical results support researchers and practitioners working on reverse engineering and management of FMs.

## 2015

- **On Breaking the Curse of Dimensionality in Reverse Engineering Feature Models.** Jean-Marc Davril, Mathieu Acher, Guillaume Bécan, and Patrick Heymans. *17th International Configuration Workshop (ConfWS'15)*, 2015. [PDF](https://inria.hal.science/hal-01243571v1/file/ecai2015.pdf) · [HAL](https://hal.science/hal-01243571) · [Link](https://ceur-ws.org/Vol-1453/)
  Abstract: Feature models have become one of the most widely used formalism for representing the variability among the products of a product line. The design of a feature model from a set of existing products can help stakeholders communicate on the commonalities and differences between the products, facilitate the adoption of mass customization strategies, or provide foundations for engineering product configurators. As the manual construction of feature models proves to be a time-consuming and error prone task, researchers have proposed various approaches for automatically deriving feature models from available product data. Existing techniques mostly rely on data mining algorithms that search for frequently occurring patterns between the features included in product configurations. However, when the number of features is too large, the sparsity among the configurations can reduce the quality of the extracted model. In this paper, we discuss motivations for the development of dimensionality reduction techniques for product lines in order to support the extraction of feature models in the case of high-dimensional product spaces. We use a real world dataset to illustrate the problems arising with high dimensionality and present four research questions to address these problems.

- **Using fuzzy modeling for consistent definitions of product qualities in requirements.** Jean-Marc Davril, Maxime Cordy, Patrick Heymans, and Mathieu Acher. *IEEE Second International Workshop on Artificial Intelligence for Requirements Engineering (AIRE'15)*, 2015. [PDF](https://inria.hal.science/hal-01243006v1/file/aire15.pdf) · [HAL](https://hal.science/hal-01243006) · [DOI](https://doi.org/10.1109/AIRE.2015.7337624)
  Abstract: Companies increasingly rely on product differentiation and personalization strategies to provide their customers with an expansive catalog, and tools to assist them in finding the product meeting their needs. These tools include product search facilities, recommender systems, and product configurators. They typically represent a product as a set of features, which refer to a large number of technical specifications (e.g. size, weight, battery life). However, customers usually communicate and reason about products in terms of their qualities (e.g. ease-of-use, portability, ergonomics). In this paper, we tackle the problem of formalizing product qualities in the requirements of product-centred applications. Our goal is to extract product qualities from their technical features, so that customers can better perceive and evaluate the proposed products. To this end, we design a procedure for identifying segments of textual product documentation related to specific product qualities, and propose an approach based on fuzzy modeling to represent product qualities on top of technical specifications. Preliminary experiments we carried out on a catalog of cameras tend to show that fuzzy modeling is an appropriate formalism for representing product qualities. We also illustrate how modeled qualities can support the design of product configurators that are centered on the customers' needs.

- **ATSyRa: An Integrated Environment for Synthesizing Attack Trees.** Sophie Pinchinat, Mathieu Acher, and Didier Vojtisek. *Second International Workshop on Graphical Models for Security (GraMSec'15) co-located with CSF'15*, 2015. [PDF](https://inria.hal.science/hal-01243021v1/file/paper_3%20%282%29.pdf) · [HAL](https://hal.science/hal-01243021)
  Abstract: Attack trees are widely considered in the fields of security for the analysis of risks (or threats) against electronics, computer control, or physical systems. A major barrier is that attack trees can become largely complex and thus hard to specify. This paper presents ATSyRA, a tooling environment to automatically synthesize attack trees of a system under study. ATSyRA provides advanced editors to specify high-level descriptions of a system, high-level actions to structure the tree, and ways to interactively refine the synthesis. We illustrate how users can specify a military building, abstract and organize attacks, and eventually obtain a readable attack tree.

- **Synthesis of Attributed Feature Models From Product Descriptions.** Guillaume Bécan, Razieh Behjati, Arnaud Gotlieb, and Mathieu Acher. *19th International Software Product Line Conference (SPLC'15)*, 2015. [PDF](https://inria.hal.science/hal-01178454v1/file/SPLC15-AFM.pdf) · [HAL](https://hal.science/hal-01178454) · [DOI](https://doi.org/10.1145/2791060.2791068) · [Slides](https://fr.slideshare.net/acher/synthesis-of-attributed-feature-models-from-product-descriptions)
  Abstract: Many real-world product lines are only represented as non-hierarchical collections of distinct products, described by their configuration values. As the manual preparation of feature models is a tedious and labour-intensive activity, some techniques have been proposed to automatically generate boolean feature models from product descriptions. However, none of these techniques is capable of synthesizing feature attributes and relations among attributes, despite the huge relevance of attributes for documenting software product lines. In this paper, we introduce for the first time an algorithmic and parametrizable approach for computing a legal and appropriate hierarchy of features, including feature groups, typed feature attributes, domain values and relations among these attributes. We have performed an empirical evaluation by using both randomized configuration matrices and real-world examples. The initial results of our evaluation show that our approach can scale up to matrices containing 2,000 attributed features, and 200,000 distinct configurations in a couple of minutes.

- **Assessing Product Line Derivation Operators Applied to Java Source Code: An Empirical Study.** João Bosco Ferreira Filho, Simon Allier, Mathieu Acher, Olivier Barais, and Benoit Baudry. *19th International Software Product Line Conference (SPLC'15)*, 2015. [PDF](https://inria.hal.science/hal-01163423v1/file/VaryJavaSPLC2015.pdf) · [HAL](https://hal.science/hal-01163423) · [DOI](https://doi.org/10.1145/2791060.2791099) · [Slides](https://fr.slideshare.net/acher/assessing-product-line-derivation-operators-applied-to-java-source-code-an-empirical-study)
  Abstract: Product Derivation is a key activity in Software Product Line Engineering. During this process, derivation operators modify or create core assets (e.g., model elements, source code instructions, components) by adding, removing or substituting them according to a given configuration. The result is a derived product that generally needs to conform to a programming or modeling language. Some operators lead to invalid products when applied to certain assets, some others do not; knowing this in advance can help to better use them, however this is challenging, specially if we consider assets expressed in extensive and complex languages such as Java. In this paper, we empirically answer the following question: which product line operators, applied to which program elements, can synthesize variants of programs that are incorrect, correct or perhaps even conforming to test suites? We implement source code transformations, based on the derivation operators of the Common Variability Language. We automatically synthesize more than 370,000 program variants from a set of 8 real large Java projects (up to 85,000 lines of code), obtaining an extensive panorama of the sanity of the operations.

- **Tooling Support for Variability and Architectural Patterns in Systems Engineering.** Thomas Degueule, João Bosco Ferreira Filho, Olivier Barais, Mathieu Acher, Jérôme Lenoir, Olivier Constant, Sebastien Madelenat, Gregory Gailliard, and Godefroy Burlot. *19th International Software Product Line Conference (SPLC'15)*, 2015. [PDF](https://inria.hal.science/hal-01242180v1/file/SPLC2015-kCVLPatternsTool.pdf) · [HAL](https://hal.science/hal-01242180) · [DOI](https://doi.org/10.1145/2791060.2791097)
  Abstract: In systems engineering, the deployment of software components is error-prone since numerous safety and security rules have to be preserved. Another related problem is that numerous variants of deployments on different platforms are possible. In this paper we present a technological solution to assist industrial practitioners in producing a safe and secure solution out of numerous architectural variants. First, we introduce a pattern technology that provides correct-by-construction deployment models through the reuse of modeling artefacts organized in a catalog. Second, we develop a variability solution, connected to the pattern technology and based on an extension of the common variability language, for supporting the synthesis of model-based architectural variants. This paper describes a live demonstration of an industrial effort seeking to bridge the gap between variability modeling and system engineering practices. We illustrate the tooling support with an industrial case study (a secure radio platform).

- **SPLTea 2015: Second International Workshop on Software Product Line Teaching.** Mathieu Acher, Roberto Erick Lopez-Herrejon, and Rick Rabiser. *19th International Software Product Line Conference (SPLC'15)*, 2015. [PDF](https://inria.hal.science/hal-01243213v1/file/spltea_summaryHAL.pdf) · [HAL](https://hal.science/hal-01243213) · [DOI](https://doi.org/10.1145/2791060.2791063)
  Abstract: Education has a key role to play for disseminating the constantly growing body of Software Product Line (SPL) knowledge. Teaching SPLs is challenging; it is unclear, for example, how SPLs can be taught and what is the material available. This workshop aims to explore and explain the current status and ongoing work on teaching SPLs at universities, colleges, and in industry (e.g., by consultants). This second edition will continue the effort made at SPLTea'14. In particular we seek to design and populate an open repository of resources dedicated to SPL teaching. See also http://teaching.variability.io

- **Challenges on Software Unbundling: Growing and Letting Go.** João Bosco Ferreira Filho, Mathieu Acher, and Olivier Barais. *14th International Conference on Modularity'15*, 2015. [PDF](https://inria.hal.science/hal-01116694v1/file/unbundling.pdf) · [HAL](https://hal.science/hal-01116694) · [DOI](https://doi.org/10.1145/2735386.2735390)
  Abstract: Unbundling is a phenomenon that consists of dividing an existing software artifact into smaller ones. For example, mobile applications from well-known companies are being divided into simpler and more focused new ones. Despite its current importance, little is known or studied about unbundling or about how it relates to existing software engineering approaches, such as modularization. Consequently, recent cases points out that it has been performed unsystematically and arbitrarily. In this paper, our main goal is to present this novel and relevant concept and its challenges in the light of software engineering, exemplifying it with recent cases. We relate unbundling to standard software modularization, presenting the new motivations behind it, the resulting problems, and drawing perspectives for future support in the area.

- **Synthesis of Attributed Feature Models From Product Descriptions: Foundations.** Guillaume Bécan, Razieh Behjati, Arnaud Gotlieb, and Mathieu Acher. *Rapport de Recherche RR-8680, Inria Rennes*, 2015. [PDF](https://inria.hal.science/hal-01116663v1/file/RR-8680.pdf) · [HAL](https://hal.science/hal-01116663)
  Abstract: Feature modeling is a widely used formalism to characterize a set of products (also called configurations). As a manual elaboration is a long and arduous task, numerous techniques have been proposed to reverse engineer feature models from various kinds of artefacts. But none of them synthesize feature attributes (or constraints over attributes) despite the practical relevance of attributes for documenting the different values across a range of products. In this report, we develop an algorithm for synthesizing attributed feature models given a set of product descriptions. We present sound, complete, and parametrizable techniques for computing all possible hierarchies, feature groups, placements of feature attributes, domain values, and constraints. We perform a complexity analysis w.r.t. number of features, attributes, configurations, and domain size. We also evaluate the scalability of our synthesis procedure using randomized configuration matrices. This report is a first step that aims to describe the foundations for synthesizing attributed feature models.

- **On the Variability Secrets of an Online Video Generator.** Guillaume Bécan, Mathieu Acher, Jean-Marc Jézéquel, and Thomas Menguy. *Variability Modelling of Software-intensive Systems (VaMoS'15)*, 2015. [PDF](https://inria.hal.science/hal-01104797v1/file/vamos15-bref.pdf) · [HAL](https://hal.science/hal-01104797) · [DOI](https://doi.org/10.1145/2701319.2701328)
  Abstract: We relate an original experience concerning a popular online video service that offers to generate variants of an humorous video. To further the understanding of the generator, we have reverse engineered its general behavior, architecture, as well as its variation points and its configuration space. The reverse engineering also allows us to create a new generator and online configurator that proposes 18 variation points – instead of only 3 as in the original generator. We explain why and how we have collaborated and are collaborating with the original creators of the video generator. We also highlight how our reverse engineering work represents a threat to the original service and call for further investigating variability-aware security mechanisms.

- **MatrixMiner: a red pill to architect informal product descriptions in the matrix.** Sana Ben Nasr, Guillaume Bécan, Mathieu Acher, Joao Bosco Ferreira Filho, Benoit Baudry, Nicolas Sannier, and Jean-Marc Davril. *Proceedings of the 2015 10th Joint Meeting on Foundations of Software Engineering, (ESEC/FSE'15)*, 2015. [PDF](https://inria.hal.science/hal-01234338v1/file/MatrixMiner.pdf) · [HAL](https://hal.science/hal-01234338) · [DOI](https://doi.org/10.1145/2786805.2803180)
  Abstract: Domain analysts, product managers, or customers aim to capture the important features and differences among a set of related products. A case-by-case reviewing of each product description is a laborious and time-consuming task that fails to deliver a condensed view of a product line. This paper introduces MatrixMiner: a tool for automatically synthesizing product comparison matrices (PCMs) from a set of product descriptions written in natural language. MatrixMiner is capable of identifying and organizing features and values in a PCM – despite the informality and absence of structure in the textual descriptions of products. Our empirical results of products mined from BestBuy show that the synthesized PCMs exhibit numerous quantitative, comparable information. Users can exploit MatrixMiner to visualize the matrix through a Web editor and review, refine, or complement the cell values thanks to the traceability with the original product descriptions and technical specifications.

- **Product lines can jeopardize their trade secrets.** Mathieu Acher, Guillaume Bécan, Benoit Combemale, Benoit Baudry, and Jean-Marc Jézéquel. *Proceedings of the 2015 10th Joint Meeting on Foundations of Software Engineering (ESEC/FSE'15)*, 2015. [PDF](https://inria.hal.science/hal-01234342v1/file/fse15nier-nierid35-p-3ebab97-24933-preprint.pdf) · [HAL](https://hal.science/hal-01234342) · [DOI](https://doi.org/10.1145/2786805.2803210) · [Slides](https://fr.slideshare.net/gbecan/product-lines-can-jeopardize-their-trade-secrets)
  Abstract: What do you give for free to your competitor when you exhibit a product line? This paper addresses this question through several cases in which the discovery of trade secrets of a product line is possible and can lead to severe consequences. That is, we show that an outsider can understand the variability realization and gain either confidential business information or even some economical direct advantage. For instance, an attacker can identify hidden constraints and bypass the product line to get access to features or copyrighted data. This paper warns against possible naive modeling, implementation, and testing of variability leading to the existence of product lines that jeopardize their trade secrets. Our vision is that defensive methods and techniques should be developed to protect specifically variability – or at least further complicate the task of reverse engineering it.

- **Third International Workshop on Reverse Variability Engineering (REVE 2015).** Roberto E. Lopez-Herrejon, Tewfik Ziadi, Jabier Martinez, Anil Kumar Thurimella, and Mathieu Acher. *Proceedings of the 19th International Conference on Software Product Line, SPLC 2015, Nashville, TN, USA, July 20-24, 2015*, 2015. [HAL](https://hal.science/hal-01213538) · [DOI](https://doi.org/10.1145/2791060.2791062)
  Abstract: Variability management of a product family is the core aspect of Software Product Line Engineering. The adoption of this mature approach requires a high upfront investment before being able to automatically generate product instances based on customer requirements. However, this adoption costs and risks could be reduced with an incremental approach, which mines existing assets and then transitions to full product line engineering. Those existing assets can be for instance similar product variants that were implemented using ad-hoc reuse techniques such as clone-and-own. Hence, there is a great need of bottom-up approaches that extract variability from the artifacts (across all the life cycle) of the legacy product variants and manage the consolidated variability. The REVE workshop series aims to bring together the Reengineering and Software Product Line Engineering communities to address this gap.

- **Talk at Third International Workshop on Reverse Variability Engineering (REVE'15).** Mathieu Acher. *Proceedings of the 19th International Conference on Software Product Line (SPLC'15)*, 2015. [Slides](https://fr.slideshare.net/acher/from-basic-variability-models-to-opencompareorg)
  Abstract: Variability is omnipresent in numerous kinds of artefacts (e.g., source code, product matrices) and in different shapes (e.g., conditional compilation, differences among product descriptions). For understanding, reasoning about, maintaining or evolving variability, practitioners usually need an explicit encoding of variability (ie a variability model). As a result, numerous techniques have been developed to reverse engineer variability (e.g., through the mining of features and constraints from source code) or for migrating a set of products as a variability system. In this talk we will first present tool-supported techniques for synthesizing variability models from constraints or product descriptions. Practitioners can build Boolean feature models with an interactive environment for selecting a meaningful and sound hierarchy. Attributes can also be synthesized for encoding numerical values and constraints among them. We will present key results we obtain through experiments with the SPLOT repository and product comparison matrices coming from Wikipedia and BestBuy. Finally we will introduce OpenCompare.org a recent initiative for editing, reasoning, and mining product comparison matrices. This talk has been done at REVE'15 workshop co-located with SPLC'15 (software product line conference): http://www.isse.jku.at/reve2015/program.html

## 2014

- **Metamorphic Domain-Specific Languages: A Journey Into the Shapes of a Language.** Mathieu Acher, Benoit Combemale, and Philippe Collet. *Onward! Essays (co-located with SPLASH and OOPSLA)*, 2014. [PDF](https://inria.hal.science/hal-01061576v1/file/onwd1446-acher.pdf) · [HAL](https://hal.science/hal-01061576) · [DOI](https://doi.org/10.1145/2661136.2661159) · [arXiv](https://arxiv.org/abs/1404.6838) · [Slides](https://fr.slideshare.net/acher/metamorphic-domainspecific-languages)
  Abstract: External or internal domain-specific languages (DSLs) or (fluent) APIs? Whoever you are – a developer or a user of a DSL – you usually have to choose side; you should not! What about metamorphic DSLs that change their shape according to your needs? Our 4-years journey of providing the "right" support (in the domain of feature modeling), led us to develop an external DSL, different shapes of an internal API, and maintain all these languages. A key insight is that there is no one-size-fits-all solution or no clear superiority of a solution compared to another. On the contrary, we found that it does make sense to continue the maintenance of an external and internal DSL. Based on our experience and on an analysis of the DSL engineering field, the vision that we foresee for the future of software languages is their ability to be self-adaptable to the most appropriate shape (including the corresponding integrated development environment) according to a particular usage or task. We call metamorphic DSL such a language, able to change from one shape to another shape.

- **Towards Synthesis of Attack Trees for Supporting Computer-Aided Risk Analysis.** Sophie Pinchinat, Mathieu Acher, and Didier Vojtisek. *Workshop on Formal Methods in the Development of Software (co-located with SEFM)*, 2014. [PDF](https://inria.hal.science/hal-01064645v1/file/SEFM-FMDS.pdf) · [HAL](https://hal.science/hal-01064645) · [DOI](https://doi.org/10.1007/978-3-319-15201-1_24)
  Abstract: Attack trees are widely used in the fields of defense for the analysis of risks (or threats) against electronics systems, computer control systems or physical systems. Based on the analysis of attack trees, practitioners can define actions to engage in order to reduce or annihilate risks. A major barrier to support computer-aided risk analysis is that attack trees can become largely complex and thus hard to specify. This paper is a first step towards a methodology, formal foundations as well as automated techniques to synthesize attack trees from a high-level description of a system. Attacks are expressed as a succession of elementary actions and high-level actions can be used to abstract and organize attacks into exploitable attack trees. We describe our tooling support and identify open challenges for supporting the analysis of risks.

- **Automating the Formalization of Product Comparison Matrices.** Guillaume Bécan, Nicolas Sannier, Mathieu Acher, Olivier Barais, Arnaud Blouin, and Benoit Baudry. *29th IEEE/ACM International Conference on Automated Software Engineering (ASE'14)*, 2014. [PDF](https://inria.hal.science/hal-01058440v1/file/FromData2Models.pdf) · [HAL](https://hal.science/hal-01058440) · [DOI](https://doi.org/10.1145/2642937.2643000) · [Slides](https://fr.slideshare.net/gbecan/ase2014-presentation)
  Abstract: Product Comparison Matrices (PCMs) form a rich source of data for comparing a set of related and competing products over numerous features. Despite their apparent simplicity, PCMs contain heterogeneous, ambiguous, uncontrolled and partial information that hinders their efficient exploitations. In this paper, we formalize PCMs through model-based automated techniques and develop additional tooling to support the edition and re-engineering of PCMs. 20 participants used our editor to evaluate the PCM metamodel and automated transformations. The results over 75 PCMs from Wikipedia show that (1) a significant proportion of the formalization of PCMs can be automated - 93.11% of the 30061 cells are correctly formalized; (2) the rest of the formalization can be realized by using the editor and mapping cells to existing concepts of the metamodel. The automated approach opens avenues for engaging a community in the mining, re-engineering, edition, and exploitation of PCMs that now abound on the Internet.

- **Automating Variability Model Inference for Component-Based Language Implementations.** Edoardo Vacchi, Walter Cazzola, Benoit Combemale, and Mathieu Acher. *18th International Software Product Line Conference (SPLC'14)*, 2014. [PDF](https://inria.hal.science/hal-01023864v1/file/splc14-camera.pdf) · [HAL](https://hal.science/hal-01023864) · [DOI](https://doi.org/10.1145/2648511.2648529)
  Abstract: Recently, domain-specific language development has become again a topic of interest, as a means to help designing solutions to domain-specific problems. Componentized language frameworks, coupled with variability modeling, have the potential to bring language development to the masses, by simplifying the configuration of a new language from an existing set of reusable components. However, designing variability models for this purpose requires not only a good understanding of these frameworks and the way components interact, but also an adequate familiarity with the problem domain. In this paper we propose an approach to automatically infer a relevant variability model from a collection of already implemented language components, given a structured, but general representation of the domain. We describe techniques to assist users in achieving a better understanding of the relationships between language components, and find out which languages can be derived from them with respect to the given domain.

- **An Approach to Derive Usage Models Variants for Model-based Testing.** Hamza Samih, Hélène Le Guen, Ralf Bogusch, Mathieu Acher, and Benoit Baudry. *26th IFIP International Conference on Testing Software and Systems (ICTSS'2014)*, 2014. [PDF](https://inria.hal.science/hal-01025124v2/file/978-3-662-44857-1_6_Chapter.pdf) · [HAL](https://hal.science/hal-01025124) · [DOI](https://doi.org/10.1007/978-3-662-44857-1_6)
  Abstract: Testing techniques in industry are not yet adapted for product line engineering (PLE). In particular, Model-based Testing (MBT), a technique that allows to automatically generate test cases from requirements, lacks support for managing variability (differences) among a set of related product. In this paper, we present an approach to equip usage models, a widely used formalism in MBT, with variability capabilities. Formal correspondences are established between a variability model, a set of functional requirements, and a usage model. An algorithm then exploits the traceability links to automatically derive a usage model variant from a desired set of selected features. The approach is integrated into the professional MBT tool MaTeLo and is currently used in industry.

- **WebFML: Synthesizing Feature Models Everywhere.** Guillaume Bécan, Sana Ben Nasr, Mathieu Acher, and Benoit Baudry. *18th International Software Product Line Conference (SPLC'14), tool track*, 2014. [PDF](https://inria.hal.science/hal-01022912v1/file/SPLC2014-WebFML.pdf) · [HAL](https://hal.science/hal-01022912) · [DOI](https://doi.org/10.1145/2647908.2655974) · [Slides](https://fr.slideshare.net/acher/webfml-synthesizing-feature-models-everywhere-splc-2014)
  Abstract: Feature Models (FMs) are the de-facto standard for documenting, model checking, and reasoning about the configurations of a software system. This paper introduces WebFML a comprehensive environment for synthesizing FMs from various kinds of artefacts (e.g. propositional formula, dependency graph, FMs or product comparison matrices). A key feature of WebFML is an interactive support (through ranking lists, clusters, and logical heuristics) for choosing a sound and meaningful hierarchy. WebFML opens avenues for numerous practical applications (e.g., merging multiple product lines, slicing a configuration process, reverse engineering configurable systems).

- **Deriving Usage Model Variants for Model-based Testing: An Industrial Case Study.** Hamza Samih, Mathieu Acher, Ralf Bogusch, Hélène Le Guen, and Benoit Baudry. *19th International Conference on Engineering of Complex Computer Systems (ICECCS'14)*, 2014. [PDF](https://inria.hal.science/hal-01002099v1/file/Deriving_Usage_Model_Variants_for_Model_based_Testing_An_Industrial_Case_Study.pdf) · [HAL](https://hal.science/hal-01002099) · [DOI](https://doi.org/10.1109/iceccs.2014.19)
  Abstract: The strong cost pressure of the market and safety issues faced by aerospace industry affect the development. Suppliers are forced to continuously optimize their life-cycle processes to facilitate the development of variants for different customers and shorten time to market. Additionally, industrial safety standards like RTCA/DO-178C require high efforts for testing single products. A suitably organized test process for Product Lines (PL) can meet standards. In this paper, we propose an approach that adopts Model-based Testing (MBT) for PL. Usage models, a widely used MBT formalism that provides automatic test case generation capabilities, are equipped with variability information such that usage model variants can be derived for a given set of features. The approach is integrated in the professional MBT tool MaTeLo. We report on our experience gained from an industrial case study in the aerospace domain.

- **Modeling Variability in the Video Domain: Language and Experience Report.** Mauricio Alférez, José A. Galindo, Mathieu Acher, and Benoit Baudry. *Rapport de Recherche RR-8576, INRIA*, 2014. [PDF](https://inria.hal.science/hal-01023159v2/file/RR-8576.pdf) · [HAL](https://hal.science/hal-01023159)
  Abstract: This paper reports about a new domain-specific variability modeling language, called VM, resulting from the close collaboration with industrial partners in the video domain. We expose the requirements and advanced variability constructs required to characterize and realize variations of physical properties of a video (such as objects' speed or scene illumination). The results of our experiments and industrial experience show that VM is effective to model complex variability information and can be exploited to synthesize video variants. We concluded that basic variability mechanisms are useful but not enough, attributes and multi-features are of prior importance, and meta-information is relevant for efficient variability analysis. In addition, we questioned the existence of one-size-fits-all variability modeling solution applicable in any industry. Yet, some common needs for modeling variability are becoming apparent such as support for attributes and multi-features.

- **Generating Counterexamples of Model-based Software Product Lines.** Joao Bosco Ferreira Filho, Olivier Barais, Mathieu Acher, Jérôme Le Noir, Axel Legay, and Benoit Baudry. *International Journal on Software Tools for Technology Transfer (STTT), 17(5)*, 2014. [PDF](https://inria.hal.science/hal-01026581v1/file/STTT2014.pdf) · [HAL](https://hal.science/hal-01026581) · [DOI](https://doi.org/10.1007/s10009-014-0341-2)
  Abstract: In a Model-based Software Product Line (MSPL), the variability of the domain is characterized in a variability model and the core artifacts are base models conforming to a modeling language (also called metamodel). A realization model connects the features of the variability model to the base model elements, triggering operations over these elements based on a configuration. The design space of an MSPL is extremely complex to manage for the engineer, since the number of variants may be exponential and the derived product models have to be conforming to numerous well-formedness and business rules. In this paper, the objective is to provide a way to generate MSPLs, called counterexamples (also called anti-patterns), that can produce invalid product models despite a valid configuration in the variability model. We describe the foundations and motivate the usefulness of counterexamples (e.g., inference of guidelines or domain-specific rules to avoid earlier the specification of incorrect mappings; testing oracles for increasing the robustness of derivation engines given a modeling language). We provide a generic process, based on the Common Variability Language (CVL) to randomly search the space of MSPLs for a specific modelling language. We develop LineGen a tool on top of CVL and modeling technologies to support the methodology and the process. LineGen targets different scenarios and is flexible to work either with just a domain metamodel as input or also with pre-defined variability models and base models. We validate the effectiveness of this process for three formalisms at different scales (up to 247 metaclasses and 684 rules). We also apply the approach in the context of a real industrial scenario involving a large-scale metamodel.

- **Customization and 3D Printing: A Challenging Playground for Software Product Lines.** Mathieu Acher, Benoit Baudry, Olivier Barais, and Jean-Marc Jézéquel. *18th International Software Product Line Conference (SPLC'14), research track*, 2014. [PDF](https://inria.hal.science/hal-01018937v1/file/SPLC2014-3DPrinting.pdf) · [HAL](https://hal.science/hal-01018937) · [DOI](https://doi.org/10.1145/2648511.2648526) · [Slides](https://fr.slideshare.net/acher/3d-printing-customization-and-product-lines)
  Abstract: 3D printing is gaining more and more momentum to build customized product in a wide variety of fields. We conduct an exploratory study of Thingiverse, the most popular Website for sharing user-created 3D design files, in order to establish a possible connection with software product line (SPL) engineering. We report on the socio-technical aspects and current practices for modeling variability, implementing variability, configuring and deriving products, and reusing artefacts. We provide hints that SPL-alike techniques are practically used in 3D printing and thus relevant. Finally, we discuss why the customization in the 3D printing field represents a challenging playground for SPL engineering.

- **Towards Managing Variability in the Safety Design of an Automotive Hall Effect Sensor.** Dimitri Van Landuyt, Steven Op De Beeck, Aram Hovsepyan, Sam Michiels, Wouter Joosen, Sven Meynckens, Gjalt De Jong, Olivier Barais, and Mathieu Acher. *18th International Software Product Line Conference (SPLC'14), industrial track*, 2014. [PDF](https://inria.hal.science/hal-01018938v1/file/splc.pdf) · [HAL](https://hal.science/hal-01018938) · [DOI](https://doi.org/10.1145/2648511.2648546)
  Abstract: This paper discusses the merits and challenges of adopting software product line engineering (SPLE) as the main development process for an automotive Hall Effect sensor. This versatile component is integrated into a number of automotive applications with varying safety requirements (e.g., windshield wipers and brake pedals). This paper provides a detailed explanation as to why the process of safety assessment and verification of the Hall Effect sensor is currently cumbersome and repetitive:ĩt must be repeated entirely for every automotive application in which the sensor is to be used. In addition, no support is given to the engineer to select and configure the appropriate safety solutions and to explain the safety implications of his decisions. To address these problems, we present a tailored SPLE-based approach that combines model-driven development with advanced model composition techniques for applying and reasoning about specific safety solutions. In addition, we provide insights about how this approach can reduce the overall complexity, improve reusability, and facilitate safety assessment of the Hall Effect sensor.

- **Moving Toward Product Line Engineering in a Nuclear Industry Consortium.** Sana Ben Nasr, Nicolas Sannier, Mathieu Acher, and Benoit Baudry. *18th International Software Product Line Conference (SPLC'2014), industrial track*, 2014. [PDF](https://inria.hal.science/hal-01019537v1/file/Ben-Nasr_Sannier_Acher_Baudry_Moving_toward_PLE_in_nuclear_industry.pdf) · [HAL](https://hal.science/hal-01019537) · [DOI](https://doi.org/10.1145/2648511.2648545)
  Abstract: Nuclear power plants are some of the most sophisticated and complex energy systems ever designed. These systems perform safety critical functions and must conform to national safety institutions and international regulations. In many cases, regulatory documents provide very high level and ambiguous requirements that leave a large margin for interpretation. As the French nuclear industry is now seeking to spread its activities outside France, it is but necessary to master the ins and the outs of the variability between countries safety culture and regulations. This sets both an industrial and a scientific challenge to introduce and propose a product line engineering approach to an unaware industry whose safety culture is made of interpretations, specificities, and exceptions. This paper presents our current work within the French R&D project CONNEXION, while introducing variability modeling to the French nuclear industry. In particular, we discuss the background, the quest for the best variability paradigm, the practical modeling of requirements variability as well as the mapping between variable requirements and variable architecture elements.

- **SPLTea 2014: First International Workshop on Software Product Line Teaching.** Mathieu Acher, Roberto Erick Lopez-Herrejon, and Rick Rabiser. *18th International Software Product Line Conference (SPLC'14)*, 2014. [PDF](https://inria.hal.science/hal-01024990v1/file/spltea_summary.pdf) · [HAL](https://hal.science/hal-01024990) · [DOI](https://doi.org/10.1145/2648511.2648551)
  Abstract: Education has a key role to play for disseminating the constantly growing body of Software Product Line (SPL) knowledge. Teaching SPLs is challenging and it is unclear how SPLs can be taught, what are the possible benefits, or what is the material available. This workshop aims to explore and explain the current status and ongoing work on teaching SPLs at universities, colleges, and in industry (e.g., by consultants). Participants will discuss gaps and difficulties faced when teaching SPLs, benefits to research and industry, different ways to teach SPL knowledge, common threads, interests, and problems. The overall goal is to strengthen the important aspect of teaching in the SPL community.

- **Software Diversity: Challenges to handle the imposed, Opportunities to harness the chosen.** Mathieu Acher, Olivier Barais, Benoit Baudry, Arnaud Blouin, Johann Bourcier, Benoit Combemale, Jean-Marc Jézéquel, and Noël Plouzeau. *GDR GPL*, 2014. [PDF](https://inria.hal.science/hal-00980126v1/file/GDR-challenge.pdf) · [HAL](https://hal.science/hal-00980126)
  Abstract: Diversity emerges as a critical concern that spans all activities in software engineering (from design to verification, from deployment to runtime resilience) and appears in all sorts of domains, which rely on software intensive systems, from systems of systems to pervasive combinations of Internet of Things and Internet of Services. If these domains are apparently radically different, we envision a strong convergence of the scientific principles underpinning their construction and validation towards flexible and open yet dependable systems. In this paper, we discuss the software engineering challenges raised by these requirements for flexibility and openness, focusing on four dimensions of diversity: the diversity of functionalities required by the different customers; the diversity of languages used by the stakeholders involved in the construction of these systems; the diversity of runtime environments in which software has to run and adapt; the diversity of failures against which the system must be able to react. In particular, we want to emphasize the challenges for handling imposed diversity, as well as the opportunities to leverage chosen diversity. The main challenge is that software diversity imposes to integrate the fact that software must adapt to changes in the requirements and environment – in all development phases and in unpredictable ways. Yet, exploiting and increasing software diversity is a great opportunity to allow the spontaneous exploration of alternative software solutions and proactively prepare for unforeseen changes. Concretely, we want to provide software engineers with the ability: to characterize an 'envelope' of possible variations; to compose 'envelopes' (to discover new macro envelopes in an opportunistic manner); to dynamically synthesize software inside a given envelop.

- **Sound Merging and Differencing for Class Diagrams.** Uli Fahrenberg, Mathieu Acher, Axel Legay, and Andrzej Wasowski. *17th International Conference on Fundamental Approaches to Software Engineering (FASE'14)*, 2014. [PDF](https://inria.hal.science/hal-01087323v1/file/fase-final.pdf) · [HAL](https://hal.science/hal-01087323) · [DOI](https://doi.org/10.1007/978-3-642-54804-8_5) · [Link](https://hal.science/hal-00927310)
  Abstract: Class diagrams are among the most popular modeling languages in industrial use. In a model-driven development process, class diagrams evolve, so it is important to be able to assess differences between revisions, as well as to propagate differences using suitable merge operations. Existing differencing and merging methods are mainly syntactic, concentrating on edit operations applied to model elements, or they are based on sampling: enumerating some examples of instances which characterize the difference between two diagrams. This paper presents the first known (to the best of our knowledge) automatic model merging and differencing operators supported by a formal semantic theory guaranteeing that they are semantically sound. All instances of the merge of a model and its difference with another model are automatically instances of the second model. The differences we synthesize are represented using class diagram notation (not edits, or instances), which allows creation of a simple yet flexible algebra for diffing and merging. It also allows presenting changes comprehensively, in a notation already known to users.

- **Metamorphic Domain-Specific Languages: A Journey Into the Shapes of a Language.** Mathieu Acher, Benoit Combemale, and Philippe Collet. *CoRR, abs/1404.6838*, 2014. [DOI](https://doi.org/10.48550/arXiv.1404.6838) · [arXiv](https://arxiv.org/abs/1404.6838) · [Published version](/publications/#acher:hal-01061576)
  Abstract: External or internal domain-specific languages (DSLs) or (fluent) APIs? Whoever you are – a developer or a user of a DSL – you usually have to choose your side; you should not! What about metamorphic DSLs that change their shape according to your needs? We report on our 4-years journey of providing the "right" support (in the domain of feature modeling), leading us to develop an external DSL, different shapes of an internal API, and maintain all these languages. A key insight is that there is no one-size-fits-all solution or no clear superiority of a solution compared to another. On the contrary, we found that it does make sense to continue the maintenance of an external and internal DSL. The vision that we foresee for the future of software languages is their ability to be self-adaptable to the most appropriate shape (including the corresponding integrated development environment) according to a particular usage or task. We call metamorphic DSL such a language, able to change from one shape to another shape.

- **Reverse Engineering Web Configurators.** Ebrahim Khalil Abbasi, Mathieu Acher, Patrick Heymans, and Anthony Cleve. *2014 Software Evolution Week - IEEE Conference on Software Maintenance, Reengineering, and Reverse Engineering (CSMR-WCRE)*, 2014. [PDF](https://inria.hal.science/hal-00913139v1/file/csmr-main.pdf) · [HAL](https://hal.science/hal-00913139) · [DOI](https://doi.org/10.1109/csmr-wcre.2014.6747178)
  Abstract: A Web configurator offers a highly interactive environment to assist users in customising sales products through the selection of configuration options. Our previous empirical study revealed that a significant number of configurators are suboptimal in reliability, efficiency, and maintainability, opening avenues for re-engineering support and methodologies. This paper presents a tool-supported reverse-engineering process to semi-automatically extract configuration-specific data from a legacy Web configurator. The extracted and structured data is stored in formal models (e.g., variability models) and can be used in a forward-engineering process to generate a customized interface with an underlying reliable reasoning engine. Two major components are presented: (1) a Web Wrapper that extracts structured configuration-specific data from unstructured or semi-structured Web pages of a configurator, and (2) a Web Crawler that explores the configuration space (i.e., all objects representing configuration-specific data) and simulates users' configuration actions. We describe variability data extraction patterns, used on top of the Wrapper and the Crawler to extract configuration data. Experimental results on five existing Web configurators show that the specification of a few variability patterns enable the identification of hundreds of options.

- **Comparing or Configuring Products: Are We Getting the Right Ones?.** Nicolas Sannier, Guillaume Bécan, Mathieu Acher, Sana Ben Nasr, and Benoit Baudry. *8th International Workshop on Variability Modelling of Software-intensive Systems (VaMoS'14)*, 2014. [PDF](https://inria.hal.science/hal-00927312v1/file/VAMOS2014vision.pdf) · [HAL](https://hal.science/hal-00927312) · [DOI](https://doi.org/10.1145/2556624.2556636) · [Slides](https://fr.slideshare.net/gbecan/vamos2014)
  Abstract: Product comparators and configurators aim to assist customers in choosing a product that meets their expectations. While comparators present similarities and differences between competing products, configurators propose an assisted environment to gradually choose and customize products. The two systems have pros and cons and are inherently different. But both share the same variability information background and operate over a set of (possible) products, typically represented through product comparison matrices (PCMs). A key issue is that current PCMs have no clear semantics, making their analysis and transformations imprecise and hard. In this paper, we sketch a research plan for generating dedicated comparators or configurators from PCMs. The core of our vision is the use of formal variability models to encode PCMs and enables a further exploitation by developers of comparators or configurators. We elaborate on five research questions and describe the expected outputs of the research.

- **A Survey on Teaching of Software Product Lines.** Mathieu Acher, Roberto Erick Lopez-Herrejon, and Rick Rabiser. *Eight International Workshop on Variability Modelling of Software-Intensive Systems (VaMoS'14)*, 2014. [PDF](https://inria.hal.science/hal-00916746v1/file/vamos14.pdf) · [HAL](https://hal.science/hal-00916746) · [DOI](https://doi.org/10.1145/2556624.2556629) · [Slides](https://fr.slideshare.net/acher/teaching-30301536)
  Abstract: With around two decades of existence, the community of Software Product Line (SPL) researchers and practitioners is thriving as can be attested by the extensive research output and the numerous successful industrial projects. Education has a key role to support the next generation of engineers to build highly complex SPLs. Yet, it is unclear how SPLs are taught, what are the possible missing gaps and difficulties faced, what are the benefits, or what is the material available. In this paper, we carry out a survey with over 30 respondents with the purpose of capturing a snapshot of the state of teaching in our community. We report and discuss quantitative as well as qualitative results of the survey. We build upon them and sketch six concrete actions to continue improving the state of practice of SPL teaching.

- **ViViD: A Variability-Based Tool for Synthesizing Video Sequences.** Mathieu Acher, Mauricio Alferez, José A. Galindo, Pierre Romenteau, and Benoit Baudry. *18th International Software Product Line Conference (SPLC'14), tool track*, 2014. [PDF](https://inria.hal.science/hal-01020933v1/file/paper.pdf) · [HAL](https://hal.science/hal-01020933) · [DOI](https://doi.org/10.1145/2647908.2655981)
  Abstract: We present ViViD, a variability-based tool to synthesize variants of video sequences. ViViD is developed and used in the context of an industrial project involving consumers and providers of video processing algorithms. The goal is to synthesize synthetic video variants with a wide range of characteristics to then test the algorithms. We describe the key components of ViViD(1) a variability language and an environment to model what can vary within a video sequence; (2) a reasoning back-end to generate relevant testing configurations; (3) a video synthesizer in charge of producing variants of video sequences corresponding to configurations. We show how ViViD can synthesize realistic videos with different characteristics such as luminances, vehicles and persons that cover a diversity of testing scenarios.

- **Software Architectures and Multiple Variability.** Mathieu Acher, Philippe Collet, and Philippe Lahire. *Chapter in Software Architecture 2, Wiley*, 2014. [HAL](https://hal.science/hal-01098107)
  Abstract: During the construction of software product lines, variability management is a crucial activity. A large number of software variants must be produced, in most cases, by using extensible architectures. In this chapter, we present the various applications of a set of modular management variability tools (FAMILIAR) for different forms of architecture (component-, service- and plug-in-based), and at different stages of the software life cycle. We discuss the lessons learnt from these studies and present guidelines for resolving recurring problems linked to multiple variability and to software architecture.

- **A Variability-based Testing Approach for Synthesizing Video Sequences.** José A. Galindo, Mauricio Alferez, Mathieu Acher, Benoit Baudry, and David Benavides. *International Symposium on Software Testing and Analysis (ISSTA'14)*, 2014. [PDF](https://inria.hal.science/hal-01003148v3/file/paper.pdf) · [HAL](https://hal.science/hal-01003148) · [DOI](https://doi.org/10.1145/2610384.2610411)
  Abstract: A key problem when developing video processing software is the difficulty to test different input combinations. In this paper, we present VANE, a variability-based testing approach to derive video sequence variants. The ideas of the approach are i) to encode what can vary within a video sequence in a variability model; ii) exploit the variability model to generate a certain number of testable configurations; iii) synthesize variants of video sequences corresponding to configurations. VANE computes T-wise covering sets while maximizing a function over quality attributes. Also, we present a preliminary validation of the VANE approach in the context of an industrial project involving the test of video processing algorithms.

- **Architectures logicielles et variabilité multiple.** Mathieu Acher, Philippe Collet, and Philippe Lahire. *Chapter in Architectures logicielles et variabilité multiple, Lavoisier*, 2014. [HAL](https://hal.science/hal-01098109) · [Link](https://web.archive.org/web/20230911210104/https://www.lavoisier.fr/livre/informatique/architectures-logicielles/oussalah/descriptif-9782746245174)
  Abstract: Lors de la construction de lignes de produits logiciels, la gestion de la variabilité est une activité cruciale. Un très grand nombre de variantes logicielles doit être réalisé, le plus souvent en utilisant des architectures extensibles. Dans ce chapitre, nous présentons plusieurs applications d'un outillage (FAMILIAR) de gestion modulaire de la variabilité à différentes formes d'architectures (à base de composants, de services, de plugins) et à différents stades du cycle de vie logiciel. Nous discutons les leçons apprises de ces études, ainsi que quelques problèmes ouverts liés à la variabilité et aux architectures logicielles.

## 2013

- **Breathing Ontological Knowledge Into Feature Model Management.** Guillaume Bécan, Mathieu Acher, Benoit Baudry, and Sana Ben Nasr. *Rapport Technique RT-0441, INRIA*, 2013. [PDF](https://inria.hal.science/hal-00874867v1/file/RT-441.pdf) · [HAL](https://hal.science/hal-00874867)
  Abstract: Feature Models (FMs) are a popular formalism for modeling and reasoning about the configurations of a software product line. As the manual construction or management of an FM is time-consuming and error-prone for large software projects, recent works have focused on automated operations for reverse engineering or refactoring FMs from a set of configurations/dependencies. Without prior knowledge, meaningless ontological relations (as defined by the feature hierarchy and groups) are likely to be synthesized and cause severe difficulties when reading, maintaining or exploiting the resulting FM. In this paper we define a generic, ontological-aware synthesis procedure that guides users when identifying the likely siblings or parent candidates for a given feature. We develop and evaluate a series of heuristics for clustering/weighting the logical, syntactic and semantic relationships between features. Empirical experiments on hundreds of FMs, coming from the SPLOT repository and Wikipedia, show that an hybrid approach mixing logical and ontological techniques outperforms state-of-the-art solutions and offers the best support for reducing the number of features a user has to consider during the interactive selection of a hierarchy.

- **Feature Model Management: Smart Operations and Language Support (tutorial).** Philippe Collet, Philippe Lahire, Mathieu Acher, and Robert France. *ACM/IEEE 16th International Conference on Model Driven Engineering Languages and Systems (MODELS'13)*, 2013. [HAL](https://hal.science/hal-00913157)
  Abstract: Variability modelling and management is pervasive in a growing number of software engineering contexts (e.g., software product lines, dynamic adaptive systems). Feature models are the de facto standard to formally represent and reason about commonality and variability of a software system. This tutorial aims at presenting feature modelling languages and tools, directly applicable to a wide range of model-based variability problems and application domains. We will explain how to import, export, compose, decompose, edit, configure, compute diffs, refactor, reverse engineer, test, or reason about (multiple) feature models. We will also illustrate how these "smart" operations can be combined to realize complex variability management tasks. Participants (being practitioners or academics, beginners or advanced) will learn the principles and foundations of tool-supported techniques dedicated to the model-based management of variability.

- **Model-Based Variability Management (tutorial).** Mathieu Acher, Benoit Combemale, and Olivier Barais. *Three co-located international conferences ECOOP'13, ECMFA'13 and ECSA'13*, 2013. [Link](https://www.lirmm.fr/ecmfa13/?id=158#tutorial10) · [Slides](https://fr.slideshare.net/acher/ec2013-tutorialmb-variabilityfinal)
  Abstract: The customization of almost everything is observed in a wide range of domains. Many organizations should address the challenge of extending, changing, customizing or configuring numerous kinds of systems and artefacts (requirements, components, services, languages, architectural or design models, codes, user interfaces, etc.) for use in a particular context. As a result, modeling and managing variability of such systems and artefacts is a crucial activity in a growing number of software engineering contexts (e.g., software product lines, dynamic adaptive architectures). Numerous model-based techniques have been proposed and usually consist in i) a variability model (e.g., a feature model), ii) a model (e.g., a class diagram) expressed in a domain-specific modeling language (e.g., Unified Modelling language), and iii) a realization layer that maps and transforms variation points into model elements. Based on a selection of desired features in the variability model, a derivation engine can automatically synthesise customized models – each model corresponding to an individual product. In this tutorial, we present the foundations and tool-supported techniques of state-of-the-art variability modeling technologies. In the first part, we briefly exemplify the management of variability in some systems/artefacts (design models, languages, product configurators). We introduce the Common Variability Language (CVL), a representative approach and ongoing effort involving both academic and industry partners to promote standardization variability modeling technology. In the second part, we focus on feature models the most popular notation to formally represent and reason about commonality and variability of a software system. Feature modelling languages and tools, directly applicable to a wide range of model-based variability problems and application domains, are presented. The FAMILIAR language and environment is used to perform numerous management operations like the import, export, compose, decompose, edit, configure, compute diffs, refactor, reverse engineer, test, or reason about (multiple) feature models. We describe their theoretical foundations, efficient implementations, and how these operations can be combined to realize complex variability management tasks. In the third part, we show how to combine feature models and other modeling artefacts. We revisit the examples given in the first part of the tutorial, using the Kermeta workbench and familiarCVL, an implementation of CVL. Finally we present some of the ongoing challenges for variability modeling. At the end of the tutorial, participants (being practitioners or academics, beginners or advanced) will learn languages, tools and novel variability modeling techniques they can directly use in their industrial contexts or as part of their research.

- **The Anatomy of a Sales Configurator: An Empirical Study of 111 Cases.** Ebrahim Khalil Abbasi, Arnaud Hubaux, Mathieu Acher, Quentin Boucher, and Patrick Heymans. *25th International Conference on Advanced Information Systems Engineering (CAiSE'13)*, 2013. [PDF](https://inria.hal.science/hal-00796555v1/file/ConfiguratorsCAISE13.pdf) · [HAL](https://hal.science/hal-00796555) · [DOI](https://doi.org/10.1007/978-3-642-38709-8_11)
  Abstract: Nowadays, mass customization has been embraced by a large portion of the industry. As a result, the web abounds with sales config- urators that help customers tailor all kinds of goods and services to their specific needs. In many cases, configurators have become the sin- gle entry point for placing customer orders. As such, they are strategic components of companies' information systems and must meet stringent reliability, usability and evolvability requirements. However, the state of the art lacks guidelines and tools for efficiently engineering web sales configurators. To tackle this problem, empirical data on current practice is required. The first part of this paper reports on a systematic study of 111 web sales configurators along three essential dimensions: rendering of configuration options, constraint handling, and configuration process support. Based on this, the second part highlights good and bad prac- tices in engineering web sales configurator. The reported quantitative and qualitative results open avenues for the elaboration of methodolo- gies to (re-)engineer web sales configurators.

- **Support for Reverse Engineering and Maintaining Feature Models.** Mathieu Acher, Patrick Heymans, Anthony Cleve, Jean-Luc Hainaut, and Benoit Baudry. *Seventh International Workshop on Variability Modelling of Software-Intensive Systems (VaMoS'13)*, 2013. [PDF](https://inria.hal.science/hal-00766786v1/file/KSynthesis-VaMoS2013-CR.pdf) · [HAL](https://hal.science/hal-00766786) · [DOI](https://doi.org/10.1145/2430502.2430530)
  Abstract: Feature Models (FMs) are a popular formalism for modelling and reasoning about commonality and variability of a system. In essence, FMs aim to define a set of valid combinations of features, also called configurations. In this paper, we tackle the problem of synthesising an FM from a set of configurations. The main challenge is that numerous candidate FMs can be extracted from the same input configurations, yet only a few of them are meaningful and maintainable. We first characterise the different meanings of FMs and identify the key properties allowing to discriminate between them. We then develop a generic synthesis procedure capable of restituting the intended meanings of FMs based on inferred or user-specified knowledge. Using tool support, we show how the integration of knowledge into FM synthesis can be realized in different practical application scenarios that involve reverse engineering and maintaining FMs.

- **From Comparison Matrix to Variability Model: The Wikipedia Case Study.** Nicolas Sannier, Mathieu Acher, and Benoit Baudry. *28th IEEE/ACM International Conference on Automated Software Engineering (ASE'13)*, 2013. [PDF](https://inria.hal.science/hal-00858491v1/file/ASE2013_Sannier_Acher_Baudry.pdf) · [HAL](https://hal.science/hal-00858491) · [DOI](https://doi.org/10.1109/ase.2013.6693116) · [Slides](https://fr.slideshare.net/acher/product-comparison-matrix-pcm-and-wikipedia)
  Abstract: Product comparison matrices (PCMs) provide a convenient way to document the discriminant features of a family of related products and now abound on the internet. Despite their apparent simplicity, the information present in existing PCMs can be very heterogeneous, partial, ambiguous, hard to exploit by users who desire to choose an appropriate product. Variability Models (VMs) can be employed to formulate in a more precise way the semantics of PCMs and enable automated reasoning such as assisted configuration. Yet, the gap between PCMs and VMs should be precisely understood and automated techniques should support the transition between the two. In this paper, we propose variability patterns that describe PCMs content and conduct an empirical analysis of 300+ PCMs mined from Wikipedia. Our findings are a first step toward better engineering techniques for maintaining and configuring PCMs.

- **Interactive Visualisation of Products in Online Configurators: A Case Study for Variability Modelling Technologies.** Marianela Ciolfi Felice, Joao Bosco Ferreira Filho, Mathieu Acher, Arnaud Blouin, and Olivier Barais. *MAPLE/SCALE 2013 at SPLC 2013 Joint Workshop of MAPLE 2013 – 5th International Workshop on Model-driven Approaches in Software Product Line Engineering and SCALE 2013 – 4th Workshop on Scalable Modeling Techniques for Software Product Lines*, 2013. [PDF](https://inria.hal.science/hal-00842656v1/file/MAPLE2013.pdf) · [HAL](https://hal.science/hal-00842656) · [DOI](https://doi.org/10.1145/2499777.2500711)
  Abstract: Numerous companies develop interactive environments to assist users in customising sales products through the selection of configuration options. A visual representation of these products is an important factor in terms of user experience. However, an analysis of 60+ existing configurators highlights that not all provide visual representations of configured products and few of them do it in an user-friendly manner. One of the current challenges is the trade-off developers face between either the memory consuming use of pregenerated images of all the combinations of options, or rendering products on the fly, which is non trivial to implement efficiently. We believe that a new approach to associate product configurations to visual representations is needed to compose and render them dynamically. In this paper we present a formal statement of the problem and a model-driven perspective for addressing it as well as ongoing and future work. We argue the case study can serve as an empirical method to explore the adequacy of variability (modelling) technologies.

- **Composing your Compositions of Variability Models.** Mathieu Acher, Benoit Combemale, Philippe Collet, Olivier Barais, Philippe Lahire, and Robert B. France. *ACM/IEEE 16th International Conference on Model Driven Engineering Languages and Systems (MODELS'13)*, 2013. [PDF](https://inria.hal.science/hal-00859473v1/file/models13-compofm.pdf) · [HAL](https://hal.science/hal-00859473) · [DOI](https://doi.org/10.1007/978-3-642-41533-3_22)
  Abstract: Modeling and managing variability is a key activity in a growing number of software engineering contexts. Support for composing variability models is arising in many engineering scenarios, for instance, when several subsystems or modeling artifacts, each coming with their own variability and possibly developed by different stakeholders, should be combined together. In this paper, we consider the problem of composing feature models (FMs), a widely used formalism for representing and reasoning about a set of variability choices. We show that several composition operators can actually be defined, depending on both matching/merging strategies and semantic properties expected in the composed FM. We present four alternative forms and their implementations. We discuss their relative trade-offs w.r.t. reasoning, customizability, traceability, composability and quality of the resulting feature diagram. We summarize these findings in a reading grid which is validated by revisiting some relevant existing works. Our contribution should assist developers in choosing and implementing the right composition operators.

- **Feature Model Extraction from Large Collections of Informal Product Descriptions.** Jean-Marc Davril, Edouard Delfosse, Negar Hariri, Mathieu Acher, Jane Cleland-Huang, and Patrick Heymans. *European Software Engineering Conference and the ACM SIGSOFT Symposium on the Foundations of Software Engineering (ESEC/FSE'13)*, 2013. [PDF](https://inria.hal.science/hal-00859475v1/file/fse13main-id221-p-18686-final.pdf) · [HAL](https://hal.science/hal-00859475) · [DOI](https://doi.org/10.1145/2491411.2491455)
  Abstract: Feature Models (FMs) are used extensively in software product line engineering to help generate and validate individual product configurations and to provide support for domain analysis. As FM construction can be tedious and time-consuming, researchers have previously developed techniques for extracting FMs from sets of formally specified individual configurations, or from software requirements specifications for families of existing products. However, such artifacts are often not available. In this paper we present a novel, automated approach for constructing FMs from publicly available product descriptions found in online product repositories and marketing websites such as SoftPedia and CNET. While each individual product description provides only a partial view of features in the domain, a large set of descriptions can provide fairly comprehensive coverage. Our approach utilizes hundreds of partial product descriptions to construct an FM and is described and evaluated against antivirus product descriptions mined from SoftPedia.

- **Generating Counterexamples of Model-based Software Product Lines: An Exploratory Study.** João Bosco Ferreira Filho, Olivier Barais, Mathieu Acher, Jérôme Le Noir, and Benoit Baudry. *17th International Software Product Line Conference (SPLC'13)*, 2013. **Best Student Paper Award.** [PDF](https://inria.hal.science/hal-00837523v1/file/SPLC2013.pdf) · [HAL](https://hal.science/hal-00837523) · [DOI](https://doi.org/10.1145/2491627.2491639)
  Abstract: Model-based Software Product Line (MSPL) engineering aims at deriving customized models corresponding to individual products of a family. MSPL approaches usually promote the joint use of a variability model, a base model expressed in a specific formalism, and a realization layer that maps variation points to model elements. The design space of an MSPL is extremely complex to manage for the engineer, since the number of variants may be exponential and the derived product models have to be conformant to numerous well-formedness and business rules. In this paper, the objective is to provide a way to generate MSPLs, called counterexamples, that can produce invalid product models despite a valid configuration in the variability model. We provide a systematic and automated process, based on the Common Variability Language (CVL), to randomly search the space of MSPLs for a specific formalism. We validate the effectiveness of this process for three formalisms at different scales (up to 247 metaclasses and 684 rules). We also explore and discuss how counterexamples could guide practitioners when customizing derivation engines, when implementing checking rules that prevent early incorrect CVL models, or simply when specifying an MSPL.

- **Extraction and Evolution of Architectural Variability Models in Plugin-based Systems.** Mathieu Acher, Anthony Cleve, Philippe Collet, Philippe Merle, Laurence Duchien, and Philippe Lahire. *Software and Systems Modeling (SoSyM), 13(4)*, 2013. [PDF](https://inria.hal.science/hal-00859472v1/file/FraSCAtiSoSyM12.pdf) · [HAL](https://hal.science/hal-00859472) · [DOI](https://doi.org/10.1007/s10270-013-0364-2)
  Abstract: Variability management is a key issue when building and evolving software-intensive systems, making it possible to extend, configure, customize and adapt such systems to customers' needs and specific deployment contexts. A wide form of variability can be found in extensible software systems, typically built on top of plugin-based architectures that offer a (large) number of configuration options through plugins. In an ideal world, a software architect should be able to generate a system variant on-demand, corresponding to a particular assembly of plugins. To this end, the variation points and constraints between architectural elements should be properly modeled and maintained over time (i.e., for each version of an architecture). A crucial, yet error-prone and time-consuming, task for a software architect is to build an accurate representation of the variability of an architecture, in order to prevent unsafe architectural variants and reach the highest possible level of flexibility. In this article, we propose a reverse engineering process for producing a variability model (i.e., a feature model) of a plugin-based architecture. We develop automated techniques to extract and combine different variability descriptions, including a hierarchical software architecture model, a plugin dependency model and the software architect knowledge. By computing and reasoning about differences between versions of architectural feature models, software architect can control both the variability extraction and evolution processes. The proposed approach has been applied to a representative, large-scale plugin-based system (FraSCAti), considering different versions of its architecture. We report on our experience in this context.

- **FAMILIAR: A Domain-Specific Language for Large Scale Management of Feature Models.** Mathieu Acher, Philippe Collet, Philippe Lahire, and Robert France. *Science of Computer Programming (SCP) Special issue on programming languages, 78(6)*, 2013. [PDF](https://inria.hal.science/hal-00767175v1/file/SCP-FAMILIAR.pdf) · [HAL](https://hal.science/hal-00767175) · [DOI](https://doi.org/10.1016/j.scico.2012.12.004)
  Abstract: The feature model formalism has become the de facto standard for managing variability in software product lines (SPLs). In practice, developing an SPL can involve modeling a large number of features representing di erent viewpoints, sub-systems or concerns of the software system. This activity is generally tedious and error-prone. In this article, we present FAMILIAR a Domain-Specific Language (DSL) that is dedicated to the large scale management of feature models and that complements existing tool support. The language provides a powerful support for separating concerns in feature modeling, through the provision of composition and decomposition operators, reasoning facilities and scripting capabilities with modularization mechanisms. We illustrate how an SPL consisting of medical imaging services can be practically managed using reusable FAMILIAR scripts that implement reasoning mechanisms. We also report on various usages and applications of FAMILIAR and its operators, to demonstrate their applicability to di erent domains and use for di erent purposes.

- **Separating Concerns in Feature Models: Retrospective and Support for Multi-Views.** Arnaud Hubaux, Mathieu Acher, T. T. Tun, Patrick Heymans, Philippe Collet, and Philippe Lahire. *Chapter in Domain Engineering: Product Lines, Conceptual Models, and Languages (editors: Reinhartz-Berger,I. and Sturm, A. and Clark, T. and Bettin, J. and Cohen, S.), Springer*, 2013. [PDF](https://inria.hal.science/hal-00767213v1/file/DESoCFMBook.pdf) · [HAL](https://hal.science/hal-00767213) · [DOI](https://doi.org/10.1007/978-3-642-36654-3_1)
  Abstract: Feature models (FMs) are a popular formalism to describe the commonality and variability of a set of assets in a software product line (SPL). SPLs usually involve large and complex FMs that describe thousands of features whose legal combinations are governed by many and often complex rules. The size and complexity of these models is partly explained by the large number of concerns considered by SPL practitioners when managing and configuring FMs. In this chapter, we first survey concerns and their separation in FMs, highlighting the need for more modular and scalable techniques. We then revisit the concept of view as a simplified representation of an FM. We finally describe a set of techniques to specify, visualize and verify the coverage of a set of views. These techniques are implemented in complementary tools providing practical support for feature-based configuration and large scale management of FMs.

## 2012

- **Modelling variability using CVL; A step by step tutorial.** Jérôme Le Noir, Olivier Barais, Joao Bosco Ferreira Filho, Mathieu Acher, and Jean-Marc Jézéquel. *Journée Lignes de Produits*, 2012.

- **Next-Generation Model-based Variability Management: Languages and Tools (tutorial).** Mathieu Acher, Patrick Heymans, Philippe Collet, and Philippe Lahire. *ACM/IEEE 15th International Conference on Model Driven Engineering Languages & Systems (MODELS'2012)*, 2012. [PDF](https://inria.hal.science/hal-00767170v1/file/NextGenVariabilityMODELS12-tutorial.pdf) · [HAL](https://hal.science/hal-00767170)
  Abstract: Variability modelling and management is a key activity in a growing number of software engineering contexts, from software product lines to dynamic adaptive systems. Feature models are the defacto standard to formally represent and reason about commonality and variability of a software system. This tutorial aims at presenting next generation of feature modelling languages and tools, directly applicable to a wide range of model-based variability problems and application domains. Participants (being practitioners or academics, beginners or advanced) will learn the principles and foundations of languages and tool-supported techniques dedicated to the model-based management of variability.

- **Composing Multiple Variability Artifacts to Assemble Coherent Workflows.** Mathieu Acher, Philippe Collet, Alban Gaignard, Philippe Lahire, Johan Montagnat, and Robert France. *Software Quality Journal Special issue on Quality Engineering for Software Product Lines, 20(3-4)*, 2012. [PDF](https://hal.science/hal-00733556v1/file/SQJO-SPL-2011-final.pdf) · [HAL](https://hal.science/hal-00733556) · [DOI](https://doi.org/10.1007/s11219-011-9170-7)
  Abstract: The development of scientific workflows is evolving towards the systematic use of service oriented architectures, enabling the composition of dedicated and highly parameterized software services into processing pipelines. Building consistent workflows then becomes a cumbersome and error-prone activity as users cannot manage such large scale variability. This paper presents a rigorous and tooled approach in which techniques from Software Product Line (SPL) engineering are reused and extended to manage variability in service and workflow descriptions. Composition can be facilitated while ensuring consistency. Services are organized in a rich catalog which is organized as a SPL and structured according to the common and variable concerns captured for all services. By relying on sound merging techniques on the feature models that make up the catalog, reasoning about the compatibility between connected services is made possible. Moreover, an entire workflow is then seen as a multiple SPL (i.e., a composition of several SPLs). When services are configured within, the propagation of variability choices is then automated with appropriate techniques and the user is assisted in obtaining a consistent workflow. The approach proposed is completely supported by a combination of dedicated tools and languages. Illustrations and experimental validations are provided using medical imaging pipelines, which are representative of current scientific workflows in many domains.

- **Next-Generation Model-based Variability Management: Languages and Tools.** Mathieu Acher, Raphaël Michel, and Patrick Heymans. *ACM 16th International Software Product Line Conference (SPLC’12)*, 2012. [HAL](https://hal.science/hal-00718339) · [DOI](https://doi.org/10.1145/2364412.2364469) · [Link](https://dl.acm.org/citation.cfm?id=2364469)
  Abstract: This tutorial aims at presenting new feature modelling tools directly applicable to a wide range of variability problems and application domains. Techniques and languages (TVL, FAMILIAR) for modelling, managing and configuring feature models will be illustrated and explained to participants (practitioners or academics, beginners or advanced).

- **Feature Model Differences.** Mathieu Acher, Patrick Heymans, Philippe Collet, Clément Quinton, Philippe Lahire, and Philippe Merle. *24th International Conference on Advanced Information Systems Engineering (CAiSE'12)*, 2012. [PDF](https://inria.hal.science/hal-00713849v2/file/CAiSE2012Diff.pdf) · [HAL](https://hal.science/hal-00713849) · [DOI](https://doi.org/10.1007/978-3-642-31095-9_41)
  Abstract: Feature models are a widespread means to represent commonality and variability in software product lines. As is the case for other kinds of models, computing and managing feature model differences is useful in various real-world situations. In this paper, we propose a set of novel differencing techniques that combine syntactic and semantic mechanisms, and automatically produce meaningful differences. Practitioners can exploit our results in various ways: to understand, manipulate, visualize and reason about differences. They can also combine them with existing feature model composition and decomposition operators. The proposed automations rely on satisfiability algorithms. They come with a dedicated language and a comprehensive environment. We illustrate and evaluate the practical usage of our techniques through a case study dealing with a configurable component framework.

- **A Feature-based Approach to System Deployment and Adaptation.** Sabine Moisan, Jean-Paul Rigault, and Mathieu Acher. *Proceedings of the 2012 international workshop on Modeling in software engineering at ICSE 2012 (MiSE'12)*, 2012. [HAL](https://hal.science/hal-00708745) · [DOI](https://doi.org/10.1109/mise.2012.6226019)
  Abstract: Building large scale systems involves many design decisions, both at specification and implementation levels. This is due to numerous variants in the description of the task to achieve and its execution context as well as in the assembly of software components. We adopt a model-driven perspective, relying on different models and their transformations. We have started to model variability for large scale systems using feature diagrams, a formalism well suited for modeling variability. Our test application domain is video surveillance software platforms, from a software engineering perspective. These are good candidates to put MDE to the test, because of the huge variability in both the surveillance tasks and the video analysis algorithms. Our work was first concentrated on deployment of video-surveillance systems, now we rather work on runtime adaptation too.

- **Towards More Reliable Configurators: A Re-engineering Perspective.** Quentin Boucher, Ebrahim Abbasi, Arnaud Hubaux, Gilles Perrouin, Mathieu Acher, and Patrick Heymans. *Third International Workshop on Product LinE Approaches in Software Engineering at ICSE 2012 (PLEASE'12)*, 2012. [HAL](https://hal.science/hal-00718278) · [DOI](https://doi.org/10.1109/please.2012.6229766)
  Abstract: Delivering configurable solutions, that is products tailored to the requirements of a particular customer, is a priority of most B2B and B2C markets. These markets now heavily rely on interactive configurators that help customers build complete and correct products. Reliability is thus a critical requirement for configurators. Yet, our experience in industry reveals that many configurators are developed in an ad hoc manner, raising correctness and maintenance issues. In this paper, we present a vision to re-engineering more reliable configurators and the challenges it poses. The first challenge is to reverse engineer from an existing configurator the variability information, including complex rules, and to consolidate it in a variability model, namely a feature model. The second challenge is to forward engineer a new configurator that uses the feature model to generate a customized graphical user interface and the underlying reasoning engine.

- **Languages and Tools for Managing Feature Models.** Mathieu Acher, Raphaël Michel, Patrick Heymans, Philippe Collet, and Philippe Lahire. *Third International Workshop on Product LinE Approaches in Software Engineering at ICSE 2012 (PLEASE'12)*, 2012. [HAL](https://hal.science/hal-00718325) · [DOI](https://doi.org/10.1109/please.2012.6229765)
  Abstract: Feature models (FMs) are the de facto standard for modeling variability of software product lines. The research effort is still intensive and aims at increasing the adoption of FMs in practice. Integrated solutions that combine state-of-the-art techniques, languages, and tools are emerging. We give an overview of complementary languages, TVL and FAMILIAR, and tools for the purpose of supporting the management (e.g., configuration) of FMs. We report on practical applications of the languages and tools in different domains and for different purposes. Still, we are interested in applying our solutions to other contexts (e.g., industrial) in order to determine their applicability and possible adoption by practitioners.

- **Separation of Concerns in Feature Modeling: Support and Applications.** Mathieu Acher, Philippe Collet, Philippe Lahire, and Robert France. *Aspect-Oriented Software Development (AOSD'12)*, 2012. [PDF](https://inria.hal.science/hal-00767423v1/file/acher-collet-etal-2012.pdf) · [HAL](https://hal.science/hal-00767423) · [DOI](https://doi.org/10.1145/2162049.2162051)
  Abstract: Feature models (FMs) are a popular formalism for describing the commonality and variability of software product lines (SPLs) in terms of features. SPL development increasingly involves manipulating many large FMs, and thus scalable modular techniques that support compositional development of complex SPLs are required. In this paper, we describe how a set of complementary operators (aggregate, merge, slice) provides practical support for separation of concerns in feature modeling. We show how the combination of these operators can assist in tedious and error prone tasks such as automated correction of FM anomalies, update and extraction of FM views, reconciliation of FMs and reasoning about properties of FMs. For each task, we report on practical applications in different domains. We also present a technique that can efficiently decompose FMs with thousands of features and report our experimental results.

- **On Extracting Feature Models From Product Descriptions.** Mathieu Acher, Anthony Cleve, Gilles Perrouin, Patrick Heymans, Philippe Collet, Philippe Lahire, and Charles Vanbeneden. *Sixth International Workshop on Variability Modelling of Software-intensive Systems (VaMoS'12)*, 2012. [HAL](https://hal.science/hal-00718467) · [DOI](https://doi.org/10.1145/2110147.2110153)
  Abstract: In product line engineering, domain analysis is the process of analyzing related products to identify their common and variable features. This process is generally carried out by experts on the basis of existing product descriptions, which are expressed in a more or less structured way. Modeling and reasoning about product descriptions are error-prone and time consuming tasks. Feature models (FMs) consti- tute popular means to specify product commonalities and variabilities in a compact way, and to provide automated support to the domain analysis process. This paper aims at easing the transition from product descriptions expressed in a tabular format to FMs accurately representing them. This process is parameterized through a dedicated language and high-level directives (e.g., products/features scoping). We guarantee that the resulting FM represents the set of legal feature combinations supported by the considered products and has a readable tree hierarchy together with variability information. We report on our experiments based on public data and characterize the properties of the derived FMs.

- **Next-Generation Model-based Variability Management: Languages and Tools (Tutorial).** Mathieu Acher, Raphaël Michel, and Patrick Heymans. *Conférence en IngénieriE du Logiciel (CIEL'12)*, 2012.

## 2011

- **Reverse Engineering Architectural Feature Models.** Mathieu Acher, Anthony Cleve, Philippe Collet, Philippe Merle, Laurence Duchien, and Philippe Lahire. *10th Belgian-Netherlands Seminar on Software Evolution (BENEVOL)*, 2011. [PDF](https://soft.vub.ac.be/benevol2011/abstracts/Acher.pdf) · [Slides](https://fr.slideshare.net/acher/benevol11-reverse-engineering-architectural-feature-models)

- **Decomposing Feature Models: Language, Environment, and Applications.** Mathieu Acher, Philippe Collet, Philippe Lahire, and Robert France. *Automated Software Engineering (ASE'11), short paper: demonstration track*, 2011. [DOI](https://doi.org/10.1109/ASE.2011.6100135) · [Link](https://dl.acm.org/citation.cfm?id=2190078.2190137) · [Slides](https://fr.slideshare.net/acher/ase-tool-demonstration)
  Abstract: Variability in software product lines is often expressed through feature models (FMs). To handle the complexity of increasingly larger FMs, we propose semantically meaningful decomposition support through a slicing operator. We describe how the slicing operator is integrated into the FAMILIAR environment and how it can be combined with other operators to support complex tasks over FMs in different case studies.

- **Slicing Feature Models.** Mathieu Acher, Philippe Collet, Philippe Lahire, and Robert France. *26th IEEE/ACM International Conference On Automated Software Engineering (ASE'11), short paper*, 2011. [DOI](https://doi.org/10.1109/ASE.2011.6100089) · [Link](https://dl.acm.org/citation.cfm?id=2190091) · [Slides](https://fr.slideshare.net/acher/ase11-short-paper)
  Abstract: Feature models (FMs) are a popular formalism for describing the commonality and variability of software product lines (SPLs) in terms of features. As SPL development increasingly involves numerous large FMs, scalable modular techniques are required to manage their complexity. In this paper, we present a novel slicing technique that produces a projection of an FM, including constraints. The slicing allows SPL practitioners to find semantically meaningful decompositions of FMs and has been integrated into the FAMILIAR language.

- **Reverse Engineering Architectural Feature Models.** Mathieu Acher, Anthony Cleve, Philippe Collet, Philippe Merle, Laurence Duchien, and Philippe Lahire. *5th European Conference on Software Architecture (ECSA'11), long paper*, 2011. [PDF](https://inria.hal.science/inria-00614984v1/file/ecsa2011_submission_38_1_.pdf) · [HAL](https://hal.science/inria-00614984) · [DOI](https://doi.org/10.1007/978-3-642-23798-0_25) · [Slides](https://fr.slideshare.net/acher/reverse-engineering-architectural-feature-models)
  Abstract: Reverse engineering the variability of an existing system is a challenging activity. The architect knowledge is essential to identify variation points and explicit constraints between features, for instance in feature models (FMs), but the manual creation of FMs is both time-consuming and error-prone. On a large scale, it is very difficult for an architect to guarantee that the resulting FM ensures a safe composition of the architectural elements when some features are selected. In this paper, we present a comprehensive, tool supported process for reverse engineering architectural FMs. We develop automated techniques to extract and combine different variability descriptions of an architecture. Then, alignment and reasoning techniques are applied to integrate the architect knowledge and reinforce the extracted FM. We illustrate the reverse engineering process when applied to a representative software system, FraSCAti, and we report on our experience in this context.

- **Managing Multiple Feature Models: Foundations, Language, and Applications.** Mathieu Acher. *PhD thesis, University of Nice Sophia Antipolis*, 2011. [Slides](https://fr.slideshare.net/acher/acher-phd-thesis-defense)

- **Run Time Adaptation of Video-Surveillance Systems: A Software Modeling Approach.** Sabine Moisan, Jean-Paul Rigault, Mathieu Acher, Philippe Collet, and Philippe Lahire. *8th International Conference on Computer Vision Systems (ICVS'2011)*, 2011. [HAL](https://hal.science/inria-00617279) · [DOI](https://doi.org/10.1007/978-3-642-23968-7_21)

- **Modeling Variability from Requirements to Runtime.** Mathieu Acher, Philippe Collet, Philippe Lahire, Sabine Moisan, and Jean-Paul Rigault. *16th International Conference on Engineering of Complex Computer Systems (ICECCS'11)*, 2011. [HAL](https://hal.science/inria-00617273) · [DOI](https://doi.org/10.1109/iceccs.2011.15)
  Abstract: In software product line (SPL) engineering, a software configuration can be obtained through a valid selection of features represented in a feature model (FM). With a strong separation between requirements and reusable components and a deep impact of high level choices on technical parts, determining and configuring an well-adapted software configuration is a long, cumbersome and error-prone activity. This paper presents a modeling process in which variability sources are separated in different FMs and inter-related by propositional constraints while consistency checking and propagation of variability choices are automated. We show how the variability requirements can be expressed and then refined at design time so that the set of valid software configurations to be considered at runtime may be highly reduced. Software tools support the approach and some experimentations on a video surveillance SPL are also reported.

- **A Domain-Specific Language for Managing Feature Models.** Mathieu Acher, Philippe Collet, Philippe Lahire, and Robert France. *Symposium on Applied Computing (SAC'11)*, 2011. [DOI](https://doi.org/10.1145/1982185.1982473)
  Abstract: Feature models are a popular formalism for managing variability in software product lines (SPLs). In practice, developing an SPL can involve modeling a large number of features representing different viewpoints, sub-systems or concerns of the software system. To manage complexity, there is a need to separate, relate and compose several feature models while automating the reasoning on their compositions in order to enable rigorous SPL validation and configuration. In this paper, we propose a Domain-Specific Language (DSL) that is dedicated to the management of feature models and that complements existing tool support. Rationale for this language is discussed and its main constructs are presented through examples. We show how the DSL can be used to realize a non trivial scenario in which multiple SPLs are managed.

- **Managing Feature Models with FAMILIAR: a Demonstration of the Language and its Tool Support.** Mathieu Acher, Philippe Collet, Philippe Lahire, and Robert France. *Fifth International Workshop on Variability Modelling of Software-intensive Systems (VaMoS'11)*, 2011. [DOI](https://doi.org/10.1145/1944892.1944903)
  Abstract: Developing software product lines involves modeling a large number of features, usually using feature models, that represent different viewpoints, sub-systems or concerns of the software system. To manage complexity on a large scale, there is a need to separate, relate and compose several feature models while automating the reasoning on their compositions. This demonstration gives an overview of a Domain-Specific Language, FAMILIAR, that is dedicated to the management of feature models. Its comprehensive programming environment, based on Eclipse, is also described. It complements existing tool support (i.e., FeatureIDE).

- **FAMILIAR (FeAture Model scrIpt Language for manIpulation and Automatic Reasoning).** Mathieu Acher, Philippe Collet, Philippe Lahire, and Robert France. 2011. [Link](https://familiar-project.github.io/)

## 2010

- **FAMILIAR, a Language and its Environment for Feature Model Management.** Mathieu Acher, Philippe Collet, Philippe Lahire, and Robert France. *Journée Lignes de Produits. Maîtriser la Diversité*, 2010.
  Abstract: Feature models are a popular formalism for managing variability in software product lines (SPLs). In practice, developing an SPL can involve modeling a large number of features representing different viewpoints, sub-systems or concerns of the software system. To manage complexity, there is a need to separate, relate and compose several feature models while automating the reasoning on their compositions in order to enable rigorous SPL validation and configuration. In this paper, we propose a domain-specific language, named FAMILIAR, that is dedicated to the management of feature models. We introduce the main constructs of the langage through examples and we describe its comprehensive programming environment, based on Eclipse, that complements existing tool support (i.e., FeatureIDE).

- **Exploring the Synergies Between Feature Models and Ontologies.** Martin Fagereng Johansen, Franck Fleurey, Mathieu Acher, Philippe Collet, and Philippe Lahire. *International Workshop on Model-driven Approaches in Software Product Line Engineering (MAPLE 2010)*, 2010. [PDF](https://web.archive.org/web/20160203133206/http://heim.ifi.uio.no/martifag/papers/Johansen2010.pdf)
  Abstract: A factor slowing down the use of feature models is that either the concepts or the relations expressed in a feature model are not defined at all, or defined in an unsatisfactory manner; feature models are sometimes too vague to be analyzed by a reasoning tool. It is thus difficult to determine if the features in a feature model are arranged and structured consistently with domain knowledge and if they are accurately expressed, organized and represented. Ontology modeling can improve feature modeling by providing additional information relevant for the domain in which a feature model is constructed. Finding synergies between feature models and ontologies will aid an SPL engineer in accurately expressing, organizing and representing features in their feature models. In this paper, we look at potential benefits in using the two modeling formalisms together, we identify issues and challenges considering the gap between the two formalisms and discuss the importance of this gap. We report on our current ideas and results.

- **Managing Variability in Workflow with Feature Model Composition Operators.** Mathieu Acher, Philippe Collet, Philippe Lahire, and Robert France. *9th International Conference on Software Composition (SC'10)*, 2010. [PDF](https://hal.science/hal-00484152v1/file/CameraReady.pdf) · [HAL](https://hal.science/hal-00484152) · [DOI](https://doi.org/10.1007/978-3-642-14046-4_2) · [Slides](https://fr.slideshare.net/acher/managing-variability-in-workflow-with-feature-model-composition-operators-4851930)
  Abstract: In grid-based scientific applications, building a workflow essentially involves composing parameterized services describing families of services and then configuring the resulting workflow product line. In domains (e.g., medical imaging) in which many different kinds of highly parameterized services exist, there is a strong need to manage variabilities so that scientists can more easily configure and compose services with consistency guarantees. In this paper, we propose an approach in which variable points in services are described with several separate feature models, so that families of workflow can be defined as compositions of feature models. A compositional technique then allows reasoning about the compatibility between connected services to ensure consistency of an entire workflow, while supporting automatic propagation of variability choices when configuring services.

- **Comparing Approaches to Implement Feature Model Composition.** Mathieu Acher, Philippe Collet, Philippe Lahire, and Robert France. *6th European Conference on Modelling Foundations and Applications (ECMFA)*, 2010. [PDF](https://hal.science/hal-00484232v1/file/CameraReady.pdf) · [HAL](https://hal.science/hal-00484232) · [DOI](https://doi.org/10.1007/978-3-642-13595-8_3) · [Slides](https://fr.slideshare.net/acher/comparing-approaches-to-implement-feature-model-composition)
  Abstract: The use of Feature Models (FMs) to define the valid combinations of features in Software Product Lines (SPL) is becoming commonplace. To enhance the scalability of FMs, support for composing FMs describing different SPL aspects is needed. Some composition operators, with interesting property preservation capabilities, have already been defined but a comprehensive and efficient implementation is still to be proposed. In this paper, we systematically compare strengths and weaknesses of different implementation approaches. The study provides some evidence that using generic model composition frameworks are not helping much in the realization, whereas a specific solution is finally necessary and clearly stands out by its qualities.

- **Managing Multiple Software Product Lines Using Merging Techniques.** Mathieu Acher, Philippe Collet, Philippe Lahire, and Robert France. *Technical Report, University of Nice Sophia Antipolis, I3S CNRS*, 2010. [PDF](https://web.archive.org/web/20211008120050/https://www.i3s.unice.fr/~mh/RR/2010/RR-10-06-P.LAHIRE.pdf)
  Abstract: A growing number of organizations produce and maintain multiple Software Product Lines (SPLs) or design software products that utilize features in SPLs maintained by competing suppliers. Manually building monolithic Feature Models (FMs) to help manage features described across different SPLs is error-prone and tedious and the resulting FMs can be difficult to understand and use. In this paper we propose a compositional approach to managing multiple SPLs that involves automatically merging FMs defined across the SPLs. We illustrate how the approach can be used to create FMs that support selection of products from among sets of competing products provided by different companies or suppliers. The merging techniques can also manage features from different SPLs which are then combined to form products. We show that the proposed approach results in more compact FMs, and we provide some empirical results on the complexity and scalability of the composition operators used in the approach.

## 2009

- **Modeling Context and Dynamic Adaptations with Feature Models.** Mathieu Acher, Philippe Collet, Franck Fleurey, Philippe Lahire, Sabine Moisan, and Jean-Paul Rigault. 2009. [PDF](https://web.archive.org/web/20160131014545/http://nyx.unice.fr/publis/acher-collet-etal:2009a.pdf) · [HAL](https://hal.science/hal-00419990)

- **Composing Feature Models.** Mathieu Acher, Philippe Collet, Philippe Lahire, and Robert France. *2nd International Conference on Software Language Engineering (SLE'09)*, 2009. **Most Influential Paper Award at SLE 2019.** [PDF](https://hal.science/hal-00415767v1/file/SLE2009-postproceedings.pdf) · [HAL](https://hal.science/hal-00415767) · [DOI](https://doi.org/10.1007/978-3-642-12107-4_6) · [Slides](https://fr.slideshare.net/acher/composing-feature-models)
  Abstract: Feature modeling is a widely used technique in Software Product Line development. Feature models allow stakeholders to describe domain concepts in terms of commonalities and differences within a family of software systems. Developing a complex monolithic feature model can require significant effort and restrict the reusability of a set of features already modeled. We advocate using modeling techniques that support separating and composing concerns to better manage the complexity of developing large feature models. In this paper, we propose a set of composition operators dedicated to feature models. These composition operators enable the development of large feature models by composing smaller feature models which address well-defined concerns. The operators are notably distinguished by their documented capabilities to preserve some significant properties.

- **Modeling Context and Dynamic Adaptations with Feature Models.** Mathieu Acher, Philippe Collet, Franck Fleurey, Philippe Lahire, Sabine Moisan, and Jean-Paul Rigault. *4th International Workshop Models@run.time at Models 2009 (MRT'09)*, 2009. [PDF](https://hal.science/hal-00419990v1/file/MRT09-CR.pdf) · [HAL](https://hal.science/hal-00419990)
  Abstract: Self-adaptive and dynamic systems adapt their behavior according to the context of execution. The contextual information exhibits multiple variability factors which induce many possible configurations of the software system at runtime. The challenge is to specify the adaptation rules that can link the dynamic variability of the context with the possible variants of the system. Our work investigates the systematic use of feature models for modeling the context and the software variants, together with their inter relations, as a way to configure the adaptive system with respect to a particular context. A case study in the domain of video surveillance systems is used to illustrate the approach.

- **Tackling High Variability in Video Surveillance Systems through a Model Transformation Approach.** Mathieu Acher, Philippe Lahire, Sabine Moisan, and Jean-Paul Rigault. *MiSE '09: Proceedings of the 2009 international workshop on Modeling in software engineering at ICSE 2009 (MiSE'09)*, 2009. [PDF](https://hal.science/hal-00415770v1/file/ICSE2009_MISE_2005_.pdf) · [HAL](https://hal.science/hal-00415770) · [DOI](https://doi.org/10.1109/mise.2009.5069896)
  Abstract: This work explores how model-driven engineering techniques can support the configuration of systems in domains presenting multiple variability factors. Video surveillance is a good candidate for which we have an extensive experience. Ultimately, we wish to automatically generate a software component assembly from an application specification, using model to model transformations. The challenge is to cope with variability both at the specification and at the implementation levels. Our approach advocates a clear separation of concerns. More precisely, we propose two feature models, one for task specification and the other for software components. The first model can be transformed into one or several valid component configurations through step-wise specialization. This paper outlines our approach, focusing on the two feature models and their relations. We particularly insist on variability and constraint modeling in order to achieve the mapping from domain variability to software variability through model transformations.

## 2008

- **Un compte rendu de la conférence Models 2008 (Toulouse, France).** Mathieu Acher and Vincent Aranega. 2008. [PDF](https://web.archive.org/web/20200815193943/http://nyx.unice.fr/publis/acher-aranega:2008.pdf)

- **Imaging Services on the Grid as a Product Line: Requirements and Architecture.** Mathieu Acher, Philippe Collet, Philippe Lahire, and Johan Montagnat. *Service-Oriented Architectures and Software Product Lines - Putting Both Together (SOAPL'08)*, 2008. [PDF](https://hal.science/hal-00419992v1/file/soapl.pdf) · [HAL](https://hal.science/hal-00419992)
  Abstract: SOA is now the reference architecture for medical imaging processing on the grid. Imaging services must be composed in workflows to implement the processing chains, but the need to handle end-to-end qualities of service hampered both the provision of services and their composition. This paper analyses the variability of functional and non functional aspects of this domain and proposes a first architecture in which services are organized within a product line architecture and metamodels help in structuring necessary information.

- **Vers une ligne de services pour la grille: application à l’imagerie médicale.** Mathieu Acher. *Master's thesis, Université de Nice Sophia-Antipolis*, 2008. [PDF](https://web.archive.org/web/20200819055947/http://nyx.unice.fr/publis/acher:2008.pdf)

- **Issues in Managing Variability of Medical Imaging Grid Services.** Mathieu Acher, Philippe Collet, and Philippe Lahire. *MICCAI-Grid Workshop (MICCAI-Grid)*, 2008. [PDF](https://hal.science/hal-00459517v1/file/acher-collet-etal_2008.pdf) · [HAL](https://hal.science/hal-00459517)
  Abstract: In medical image analysis, there exist multifold applications to grids and service-oriented architectures are more and more used to implement such imaging applications. In this context, workflow and service architects have to face an important variability problem related both to the functional description of services, and to the numerous quality of service (QoS) dimensions that are to be considered. In this paper, we analyze such variability issues and establish the requirements of a service product line, which objective is to facilitate variability handling in the image processing chain.