Publications
(See also DBLP, Google Scholar, or
HAL
. Send me an email for further information!)
[1] Luc Lesoil, Helge Spieker, Arnaud Gotlieb, Mathieu Acher, Paul Temple, Arnaud Blouin, and Jean-Marc Jézéquel. Learning input-aware performance models of configurable systems: An empirical evaluation (2023). In Journal of Systems and Software published by Elsevier [PDF] [bib][DOI] 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.
[2] Quentin Mazouni, Helge Spieker, Arnaud Gotlieb, and Mathieu Acher. Policy Testing with MDPFuzz (Replicability Study) (2024). In Proceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis published by Association for Computing Machinery [PDF] [bib][DOI] Distinguished Paper Award 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.
[3] Olivier Zeyen, Maxime Cordy, Gilles Perrouin, and Mathieu Acher. Exploring the Computational Complexity of SAT Counting and Uniform Sampling with Phase Transitions (2024). In Proceedings of the 2024 IEEE/ACM 46th International Conference on Software Engineering: Companion Proceedings, ICSE Companion 2024, Lisbon, Portugal, April 14-20, 2024 published by ACM [PDF] [bib][DOI] 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].
[4] Olivier Zeyen, Maxime Cordy, Gilles Perrouin, and Mathieu Acher. Preprocessing is What You Need: Understanding and Predicting the Complexity of SAT-based Uniform Random Sampling (2024). In Proceedings of the 2024 IEEE/ACM 12th International Conference on Formal Methods in Software Engineering (FormaliSE), Lisbon, Portugal, April 14-15, 2024 published by ACM [PDF] [bib][DOI] 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.
[5] Maxime Cordy, Daniel Str{\"{u}}ber, M{\'{o}}nica Pinto, Iris Groher, Deepak Dhungana, Jacob Kr{\"{u}}ger, Juliana Alves Pereira, Mathieu Acher, Thomas Th{\"{u}}m, Maurice H. Beek, Jessie Galasso-Carbonnel, Paolo Arcaini, Mohammad Reza Mousavi, Xhevahire Tërnava, Jos{é} A. Galindo, Tao Yue, Lidia Fuentes, and Jos{é} Miguel Horcas. Proceedings of the 28th ACM International Systems and Software Product Line Conference - Volume B, SPLC 2024, Dommeldange, Luxembourg, September 2-6, 2024 [editor of the proceedings] (2024). published by ACM [PDF] [bib][DOI]
[6] Maxime Cordy, Daniel Str{\"{u}}ber, M{\'{o}}nica Pinto, Iris Groher, Deepak Dhungana, Jacob Kr{\"{u}}ger, Juliana Alves Pereira, Mathieu Acher, Thomas Th{\"{u}}m, Maurice H. Beek, Jessie Galasso-Carbonnel, Paolo Arcaini, Mohammad Reza Mousavi, Xhevahire Tërnava, Jos{é} A. Galindo, Tao Yue, Lidia Fuentes, and Jos{é} Miguel Horcas. Proceedings of the 28th ACM International Systems and Software Product Line Conference - Volume A, SPLC 2024, Dommeldange, Luxembourg, September 2-6, 2024 [editor of the proceedings] (2024). published by ACM [PDF] [bib][DOI]
[7] Mathieu Acher, Beno{\^i}t Combemale, Georges Aaron Randrianaina, and Jean-Marc Jézéquel. Embracing Deep Variability For Reproducibility and Replicability (2024). In REP 2024 - ACM Conference on Reproducibility and Replicability [PDF] [bib] 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.
[8] Georges Aaron Randrianaina, Djamel Eddine Khelladi, Olivier Zendra, and Mathieu Acher. Options Matter: Documenting and Fixing Non-Reproducible Builds in Highly-Configurable Systems (2024). In MSR 2024 - 21th International Conference on Mining Software Repository [PDF] [bib] 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.
[9] Quentin Mazouni, Helge Spieker, Arnaud Gotlieb, and Mathieu Acher. Testing for Fault Diversity in Reinforcement Learning (2024). In Proceedings of the 5th ACM/IEEE International Conference on Automation of Software Test (AST 2024), Lisbon, Portugal, April 15-16, 2024 published by ACM [PDF] [bib][DOI] Best Paper Award 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.
[10] Mathieu Acher. A Demonstration of End-User Code Customization Using Generative AI (2024). In VAMOS 2024 - 18th International Working Conference on Variability Modelling of Software-Intensive Systems [PDF] [bib][DOI] 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.
[11] Xhevahire Tërnava, Mathieu Acher, and Benoit Combemale. Specialization of Run-time Configuration Space at Compile-time: An Exploratory Study (2023). In SAC 2023 - The 38th ACM/SIGAPP Symposium on Applied Computing published by ACM [PDF] [bib] 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.
[12] Damien Foures, Mathieu Acher, Olivier Barais, Benoit Combemale, Jean-Marc Jézéquel, and Jörg Kienzle. Experience in Specializing a Generic Realization Language for SPL Engineering at Airbus (2023). In MODELS 2023 - 26th International Conference on Model-Driven Engineering Languages and Systems published by IEEE [PDF] [bib] Best Paper Award 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.
[13] Luc Lesoil, Mathieu Acher, Arnaud Blouin, and Jean-Marc Jézéquel. Input Sensitivity on the Performance of Configurable Systems: An Empirical Study (2023). In Journal of Systems and Software published by Elsevier [PDF] [bib][DOI] 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.
[14] Mathieu Acher, José Galindo Duarte, and Jean-Marc Jézéquel. On Programming Variability with Large Language Model-based Assistant (2023). In SPLC 2023 - 27th ACM International Systems and Software Product Lines Conference published by ACM [PDF] [bib][DOI][slides] 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.
[15] Quentin Mazouni, Helge Spieker, Arnaud Gotlieb, and Mathieu Acher. A Review of Validation and Verification of Neural Network-based Policies for Sequential Decision Making (2023). In CoRR [PDF] [bib][DOI] 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.
[16] Mathieu Acher, and Jabier Martinez. Generative AI for Reengineering Variants into Software Product Lines: An Experience Report (2023). In SPLC 2023 - 27th ACM International Systems and Software Product Lines Conference published by ACM [PDF] [bib][DOI][slides] 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.
[17] Zohra Kaouter Kebaili, Djamel Eddine Khelladi, Mathieu Acher, and Olivier Barais. Towards Leveraging Tests to Identify Impacts of Metamodel and Code Co-evolution (2023). In CAiSE 2023 - 35th International Conference on Advanced Information Systems Engineering published by Springer International Publishing [PDF] [bib][DOI]
[18] Mathieu Acher, Luc Lesoil, Georges Aaron Randrianaina, Xhevahire Tërnava, and Olivier Zendra. A Call for Removing Variability (2023). In VaMoS 2023 - 17th International Working Conference on Variability Modelling of Software-Intensive Systems [PDF] [bib][DOI] 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).
[19] Roberto Lopez-Herrejon, Jabier Martinez, Tewfik Ziadi, Mathieu Acher, K.G. Wesley Assunção, and Silvia Vergilio. Handbook of Re-Engineering Software Intensive Systems into Software Product Lines [editor of the book] (2023). published by Springer International Publishing [PDF] [bib][DOI][TwitterThread] 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.
[20] Mathieu Acher, Gilles Perrouin, and Maxime Cordy. BURST: Benchmarking Uniform Random Sampling Techniques (2023). In Science of Computer Programming published by Elsevier [PDF] [bib] 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.
[21] Hugo Martin, Paul Temple, Mathieu Acher, Juliana Alves Pereira, and Jean-Marc Jézéquel. Machine Learning for Feature Constraints Discovery (2023) chapter book, in Handbook of Re-Engineering Software Intensive Systems into Software Product Lines (2023). published by Springer International Publishing [PDF] [bib][DOI] 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.
[22] Xhevahire Tërnava, Mathieu Acher, and Benoît Combemale. Specialization of Run-time Configuration Space at Compile-time: An Exploratory Study (2022). In CoRR [PDF] [bib][DOI] 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.
[23] Jean-Baptiste Döderlein, Mathieu Acher, Djamel Eddine Khelladi, and Benoît Combemale. Piloting Copilot and Codex: Hot Temperature, Cold Prompts, or Black Magic? (2022). In CoRR [PDF] [bib][DOI] 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.
[24] Mathieu Acher, Hugo Martin, Juliana Alves Pereira, Luc Lesoil, Arnaud Blouin, Jean-Marc Jézéquel, Djamel Eddine Khelladi, and Olivier Barais. Feature Subset Selection for Learning Huge Configuration Spaces: The case of Linux Kernel Size (2022). In SPLC 2022 - 26th ACM International Systems and Software Product Line Conference [PDF] [bib][DOI][slides] 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.
[25] Jean-Marc Jézéquel, Jörg Kienzle, and Mathieu Acher. From feature models to feature toggles in practice (2022). In SPLC 2022 - 26th ACM International Systems and Software Product Line Conference published by ACM [PDF] [bib][DOI] 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.
[26] Xhevahire Tërnava, Mathieu Acher, Luc Lesoil, Arnaud Blouin, and Jean-Marc Jézéquel. Scratching the Surface of ./configure: Learning the Effects of Compile-Time Options on Binary Size and Gadgets (2022). In ICSR 2022 - 20th International Conference on Software and Systems Reuse [PDF] [bib] Best Paper Award 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.
[27] Luc Lesoil, Mathieu Acher, Arnaud Blouin, and Jean-Marc Jézéquel. Beware of the Interactions of Variability Layers When Reasoning about Evolution of MongoDB (2022). In ICPE 2022 - 13th ACM/SPEC International Conference on Performance Engineering [PDF] [bib][DOI] 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.
[28] Paul Temple, Gilles Perrouin, Mathieu Acher, Battista Biggio, Jean-Marc Jézéquel, and Fabio Roli. Empirical Assessment of Generating Adversarial Configurations for Software Product Lines (2022). In International Conference on Software Architecture (ICSA), Journal First Track [bib] 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.
[29] Georges Aaron Randrianaina, Xhevahire Tërnava, Djamel Eddine Khelladi, and Mathieu Acher. On the Benefits and Limits of Incremental Build of Software Configurations: An Exploratory Study (2022). In ICSE 2022 - 44th International Conference on Software Engineering [PDF] [bib] 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\%.
[30] Mathieu Acher. Reproducible Science and Deep Software Variability (2022). In VaMoS 2022 - 16th International Working Conference on Variability Modelling of Software-Intensive Systems [PDF] [bib] 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.
[31] Luc Lesoil, Hugo Martin, Mathieu Acher, Arnaud Blouin, and Jean-Marc Jézéquel. Transferring Performance between Distinct Configurable Systems : A Case Study (2022). In VaMoS 2022 - 16th International Working Conference on Variability Modelling of Software-Intensive Systems [PDF] [bib][DOI] 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.
[32] Xhevahire Tërnava, Luc Lesoil, Georges Aaron Randrianaina, Djamel Eddine Khelladi, and Mathieu Acher. On the Interaction of Feature Toggles (2022). In VaMoS 2022 - 16th International Working Conference on Variability Modelling of Software-Intensive Systems [PDF] [bib][DOI] 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.
[33] Georges Aaron Randrianaina, Djamel Eddine Khelladi, Olivier Zendra, and Mathieu Acher. Towards Incremental Build of Software Configurations (2022). In ICSE-NIER 2022 - 44th International Conference on Software Engineering -- New Ideas and Emerging Results [PDF] [bib][DOI]
[34] Luc Lesoil, Mathieu Acher, Arnaud Blouin, and Jean-Marc J{é}z{é}quel. The Interaction between Inputs and Configurations fed to Software Systems: an Empirical Study (2021). In CoRR [PDF] [bib][TwitterThread] 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.
[35] Mathieu Acher. Modelling, Reverse Engineering, and Learning Software Variability (2021). [PDF] [bib]
[36] Hugo Martin, Mathieu Acher, Juliana Alves Pereira, Luc Lesoil, Jean-Marc Jézéquel, and Djamel Eddine Khelladi. Transfer Learning Across Variants and Versions: The Case of Linux Kernel Size (2022). In IEEE Transactions on Software Engineering published by Institute of Electrical and Electronics Engineers [PDF] [bib][TwitterThread] 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.
[37] Juliana Alves Pereira, Hugo Martin, Mathieu Acher, Jean-Marc Jézéquel, Goetz Botterweck, and Anthony Ventresque. Learning Software Configuration Spaces: A Systematic Literature Review (2021). In Journal of Systems and Software published by Elsevier [PDF] [bib][DOI][TwitterThread] 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.
[38] Mathieu Acher, Gilles Perrouin, and Maxime Cordy. BURST: A Benchmarking Platform for Uniform Random Sampling Techniques (2021). In Proceedings of the 25th ACM International Systems and Software Product Line Conference - Volume B published by Association for Computing Machinery [PDF] [bib][DOI][TwitterThread][Youtube] 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.
[39] Luc Lesoil, Mathieu Acher, Xhevahire Tërnava, Arnaud Blouin, and Jean-Marc Jézéquel. The Interplay of Compile-time and Run-time Options for Performance Prediction (2021). In SPLC 2021 - 25th ACM International Systems and Software Product Line Conference - Volume A published by ACM [PDF] [bib][DOI][TwitterThread][Youtube] 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.
[40] Hugo Martin, Mathieu Acher, Juliana Alves Pereira, and Jean-Marc Jézéquel. A comparison of performance specialization learning for configurable systems (2021). In SPLC 2021 - 25th ACM International Systems and Software Product Line Conference published by ACM [PDF] [bib][DOI][TwitterThread][Youtube] Best Paper Award 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.
[41] Luc Lesoil, Mathieu Acher, Arnaud Blouin, and Jean-Marc Jézéquel. Deep Software Variability: Towards Handling Cross-Layer Configuration (2021). In VaMoS 2021 - 15th International Working Conference on Variability Modelling of Software-Intensive Systems [PDF] [bib][TwitterThread] 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.
[42] Maxime Cordy, Mathieu Acher, Danilo Beuche, and Gunter Saake. VaMoS '20: 14th International Working Conference on Variability Modelling of Software-Intensive Systems, Magdeburg Germany, February 5-7, 2020 [editor of the proceedings] (2020). published by ACM [PDF] [bib][DOI]
[43] Djamel Eddine Khelladi, Benoit Combemale, Mathieu Acher, Olivier Barais, and Jean-Marc Jézéquel. Co-evolving code with evolving metamodels (2020). In ICSE '20: 42nd International Conference on Software Engineering, Seoul, South Korea, 27 June - 19 July, 2020 published by ACM [PDF] [bib][DOI][Youtube] 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.
[44] Djamel Eddine Khelladi, Benoit Combemale, Mathieu Acher, and Olivier Barais. On the power of abstraction: a model-driven co-evolution approach of software code (2020). In ICSE-NIER 2020: 42nd International Conference on Software Engineering, New Ideas and Emerging Results, Seoul, South Korea, 27 June - 19 July, 2020 published by ACM [PDF] [bib][DOI][Youtube] 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.
[45] Juliana Alves Pereira, Hugo Martin, Paul Temple, and Mathieu Acher. Machine learning and configurable systems: a gentle introduction (2020). In SPLC '20: 24th ACM International Systems and Software Product Line Conference, Montreal, Quebec, Canada, October 19-23, 2020, Volume A published by ACM [PDF] [bib][DOI] 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).
[46] Benjamin Benni, S{é}bastien Mosser, Mathieu Acher, and Mathieu Paillart. Characterizing Black-box Composition Operators via Generated Tailored Benchmarks (2020). In J. Object Technol. [PDF] [bib][DOI][Youtube] 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.
[47] Francesca Arcelli Fontana, Gilles Perrouin, Apostolos Ampatzoglou, Mathieu Acher, Bartosz Walter, Maxime Cordy, Fabio Palomba, and Xavier Devroey. MALTESQUE 2019 Workshop Summary (2020). In ACM SIGSOFT Softw. Eng. Notes [PDF] [bib][DOI]
[48] Paul Temple, Gilles Perrouin, Mathieu Acher, Battista Biggio, Jean-Marc Jézéquel, and Fabio Roli. Empirical Assessment of Generating Adversarial Configurations for Software Product Lines (2020). In Empirical Software Engineering (ESE) [bib] 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.
[49] Francesca Arcelli Fontana, Bartosz Walter, Apostolos Ampatzoglou, Fabio Palomba, Gilles Perrouin, Mathieu Acher, Maxime Cordy, and Xavier Devroey. 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 [editor of the proceedings] (2019). published by ACM [PDF] [bib][DOI]
[50] Juliana Alves Pereira, Mathieu Acher, Hugo Martin, and Jean-Marc Jézéquel. Sampling Effect on Performance Prediction of Configurable Systems: A Case Study (2020). In International Conference on Performance Engineering (ICPE 2020) [PDF] [bib][Youtube] Best Paper Award 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.
[51] Mathieu Acher, and Myra B. Cohen. Special issue on systems and software product line engineering (2019). In Journal of Systems and Software (JSS) [PDF] [bib][DOI]
[52] Mathieu Acher, Hugo Martin, Juliana Alves Pereira, Arnaud Blouin, Jean-Marc Jézéquel, Djamel Eddine Khelladi, Luc Lesoil, and Olivier Barais. Learning Very Large Configuration Spaces: What Matters for Linux Kernel Sizes (2019). [PDF] [bib] 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.
[53] Mathieu Acher, Hugo Martin, Juliana Alves Pereira, Arnaud Blouin, Djamel Eddine Khelladi, and Jean-Marc Jézéquel. Learning From Thousands of Build Failures of Linux Kernel Configurations (2019). [PDF] [bib] 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).
[54] Mathieu Acher. Learning the Linux Kernel Configuration Space: Results and Challenges (2019). In ELC Europe 2019 - Embedded Linux Conference Europe 2019 [PDF] [bib][Youtube]
[55] Hugo Martin, Juliana Alves Pereira, Paul Temple, and Mathieu Acher. Machine Learning and Configurable Systems: A Gentle Introduction (2019). In SPLC 2019 - 23rd International Systems and Software Product Line Conference published by ACM [PDF] [bib][DOI]
[56] Mathieu Acher, Tewfik Ziadi, Roberto E Lopez-Herrejon, and Jabier Martinez. Seventh international workshop on reverse variability engineering (REVE 2019) (2019). In SPLC 2019 - 23rd International Systems and Software Product Line Conference published by ACM Press [PDF] [bib]
[57] Paul Temple, Mathieu Acher, and Jean-Marc Jézéquel. Empirical Assessment of Multimorphic Testing (2021). In IEEE Transactions on Software Engineering (TSE) published by Institute of Electrical and Electronics Engineers [PDF] [bib][DOI] 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.
[58] Paul Temple, Mathieu Acher, Gilles Perrouin, Battista Biggio, Jean-Marc Jézéquel, and Fabio Roli. Towards Quality Assurance of Software Product Lines with Adversarial Configurations (2019). In 23rd International Systems and Software Product Line Conference [PDF] [bib] 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.
[59] Marcel Heinz, Ralf Lämmel, and Mathieu Acher. Discovering Indicators for Classifying Wikipedia Articles in a Domain: A Case Study on Software Languages (2019). In SEKE 2019 - The 31st International Conference on Software Engineering and Knowledge Engineering [PDF] [bib]
[60] Quentin Plazar, Mathieu Acher, Gilles Perrouin, Xavier Devroey, and Maxime Cordy. Uniform Sampling of SAT Solutions for Configurable Systems: Are We There Yet? (2019). In ICST 2019 - 12th International Conference on Software Testing, Verification, and Validation [PDF] [bib] 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.
[61] Benoit Amand, Maxime Cordy, Patrick Heymans, Mathieu Acher, Paul Temple, and Jean-Marc Jézéquel. Towards Learning-Aided Configuration in 3D Printing: Feasibility Study and Application to Defect Prediction (2019). In VaMoS 2019 - 13th International Workshop on Variability Modelling of Software-Intensive Systems [PDF] [bib] 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.
[62] Gilles Perrouin, Mathieu Acher, Maxime Cordy, and Xavier Devroey. Proceedings of the 1st International Workshop on Machine Learning and Software Engineering in Symbiosis, MASES@ASE 2018, Montpellier, France, September 3, 2018 [editor of the proceedings] (2018). published by ACM [PDF] [bib][DOI]
[63] Mathieu Acher, Roberto E Lopez-Herrejon, and Rick Rabiser. Teaching Software Product Lines: A Snapshot of Current Practices and Challenges (Journal-First Abstract) (2018). In SPLC2018 - 22nd International Systems and Software Product Line Conference [PDF] [bib] 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.
[64] Axel Halin, Alexandre Nuttinck, Mathieu Acher, Xavier Devroey, Gilles Perrouin, and Benoit Baudry. Test them all, is it worth it? Assessing configuration sampling on the JHipster Web development stack (2019). In Empirical Software Engineering (ESE) published by Springer Verlag [PDF] [bib][DOI][Youtube] Empirical Software Engineering journal 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.
[65] Mathieu Acher, Paul Temple, Jean-Marc Jézéquel, José Angel Galindo Duarte, Jabier Martinez, and Tewfik Ziadi. VaryLaTeX: Learning Paper Variants That Meet Constraints (2018). In 12th International Workshop on Variability Modelling of Software-intensive Systems (VaMoS'18) [PDF] [bib][Youtube] 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.
[66] Mauricio Alférez, Mathieu Acher, José A Galindo, Benoit Baudry, and David Benavides. Modeling Variability in the Video Domain: Language and Experience Report (2019). In Software Quality Journal published by Springer Verlag [PDF] [bib][DOI] 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.
[67] Paul Temple, Mathieu Acher, Battista Biggio, Jean-Marc Jézéquel, and Fabio Roli. Towards Adversarial Configurations for Software Product Lines (2018). In CoRR [PDF] [bib]
[68] Paul Temple, Mathieu Acher, and Jean-Marc Jézéquel. Multimorphic Testing (2018). In ACM/IEEE 40th International Conference on Software Engineering: Companion Proceedings [PDF] [bib][DOI]
[69] Jabier Martinez, Jean-Sébastien Sottet, Alfonso Garcia Frey, Tegawendé Bissyandé, Tewfik Ziadi, Jacques Klein, Paul Temple, Mathieu Acher, and Yves Le Traon. Towards Estimating and Predicting User Perception on Software Product Variants (2018). In ICSR 2018 - International Conference on Software Reuse [PDF] [bib] 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.
[70] Axel Halin, Alexandre Nuttinck, Mathieu Acher, Xavier Devroey, Gilles Perrouin, and Benoit Baudry. Test them all, is it worth it? A ground truth comparison of configuration sampling strategies (2017). In CoRR [PDF] [bib] 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.
[71] 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. Proceedings of the 21st International Systems and Software Product Line Conference, SPLC 2017, Volume A, Sevilla, Spain, September 25-29, 2017 [editor of the proceedings] (2017). published by ACM [PDF] [bib][DOI]
[72] Quentin Plazar, Mathieu Acher, Sébastien Bardin, and Arnaud Gotlieb. Efficient and Complete FD-Solving for Extended Array Constraints (2017). In IJCAI 2017 [PDF] [bib] 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.
[73] Paul Temple, Mathieu Acher, Jean-Marc Jézéquel, and Olivier Barais. Learning-Contextual Variability Models (2017). In IEEE Software published by Institute of Electrical and Electronics Engineers (IEEE) [PDF] [bib] 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.
[74] Mathieu Acher, Roberto Erick Lopez-Herrejon, and Rick Rabiser. Teaching Software Product Lines: A Snapshot of Current Practices and Challenges (2017). In ACM Transactions on Computing Education (TOCE) published by ACM [bib][PDF] 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.
[75] Axel Halin, Alexandre Nuttinck, Mathieu Acher, Xavier Devroey, Gilles Perrouin, and Patrick Heymans. Yo Variability! JHipster: A Playground for Web-Apps Analyses (2017). In 11th International Workshop on Variability Modelling of Software-intensive Systems (VaMoS'17) [PDF] [bib][DOI] 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.
[76] Paul Temple, Mathieu Acher, Jean-Marc A Jézéquel, Léo A Noel-Baron, and José A Galindo. Learning-Based Performance Specialization of Configurable Systems (2017). [PDF] [bib] 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.
[77] Sana Ben Nasr, Guillaume Bécan, Mathieu Acher, João Bosco Ferreira Filho, Nicolas Sannier, Benoit Baudry, and Jean-Marc Davril. Automated Extraction of Product Comparison Matrices From Informal Product Descriptions (2017). In Journal of Systems and Software (JSS) published by Elsevier [PDF] [bib][DOI] 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.
[78] João Bosco Ferreira Filho, Mathieu Acher, and Olivier Barais. Software Unbundling: Challenges and Perspectives (2016). In Trans. Modularity and Composition published by LNCS [PDF] [bib] 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.
[79] Roberto Erick Lopez-Herrejon, Jabier Martinez, Tewfik Ziadi, and Mathieu Acher. Fourth international workshop on reverse variability engineering (REVE 2016) (2016). In Proceedings of the 20th International Systems and Software Product Line Conference, SPLC 2016, Beijing, China, September 16-23, 2016 [PDF] [bib][DOI]
[80] Gilles Perrouin, Moussa Amrani, Mathieu Acher, Benoit Combemale, Axel Legay, and Pierre-Yves Schobbens. Featured model types: Towards Systematic Reuse in Modelling Language Engineering (2016). In MiSE '16 - 8th International Workshop on Modeling in Software Engineering published by ACM [PDF] [bib][DOI] 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.
[81] Jérome Le Noir, Sébastien Madelénat, Christophe Labreuche, Olivier Constant, Grégory Gailliard, Mathieu Acher, and Olivier Barais. A Decision-making Process for Exploring Architectural Variants in Systems Engineering (2016). In Software Product Lines Conference (SPLC) [PDF] [bib][DOI] 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.
[82] Gilles Perrouin, Mathieu Acher, Jean-Marc Davril, Axel Legay, and Patrick Heymans. A Complexity Tale: Web Configurators (2016). In VACE 2016 - 1st International Workshop on Variability and Complexity in Software Design Pages (co-located with ICSE'16) [PDF] [bib][DOI] 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.
[83] Paul Temple, José Angel Galindo Duarte, Mathieu Acher, and Jean-Marc Jézéquel. Using Machine Learning to Infer Constraints for Product Lines (2016). In Software Product Line Conference (SPLC'16) [PDF] [bib][DOI] 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.
[84] José A. Galindo, Mathieu Acher, Juan Manuel Tirado, Cristian Vidal, Benoit Baudry, and David Benavides. Exploiting the Enumeration of All Feature Model Configurations: A New Perspective with Distributed Computing (2016). In Software Product Line Conference (SPLC'16) [PDF] [bib][slides] 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.
[85] Mathieu Acher, and François Esnault. Large-scale Analysis of Chess Games with Chess Engines: A Preliminary Report (2016). [PDF] [bib] 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.
[86] Jin Hyung Kim, Axel Legay, Louis-Marie Traonouez, Mathieu Acher, and Sungwon Kang. A Formal Modeling and Analysis Framework for Software Product Line of Preemptive Real-Time Systems (2016). In Sympsosium on Applied Computing (SAC'16), software engineering track [bib][PDF] 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.
[87] Sophie Pinchinat, Mathieu Acher, and Didier Vojtisek. ATSyRa: An Integrated Environment for Synthesizing Attack Trees (2015). In Second International Workshop on Graphical Models for Security (GraMSec'15) co-located with CSF'15 [bib][PDF] 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.
[88] Jean-Marc Davril, Maxime Cordy, Patrick Heymans, and Mathieu Acher. Using fuzzy modeling for consistent definitions of product qualities in requirements (2015). In IEEE Second International Workshop on Artificial Intelligence for Requirements Engineering (AIRE'15) [bib][PDF][DOI] 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.
[89] Sana Ben Nasr, Guillaume Bécan, Mathieu Acher, Joao Bosco Ferreira Filho, Benoit Baudry, Nicolas Sannier, and Jean-Marc Davril. MatrixMiner: a red pill to architect informal product descriptions in the matrix (2015). In Proceedings of the 2015 10th Joint Meeting on Foundations of Software Engineering, (ESEC/FSE'15) [bib][PDF] 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.
[90] Mathieu Acher, Guillaume Bécan, Benoit Combemale, Benoit Baudry, and Jean-Marc Jézéquel. Product lines can jeopardize their trade secrets (2015). In Proceedings of the 2015 10th Joint Meeting on Foundations of Software Engineering (ESEC/FSE'15) [bib][PDF][slides] 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.
[91] Jean-Marc Davril, Mathieu Acher, Guillaume Bécan, and Patrick Heymans. Towards Breaking The Curse of Dimensionality in Reverse Engineering Feature Models (2015). In 17th International Configuration Workshop (ConfWS'15) [bib][PDF] 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.
[92] Guillaume Bécan, Razieh Behjati, Arnaud Gotlieb, and Mathieu Acher. Synthesis of Attributed Feature Models From Product Descriptions (2015). In 19th International Software Product Line Conference (SPLC'15) [bib][PDF][slides] (research track, long paper) 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.
[93] João Bosco Ferreira Filho, Simon Allier, Mathieu Acher, Olivier Barais, and Benoit Baudry. Assessing Product Line Derivation Operators Applied to Java Source Code: An Empirical Study (2015). In 19th International Software Product Line Conference (SPLC'15) [bib][PDF][slides] (research track, long paper) 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.
[94] Roberto E. Lopez-Herrejon, Tewfik Ziadi, Jabier Martinez, Anil Kumar Thurimella, and Mathieu Acher. Third International Workshop on Reverse Variability Engineering (REVE 2015) (2015). In Proceedings of the 19th International Conference on Software Product Line, SPLC 2015, Nashville, TN, USA, July 20-24, 2015 [PDF] [bib][DOI]
[95] Thomas Degueule, João Bosco Ferreira Filho, Olivier Barais, Mathieu Acher, Jérôme Lenoir, Olivier Constant, Sebastien Madelenat, Gregory Gailliard, and Godefroy Burlot. Tooling Support for Variability and Architectural Patterns in Systems Engineering (2015). In 19th International Software Product Line Conference (SPLC'15) [bib][PDF] (demonstration and tool track) 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).
[96] Mathieu Acher. Talk at Third International Workshop on Reverse Variability Engineering (REVE'15) (2015). In Proceedings of the 19th International Conference on Software Product Line (SPLC'15) [bib][slides] 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
[97] João Bosco Ferreira Filho, Mathieu Acher, and Olivier Barais. Challenges on Software Unbundling: Growing and Letting Go (2015). In 14th International Conference on Modularity'15 [PDF] [bib] 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.
[98] Mathieu Acher, Roberto Erick Lopez-Herrejon, and Rick Rabiser. SPLTea 2015: Second International Workshop on Software Product Line Teaching (2015). In 19th International Software Product Line Conference (SPLC'15) [bib][PDF] 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
[99] Guillaume Bécan, Razieh Behjati, Arnaud Gotlieb, and Mathieu Acher. Synthesis of Attributed Feature Models From Product Descriptions: Foundations (2015). Research Report RR-8680 [PDF] [bib] 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.
[100] Guillaume Bécan, Mathieu Acher, Jean-Marc Jézéquel, and Thomas Menguy. On the Variability Secrets of an Online Video Generator (2015). In Variability Modelling of Software-intensive Systems (VaMoS'15) [PDF] [bib][DOI] 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.
[101] Guillaume Bécan, Mathieu Acher, Benoit Baudry, and Sana Ben Nasr. Breathing Ontological Knowledge Into Feature Model Synthesis: An Empirical Study (2016). In Empirical Software Engineering (ESE) published by Springer [PDF] [bib][DOI] 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.
[102] Mathieu Acher, Benoit Combemale, and Philippe Collet. Metamorphic Domain-Specific Languages: A Journey Into the Shapes of a Language (2014). In Onward! Essays (co-located with SPLASH and OOPSLA) [PDF] [bib][DOI][slides] 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.
[103] Sophie Pinchinat, Mathieu Acher, and Didier Vojtisek. Towards Synthesis of Attack Trees for Supporting Computer-Aided Risk Analysis (2014). In Workshop on Formal Methods in the Development of Software (co-located with SEFM) [PDF] [bib] 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.
[104] Mauricio Alférez, José A. Galindo, Mathieu Acher, and Benoit Baudry. Modeling Variability in the Video Domain: Language and Experience Report (2014). Research Report RR-8576 [PDF] [bib] 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.
[105] Guillaume Bécan, Nicolas Sannier, Mathieu Acher, Olivier Barais, Arnaud Blouin, and Benoit Baudry. Automating the Formalization of Product Comparison Matrices (2014). In 29th IEEE/ACM International Conference on Automated Software Engineering (ASE'14) [PDF] [bib][DOI][slides] 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.
[106] Joao Bosco Ferreira Filho, Olivier Barais, Mathieu Acher, Jérôme Le Noir, Axel Legay, and Benoit Baudry. Generating Counterexamples of Model-based Software Product Lines (2014). In International Journal on Software Tools for Technology Transfer (STTT) published by Springer [PDF] [bib] 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.
[107] Mathieu Acher, Benoit Baudry, Olivier Barais, and Jean-Marc Jézéquel. Customization and 3D Printing: A Challenging Playground for Software Product Lines (2014). In 18th International Software Product Line Conference (SPLC'14), research track [PDF] [bib][slides] 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.
[108] Mathieu Acher, Olivier Barais, Benoit Baudry, Arnaud Blouin, Johann Bourcier, Benoit Combemale, Jean-Marc Jézéquel, and Noël Plouzeau. Software Diversity: Challenges to handle the imposed, Opportunities to harness the chosen (2014). In GDR GPL [PDF] [bib] 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.
[109] Edoardo Vacchi, Walter Cazzola, Benoit Combemale, and Mathieu Acher. Automating Variability Model Inference for Component-Based Language Implementations (2014). In 18th International Software Product Line Conference (SPLC'14) published by ACM [PDF] [bib] 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.
[110] Hamza Samih, Hélène Le Guen, Ralf Bogusch, Mathieu Acher, and Benoit Baudry. An Approach to Derive Usage Models Variants for Model-based Testing (2014). In 26th IFIP International Conference on Testing Software and Systems (ICTSS'2014) published by Springer [PDF] [bib] 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.
[111] Dimitri Van Landuyt, Steven Op De Beeck, Aram Hovsepyan, Sam Michiels, Wouter Joosen, Sven Meynckens, Gjalt De Jong, Olivier Barais, and Mathieu Acher. Towards Managing Variability in the Safety Design of an Automotive Hall Effect Sensor (2014). In 18th International Software Product Line Conference (SPLC'14), industrial track [PDF] [bib] 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:\~it 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.
[112] Sana Ben Nasr, Nicolas Sannier, Mathieu Acher, and Benoit Baudry. Moving Toward Product Line Engineering in a Nuclear Industry Consortium (2014). In 18th International Software Product Line Conference (SPLC'2014), industrial track [PDF] [bib] 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.
[113] Mathieu Acher, Mauricio Alferez, José A. Galindo, Pierre Romenteau, and Benoit Baudry. ViViD: A Variability-Based Tool for Synthesizing Video Sequences (2014). In 18th International Software Product Line Conference (SPLC'14), tool track [PDF] [bib] 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.
[114] Guillaume Bécan, Sana Ben Nasr, Mathieu Acher, and Benoit Baudry. WebFML: Synthesizing Feature Models Everywhere (2014). In 18th International Software Product Line Conference (SPLC'14), tool track [PDF] [bib][slides] 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).
[115] Mathieu Acher, Roberto Erick Lopez-Herrejon, and Rick Rabiser. SPLTea 2014: First International Workshop on Software Product Line Teaching (2014). In 18th International Software Product Line Conference (SPLC'14) [PDF] [bib] 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.
[116] Hamza Samih, Mathieu Acher, Ralf Bogusch, Hélène Le Guen, and Benoit Baudry. Deriving Usage Model Variants for Model-based Testing: An Industrial Case Study (2014). In 19th International Conference on Engineering of Complex Computer Systems (ICECCS'14) [PDF] [bib] 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.
[117] Mathieu Acher, Philippe Collet, and Philippe Lahire. Software Architectures and Multiple Variability (2014) chapter book, in Software Architecture 2 (2014). published by Wiley [bib][PDF] 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.
[118] José A. Galindo, Mauricio Alferez, Mathieu Acher, Benoit Baudry, and David Benavides. A Variability-based Testing Approach for Synthesizing Video Sequences (2014). In International Symposium on Software Testing and Analysis (ISSTA'14) acceptance rate: 28% [bib][PDF] 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.
[119] Nicolas Sannier, Guillaume Bécan, Mathieu Acher, Sana Ben Nasr, and Benoit Baudry. Comparing or Configuring Products: Are We Getting the Right Ones? (2014). In 8th International Workshop on Variability Modelling of Software-intensive Systems (VaMoS'14) published by ACM acceptance rate: 38% [bib][PDF][slides] 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.
[120] Uli Fahrenberg, Mathieu Acher, Axel Legay, and Andrzej Wasowski. Sound Merging and Differencing for Class Diagrams (2014). In 17th International Conference on Fundamental Approaches to Software Engineering (FASE'14) published by Springer acceptance rate: 23% [PDF] [bib] 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.
[121] Guillaume Bécan, Mathieu Acher, Benoit Baudry, and Sana Ben Nasr. Breathing Ontological Knowledge Into Feature Model Management (2013). Technical Report RT-0441 [PDF] [bib] 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.
[122] Mathieu Acher, Philippe Collet, and Philippe Lahire. Architectures logicielles et variabilité multiple (2014) chapter book, in Architectures logicielles et variabilité multiple (2014). published by Lavoisier [bib][PDF] 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.
[123] Ebrahim Khalil Abbasi, Mathieu Acher, Patrick Heymans, and Anthony Cleve. Reverse Engineering Web Configurators (2014). In 17th European Conference on Software Maintenance and Reengineering (CSMR'14) acceptance rate: 31% [bib][PDF] 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.
[124] Mathieu Acher, Roberto Erick Lopez-Herrejon, and Rick Rabiser. A Survey on Teaching of Software Product Lines (2014). In Eight International Workshop on Variability Modelling of Software-Intensive Systems (VaMoS'14) published by ACM [PDF] [bib][slides] 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.
[125] Nicolas Sannier, Mathieu Acher, and Benoit Baudry. From Comparison Matrix to Variability Model: The Wikipedia Case Study (2013). In 28th IEEE/ACM International Conference on Automated Software Engineering (ASE'13) acceptance rate: 23% [PDF] [bib][slides] 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.
[126] Marianela Ciolfi Felice, Joao Bosco Ferreira Filho, Mathieu Acher, Arnaud Blouin, and Olivier Barais. Interactive Visualisation of Products in Online Configurators: A Case Study for Variability Modelling Technologies (2013). In 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 [bib][PDF] 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.
[127] Mathieu Acher, Benoit Combemale, Philippe Collet, Olivier Barais, Philippe Lahire, and Robert B. France. Composing your Compositions of Variability Models (2013). In ACM/IEEE 16th International Conference on Model Driven Engineering Languages and Systems (MODELS'13) acceptance rate: 23% [bib][PDF] 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.
[128] Philippe Collet, Philippe Lahire, Mathieu Acher, and Robert France. Feature Model Management: Smart Operations and Language Support (tutorial) (2013). In ACM/IEEE 16th International Conference on Model Driven Engineering Languages and Systems (MODELS'13) [PDF] [bib] 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.
[129] Jean-Marc Davril, Edouard Delfosse, Negar Hariri, Mathieu Acher, Jane Cleland-Huang, and Patrick Heymans. Feature Model Extraction from Large Collections of Informal Product Descriptions (2013). In European Software Engineering Conference and the ACM SIGSOFT Symposium on the Foundations of Software Engineering (ESEC/FSE'13) acceptance rate: 20% [bib][PDF] 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.
[130] João Bosco Ferreira Filho, Olivier Barais, Mathieu Acher, Jérôme Le Noir, and Benoit Baudry. Generating Counterexamples of Model-based Software Product Lines: An Exploratory Study (2013). In 17th International Conference on Software Product Lines (SPLC'13) acceptance rate: 33% [bib][PDF] Best Student Paper Award 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.
[131] Mathieu Acher, Benoit Combemale, and Olivier Barais. Model-Based Variability Management (tutorial) (2013). In Three co-located international conferences ECOOP'13, ECMFA'13 and ECSA'13 [PDF] [bib][slides] 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.
[132] Mathieu Acher, Anthony Cleve, Philippe Collet, Philippe Merle, Laurence Duchien, and Philippe Lahire. Extraction and Evolution of Architectural Variability Models in Plugin-based Systems (2013). In Software and Systems Modeling (SoSyM) [bib][PDF] 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.
[133] Ebrahim Khalil Abbasi, Arnaud Hubaux, Mathieu Acher, Quentin Boucher, and Patrick Heymans. The Anatomy of a Sales Configurator: An Empirical Study of 111 Cases (2013). In 25th International Conference on Advanced Information Systems Engineering (CAiSE'13) acceptance rate: 16.6% [PDF] [bib] 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.
[134] Mathieu Acher, Patrick Heymans, Anthony Cleve, Jean-Luc Hainaut, and Benoit Baudry. Support for Reverse Engineering and Maintaining Feature Models (2013). In Seventh International Workshop on Variability Modelling of Software-Intensive Systems (VaMoS'13) published by ACM acceptance rate: 42% [bib][PDF] 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.
[135] Mathieu Acher, Philippe Collet, Philippe Lahire, and Robert France. FAMILIAR: A Domain-Specific Language for Large Scale Management of Feature Models (2013). In Science of Computer Programming (SCP) Special issue on programming languages [bib][PDF][DOI] 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.
[136] Arnaud Hubaux, Mathieu Acher, T. T. Tun, Patrick Heymans, Philippe Collet, and Philippe Lahire. Separating Concerns in Feature Models: Retrospective and Multi-View Support (2013) chapter book, 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.) (2013). published by Springer [bib][PDF] 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.
[137] Mathieu Acher, Patrick Heymans, Philippe Collet, Clément Quinton, Philippe Lahire, and Philippe Merle. Feature Model Differences (2012). In 24th International Conference on Advanced Information Systems Engineering (CAiSE'12) published by Springer acceptance rate: 14% [PDF] [bib] 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.
[138] Mathieu Acher, Philippe Collet, Philippe Lahire, and Robert France. Separation of Concerns in Feature Modeling: Support and Applications (2012). In Aspect-Oriented Software Development (AOSD'12) published by ACM acceptance rate: 25% [PDF] [bib] 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.
[139] Mathieu Acher, Philippe Collet, Alban Gaignard, Philippe Lahire, Johan Montagnat, and Robert France. Composing Multiple Variability Artifacts to Assemble Coherent Workflows (2012). In Software Quality Journal Special issue on Quality Engineering for Software Product Lines [PDF] [bib] 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.
[140] Mathieu Acher, Raphaël Michel, and Patrick Heymans. Next-Generation Model-based Variability Management: Languages and Tools (2012). In ACM 16th International Software Product Line Conference (SPLC’12) [bib][PDF]
[141] Mathieu Acher, Patrick Heymans, Philippe Collet, and Philippe Lahire. Next-Generation Model-based Variability Management: Languages and Tools (tutorial) (2012). In ACM/IEEE 15th International Conference on Model Driven Engineering Languages \& Systems (MODELS'2012) [PDF] [bib] 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.
[142] Mathieu Acher, Raphaël Michel, and Patrick Heymans. Next-Generation Model-based Variability Management: Languages and Tools (Tutorial) (2012). In Conf\'erence en Ing\'enieriE du Logiciel (CIEL'12) [bib]
[143] Sabine Moisan, Jean-Paul Rigault, and Mathieu Acher. A Feature-based Approach to System Deployment and Adaptation (2012). In Proceedings of the 2012 international workshop on Modeling in software engineering at ICSE 2012 (MiSE'12) published by IEEE acceptance rate: 41% [bib][PDF]
[144] Quentin Boucher, Ebrahim Abbasi, Arnaud Hubaux, Gilles Perrouin, Mathieu Acher, and Patrick Heymans. Towards More Reliable Configurators: A Re-engineering Perspective (2012). In Third International Workshop on Product LinE Approaches in Software Engineering at ICSE 2012 (PLEASE'12) acceptance rate: 57% [bib][PDF] 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.
[145] Mathieu Acher, Raphaël Michel, Patrick Heymans, Philippe Collet, and Philippe Lahire. Languages and Tools for Managing Feature Models (2012). In Third International Workshop on Product LinE Approaches in Software Engineering at ICSE 2012 (PLEASE'12) acceptance rate: 57% [bib][PDF]
[146] Jérôme Le Noir, Olivier Barais, Joao Bosco Ferreira Filho, Mathieu Acher, and Jean-Marc Jézéquel. Modelling variability using CVL; A step by step tutorial (2012). In Journ\'ee Lignes de Produits [bib]
[147] Mathieu Acher, Anthony Cleve, Gilles Perrouin, Patrick Heymans, Philippe Collet, Philippe Lahire, and Charles Vanbeneden. On Extracting Feature Models From Product Descriptions (2012). In Sixth International Workshop on Variability Modelling of Software-intensive Systems (VaMoS'12) published by ACM acceptance rate: 51% [PDF] [bib] 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.
[148] Mathieu Acher, Anthony Cleve, Philippe Collet, Philippe Merle, Laurence Duchien, and Philippe Lahire. Reverse Engineering Architectural Feature Models (2011). In 5th European Conference on Software Architecture (ECSA'11), long paper published by Springer acceptance rate: 25% [bib][PDF][slides] 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.
[149] Mathieu Acher. Managing Multiple Feature Models: Foundations, Language, and Applications (2011). [bib][slides]
[150] Mathieu Acher, Philippe Collet, Philippe Lahire, and Robert France. Decomposing Feature Models: Language, Environment, and Applications (2011). In Automated Software Engineering (ASE'11), short paper: demonstration track published by IEEE/ACM [PDF] [bib][DOI][slides] 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.
[151] Mathieu Acher, Philippe Collet, Philippe Lahire, and Robert France. Slicing Feature Models (2011). In 26th IEEE/ACM International Conference On Automated Software Engineering (ASE'11), short paper published by IEEE/ACM [PDF] [bib][DOI][slides] 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.
[152] Sabine Moisan, Jean-Paul Rigault, Mathieu Acher, Philippe Collet, and Philippe Lahire. Run Time Adaptation of Video-Surveillance Systems: A Software Modeling Approach (2011). In 8th International Conference on Computer Vision Systems (ICVS'2011) published by Springer Verlag [bib][PDF]
[153] Mathieu Acher, Philippe Collet, Philippe Lahire, Sabine Moisan, and Jean-Paul Rigault. Modeling Variability from Requirements to Runtime (2011). In 16th International Conference on Engineering of Complex Computer Systems (ICECCS'11) published by IEEE acceptance rate: 31% [bib][PDF]
[154] Mathieu Acher, Philippe Collet, Philippe Lahire, and Robert France. Managing Feature Models with FAMILIAR: a Demonstration of the Language and its Tool Support (2011). In Fifth International Workshop on Variability Modelling of Software-intensive Systems (VaMoS'11) published by ACM acceptance rate: 55% [bib]
[155] Mathieu Acher, Philippe Collet, Philippe Lahire, and Robert France. A Domain-Specific Language for Managing Feature Models (2011). In Symposium on Applied Computing (SAC'11) published by ACM acceptance rate: 33% [PDF] [bib] 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.
[156] Mathieu Acher, Philippe Collet, Philippe Lahire, and Robert France. FAMILIAR, a Language and its Environment for Feature Model Management (2010). In Journ\'ee Lignes de Produits. Ma\^\itriser la Diversit\'e [bib]
[157] Martin Fagereng Johansen, Franck Fleurey, Mathieu Acher, Philippe Collet, and Philippe Lahire. Exploring the Synergies Between Feature Models and Ontologies (2010). In International Workshop on Model-driven Approaches in Software Product Line Engineering (MAPLE 2010) published by Lancaster University [PDF] [bib] 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.
[158] Mathieu Acher, Philippe Collet, Franck Fleurey, Philippe Lahire, Sabine Moisan, and Jean-Paul Rigault. Modeling Context and Dynamic Adaptations with Feature Models (2009). [PDF] [bib] (MRT'09, poster)
[159] Mathieu Acher, Philippe Collet, Philippe Lahire, and Robert France. FAMILIAR (FeAture Model scrIpt Language for manIpulation and Automatic Reasoning): https://nyx.unice.fr/projects/familiar/ (2011). [bib]
[160] Mathieu Acher, Anthony Cleve, Philippe Collet, Philippe Merle, Laurence Duchien, and Philippe Lahire. Reverse Engineering Architectural Feature Models (2011). In 10th Belgian-Netherlands Seminar on Software Evolution (BENEVOL) [PDF] [bib][slides] (BENEVOL'11)
[161] Mathieu Acher, Philippe Collet, Philippe Lahire, and Robert France. Managing Multiple Software Product Lines Using Merging Techniques (2010). [PDF] [bib] 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.
[162] Mathieu Acher, Philippe Collet, Philippe Lahire, and Robert France. Managing Variability in Worklow with Feature Model Composition Operators (2010). In 9th International Conference on Software Composition (SC'10) published by Springer acceptance rate: 28% [bib][PDF][slides] 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.
[163] Mathieu Acher, Philippe Collet, Philippe Lahire, and Robert France. Comparing Approaches to Implement Feature Model Composition (2010). In 6th European Conference on Modelling Foundations and Applications (ECMFA) published by Springer acceptance rate: 31% [bib][PDF][slides] 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.
[164] Mathieu Acher, Philippe Collet, Philippe Lahire, and Robert France. Composing Feature Models (2009). In 2nd International Conference on Software Language Engineering (SLE'09) published by LNCS acceptance rate: 19% [bib][PDF][slides] Most Influential Paper Award at SLE 2019 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.
[165] Mathieu Acher, Philippe Collet, Franck Fleurey, Philippe Lahire, Sabine Moisan, and Jean-Paul Rigault. Modeling Context and Dynamic Adaptations with Feature Models (2009). In 4th International Workshop Models@run.time at Models 2009 (MRT'09) [bib][PDF] 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.
[166] Mathieu Acher, Philippe Lahire, Sabine Moisan, and Jean-Paul Rigault. Tackling High Variability in Video Surveillance Systems through a Model Transformation Approach (2009). In MiSE '09: Proceedings of the 2009 international workshop on Modeling in software engineering at ICSE 2009 (MiSE'09) [bib][PDF] 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.
[167] Mathieu Acher, Philippe Collet, Philippe Lahire, and Johan Montagnat. Imaging Services on the Grid as a Product Line: Requirements and Architecture (2008). In Service-Oriented Architectures and Software Product Lines - Putting Both Together (SOAPL'08) published by IEEE Computer Society [bib][PDF] 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.
[168] Mathieu Acher, Philippe Collet, and Philippe Lahire. Issues in Managing Variability of Medical Imaging Grid Services (2008). In MICCAI-Grid Workshop (MICCAI-Grid) [bib][PDF] 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.
[169] Mathieu Acher. Vers une ligne de services pour la grille: application \`a l’imagerie m\'edicale (2008). [PDF] [bib]
[170] Mathieu Acher, and Vincent Aranega. Un compte rendu de la conf\'erence Models 2008 (Toulouse, France) (2008). [PDF] [bib]
