Challenges

Reusability of software artifacts is a central notion that has been thoroughly studied and used by both academics and industrials since the early days of software construction. Essentially, designing reusable artifacts allows the construction of large systems from smaller parts that have been separately developed and validated, thus reducing the development costs by capitalizing on previous engineering efforts. However, it is still hardly possible for language designers to design typical language artifacts (e.g. language constructs, grammars, editors or compilers) in a reusable way. The current state of the practice usually prevents the reusability of language artifacts from one language to another, consequently hindering the emergence of real engineering techniques around software languages. Conversely, concepts and mechanisms that enable artifacts reusability abound in the software engineering community.

Variability in modeling languages occur in the definition of the abstract and concrete syntax as well as in the specification of the language's semantics. The major challenges met when addressing the need for variability are: (i) to set principles for modeling language units that support the modular specification of a modeling language; and (ii) to design mechanisms to assemble these units into a complete language, according to the set of authorized variation points for the modeling language family.

A new generation of complex software-intensive systems (for example smart health support, smart grid, building energy management, and intelligent transportation systems) gives new opportunities for leveraging modeling languages. The development of these systems requires expertise in diverse domains. Consequently, different types of stakeholders (e.g., scientists, engineers and end-users) must work in a coordinated manner on various aspects of the system across multiple development phases. DSMLs can be used to support the work of domain experts who focus on a specific system aspect, but they can also provide the means for coordinating work across teams specializing in different aspects and across development phases. The support and integration of DSMLs leads to what we call the globalization of modeling languages, i.e. the use of multiple languages for the coordinated development of diverse aspects of a system. One can make an analogy with world globalization in which relationships are established between sovereign countries to regulate interactions (e.g., travel and commerce related interactions) while preserving each country's independent existence.

Scientific objectives

We address reuse and variability challenges through the investigation of the time-honored concepts of substitutability, inheritance and components, evaluate their relevance for language designers and provide tools and methods for their inclusion in software language engineering. We will develop novel techniques for the modular construction of language extensions with support to model syntactical variability. From the semantics perspective, we investigate extension mechanisms for the specification of variability in operational semantics, focusing on static introduction and heterogeneous models of computation. The definition of variation points for the three aspects of the language definition provides the foundations for the novel concept Language Unit (LU) as well as suitable mechanisms to compose such units.

We explore the necessary breakthrough in software languages to support modeling and simulation of heterogeneous and open systems. This work relies on the specification of executable domain specific modeling languages (DSMLs) to formalize the various concerns of a software-intensive system, and of models of computation (MoCs) to explicitly model the concurrency, time and communication of such DSMLs. We develop a framework that integrates the necessary foundations and facilities for designing and implementing executable and concurrent domain-specific modeling languages. This framework also provides unique features to specify composition operators between (possibly heterogeneous) DSMLs. Such specifications are amenable to support the edition, execution, graphical animation and analysis of heterogeneous models. The objective is to provide both a significant improvement to MoCs and DSMLs design and implementation and to the simulation based validation and verification of complex systems.

We see an opportunity for the automatic diversification of programs' computation semantics, for example through the diversification of compilers or virtual machines. The main impact of this artificial diversity is to provide flexible computation and thus ease adaptation to different execution conditions. A combination of static and dynamic analysis could support the identification of what we call plastic computation zones in the code. We identify different categories of such zones: (i) areas in the code in which the order of computation can vary (e.g., the order in which a block of sequential statements is executed); (ii) areas that can be removed, keeping the essential functionality  114 (e.g., skip some loop iterations); (iii) areas that can replaced by alternative code (e.g., replace a try-catch by a return statement). Once we know which zones in the code can be randomized, it is necessary to modify the model of computation to leverage the computation plasticity. This consists in introducing variation points in the interpreter to reflect the diversity of models of computation. Then, the choice of a given variation is performed randomly at run time.

Challenges

A fundamental problem is that the number of variants can be exponential in the number of options (features). Already with 300 boolean configuration options, approximately ${10}^{90}$ configurations exist – more than the estimated count of atoms in the universe. Domains like automotive or operating systems have to manage more than 10000 options (e.g., Linux). Practitioners face the challenge of developing billions of variants. It is easy to forget a necessary constraint, leading to the synthesis of unsafe variants, or to under-approximate the capabilities of the software platform. Scalable modelling techniques are therefore crucial to specify and reason about a very large set of variants.

Model-driven development supports two approaches to deal with the increasing number of concerns in complex systems: multi-view modeling, i.e. when modeling each concern separately, and variability modeling. However, there is little support to combine both approaches consistently. Techniques to integrate both approaches will enable the construction of a consistent set of views and variation points in each view.

The design, construction and maintenance of software families have a major impact on software testing. Among the existing challenges, we can cite: the selection of test cases for a specific variant; the evolution of test suites with integration of new variants; the combinatorial explosion of the number of software configurations to be tested. Novel model-based techniques for test generation and test management in a software product line context are needed to overcome state-of-the-art limits we already observed in some projects.

Scientific objectives

We aim at developing scalable reasoning techniques to automatically analyze variability models and their interactions with other views on the software intensive system (requirements, architecture, design, code). These techniques provide two major advancements in the state of the art: (1) an extension of the semantics of variability models in order to enable the definition of attributes (e.g., cost, quality of service, effort) on features and to include these attributes in the reasoning; (2) an assessment of the consistent specification of variability models with respect to system views (since variability is orthogonal to system modeling, it is currently possible to specify the different models in ways that are semantically meaningless). The former aspect of analysis is tackled through constraint solving and finite-domain constraint programming, while the latter aspect is investigated through automatic search-based and learning-based techniques for the exploration of the space of interaction between variability and view models.

We aim at developing procedures to reverse engineer dependencies and features' sets from existing software artefacts – be it source code, configuration files, spreadsheets (e.g., product comparison matrices) or requirements. We expect to scale up (e.g., for extracting a very large number of variation points) and guarantee some properties (e.g., soundness of configuration semantics, understandability of ontological semantics). For instance, when building complex software-intensive systems, textual requirements are captured in very large quantities of documents. In this context, adequate models to formalize the organization of requirements documents and automated techniques to support impact analysis (in case of changes in the requirements) have to be developed.

Challenges

The main challenge is to provide new homogeneous architectural modelling languages and efficient techniques that enable continuous software reconfiguration to react to changes. This work handles the challenges of handling the diversity of runtime infrastructures and managing the cooperation between different stakeholders. More specifically, the research developed in this axis targets the following dimensions of software diversity.

Platform architectural heterogeneity induces a first dimension of imposed diversity (type diversity). Platform reconfiguration driven by changing resources define another dimension of diversity (deployment diversity). To deal with these imposed diversity problems, we will rely on model based runtime support for adaptation, in the spirit of the dynamic distributed component framework developed by the Triskell team. Since the runtime environment composed of distributed, resource constrained hardware nodes cannot afford the overhead of traditional runtime adaptation techniques, we investigate the design of novel solutions relying on Models@runtime and on specialized tiny virtual machines to offer resource provisioning and dynamic reconfiguration.

Diversity can also be an asset to optimize software architecture. Architecture models must integrate multiple concerns in order to properly manage the deployment of software components over a physical platform. However, these concerns can contradict each other (e.g., accuracy and energy). In this context, we investigate automatic solutions to explore the set of possible architecture models and to establish valid trade-offs between all concerns in case of changes.

Scientific objectives

Automatic synthesis of optimal software architectures. Implementing a service over a distributed platform (e.g., a pervasive system or a cloud platform) consists in deploying multiple software components over distributed computation nodes. We aim at designing search-based solutions to (i) assist the software architect in establishing a good initial architecture (that balances between different factors such as cost of the nodes, latency, fault tolerance) and to automatically update the architecture when the environment or the system itself change. The choice of search-based techniques is motivated by the very large number of possible software deployment architectures that can be investigated and that all provide different trade-offs between qualitative factors. Another essential aspect that is supported by multi-objective search is to explore different architectural solutions that are not necessarily comparable. This is important when the qualitative factors are orthogonal to each other, such as security and usability for example.

Flexible software architecture for testing and data management. As the number of platforms on which software runs increases and different software versions coexist, the demand for testing environments also increases. For example, the number of testing environments to test a software patch or upgrade is the product of the number of execution environments the software supports and the number of coexisting versions of the software. Based on our first experiment on the synthesis of cloud environment using architectural models, our objective is to define a set of domain specific languages to catch the requirement and to design cloud environments for testing and data management of future internet systems from data centers to things. These languages will be interpreted to support dynamic synthesis and reconfiguration of a testing environment.

Runtime support for heterogeneous environments. Execution environments must provide a way to account or reserve resources for applications. However, current execution environments such as the Java Virtual Machine do not clearly define a notion of application: each framework has its own definition. For example, in OSGi, an application is a component, in JEE, an application is most of the time associated to a class loader, in the Multi-Tasking Virtual machine, an application is a process. The challenge consists in defining an execution environment that provides direct control over resources (CPU, Memory, Network I/O) independently from the definition of an application. We propose to define abstract resource containers to account and reserve resources on a distributed network of heterogeneous devices.

Challenges

One major challenge to build flexible and open yet dependable systems is that current software engineering techniques require architects to foresee all possible situations the system will have to face. However, openness and flexibility also mean unpredictability: unpredictable bugs, attacks, environmental evolution, etc. Current fault-tolerance  108 and security  82 techniques provide software systems with the capacity of detecting accidental and deliberate faults. However, existing solutions assume that the set of bugs or vulnerabilities in a system does not evolve. This assumption does not hold for open systems, thus it is essential to revisit fault-tolerance and security solutions to account for diverse and unpredictable faults.

Diversity is known to be a major asset for the robustness of large, open, and complex systems (e.g., economical or ecological systems). Following this observation, the software engineering literature provides a rich set of work that rely on implementation diversity in software systems in order to improve robustness to attacks or to changes in quality of service. These works range from N-version programming to obfuscation of data structures or control flow, to randomization of instruction sets. An essential and active challenge is to support the automatic synthesis and evolution of software diversity in open software-intensive systems. There is an opportunity to further enhance these techniques in order to cope with a wider diversity of faults, by multiplying the levels of diversity in the different software layers that are found in software-intensive systems (system, libraries, frameworks, application). This increased diversity must be based on artificial program transformations and code synthesis, which increase the chances of exploring novel solutions, better fitted at one point in time. The biological analogy also indicates that diversity should emerge as a side-effect of evolution, to prevent over-specialization towards one kind of diversity.

Scientific objectives

The main objective is to address one of the main limitations of N-version programming for fault-tolerant systems: the manual production and management of software diversity. Through automated injection of artificial diversity we aim at systematically increasing failure diversity and thus increasing the chances of early error detection at run-time. A fundamental assumption for this work is that software-intensive systems can be “good enough”  109, 121.

Proactive program diversification. We aim at establishing novel principles and techniques that favor the emergence of multiple forms of software diversity in software-intensive systems, in conjunction with the software adaptation mechanisms that leverage this diversity. The main expected outcome is a set of meta-design principles that maintain diversity in systems and the experimental demonstration of the effects of software diversity. Higher levels of diversity in the system provide a pool of software solutions that can eventually be used to adapt to situations unforeseen at design time (bugs, crash, attacks, etc.). Principles of automated software diversification rely on the automated synthesis of variants in a software product line, as well as finer-grained program synthesis combining unsound transformations and genetic programming to explore the space of mutational robustness.

Multi-tier software diversification. We name multi-tier diversification the fact of diversifying several application software components simultaneously. The novelty of our proposal, with respect to the software diversity state of the art, is to diversify the application-level code (for example, diversify the business logic of the application), focusing on the technical layers found in web applications. The diversification of application software code is expected to provide a diversity of failures and vulnerabilities in web server deployment. Web server deployment usually adopts a form of the Reactor architecture pattern, for scalability purposes: multiple copies of the server software stack, called request handlers, are deployed behind a load balancer. This architecture is very favorable for diversification, since by using the multiplicity of request handlers running in a web server we can simultaneously deploy multiple combinations of diverse software components. Then, if one handler is hacked or crashes the others should still be able to process client requests.

6.1.1 amiunique

• Name: amiunique
• Keywords: Privacy, Browser fingerprinting
• Scientific Description:

  The amiunique web site has been deployed in 2014 in the context of the DiverSE team research activities on browser fingerprinting to understand how software diversity can be leveraged to mitigate the impact of fingerprinting on the privacy of users. In 2018, it was migrated to the Spirals team where the research on browser fingerprinting still continues to this day.

  The web site has yielded multiple datasets of genuine fingerprints to understand the multiple facets of browser fingerprinting and how they can be used on the web to reinforce security. The web site presents regular updates to include the latest development in web technology and understand their impact of users' privacy.

  The whole source code of amiunique is open source and is distributed under the terms of the MIT license.

  Main innovative features:

  • canvas fingerprinting
  • WebGL fingerprinting
  • advanced JS features (platform, DNT, etc.)

  Impact: The website has been visited by more than 3,000,000 unique visitors since its creation and it has been showcased in several professional forums and tutorial sessions over the years. It produced multiple datasets over the years that were used in articles published in top-tier conferences. Amiunique has received in 2018 the prize "Protection de la vie privée" granted by Inria and the CNIL. The research around fingerprints in amiunique has also been a source of influence for the Brave web browser.

• Functional Description: This web site aims at informing visitors about browser fingerprinting and possible tools to mitigate its effect, as well as at collecting data about the fingerprints that can be found on the web. It collects browser fingerprints with the explicit agreement of the users (they have to click on a button on the home page). Fingerprints are composed of 17 attributes, which include regular HTTP headers as well as the most recent state of the art techniques (canvas fingerprinting, WebGL information).
• URL: https://amiunique.org/
• Authors: Pierre Laperdrix, Antonin Durey, Walter Rudametkin Ivey
• Contacts: Benoit Baudry, Pierre Laperdrix
• Partners: INSA Rennes, Université de Lille

6.1.2 FAMILIAR

• Keywords: Software line product, Configators, Customisation
• Scientific Description: FAMILIAR (for FeAture Model scrIpt Language for manIpulation and Automatic Reasoning) is a language for importing, exporting, composing, decomposing, editing, configuring, computing "diffs", refactoring, reverse engineering, testing, and reasoning about (multiple) feature models. All these operations can be combined to realize complex variability management tasks. A comprehensive environment is proposed as well as integration facilities with the Java ecosystem.
• Functional Description: Familiar is an environment for large-scale product customisation. From a model of product features (options, parameters, etc.), Familiar can automatically generate several million variants. These variants can take many forms: software, a graphical interface, a video sequence or even a manufactured product (3D printing). Familiar is particularly well suited for developing web configurators (for ordering customised products online), for providing online comparison tools and also for engineering any family of embedded or software-based products.
• URL: http://familiar-project.github.com
• Contact: Mathieu Acher
• Participants: Aymeric Hervieu, Benoit Baudry, Didier Vojtisek, Edward Mauricio Alferez Salinas, Guillaume Bécan, Joao Bosco Ferreira-Filho, Julien Richard-Foy, Mathieu Acher, Olivier Barais, Sana Ben Nasr

6.1.3 GEMOC Studio

• Name: GEMOC Studio
• Keywords: DSL, Language workbench, Model debugging
• Scientific Description: The language workbench put together the following tools seamlessly integrated to the Eclipse Modeling Framework (EMF):
  • Melange, a tool-supported meta-language to modularly define executable modeling languages with execution functions and data, and to extend (EMF-based) existing modeling languages.
  • MoCCML, a tool-supported meta-language dedicated to the specification of a Model of Concurrency and Communication (MoCC) and its mapping to a specific abstract syntax and associated execution functions of a modeling language.
  • GEL, a tool-supported meta-language dedicated to the specification of the protocol between the execution functions and the MoCC to support the feedback of the data as well as the callback of other expected execution functions.
  • BCOoL, a tool-supported meta-language dedicated to the specification of language coordination patterns to automatically coordinates the execution of, possibly heterogeneous, models.
  • Sirius Animator, an extension to the model editor designer Sirius to create graphical animators for executable modeling languages.
• Functional Description: The GEMOC Studio is an Eclipse package that contains components supporting the GEMOC methodology for building and composing executable Domain-Specific Modeling Languages (DSMLs). It includes two workbenches: The GEMOC Language Workbench: intended to be used by language designers (aka domain experts), it allows to build and compose new executable DSMLs. The GEMOC Modeling Workbench: intended to be used by domain designers to create, execute and coordinate models conforming to executable DSMLs. The different concerns of a DSML, as defined with the tools of the language workbench, are automatically deployed into the modeling workbench. They parametrize a generic execution framework that provides various generic services such as graphical animation, debugging tools, trace and event managers, timeline.
• URL: http://gemoc.org/studio.html
• Authors: Didier Vojtisek, Benoît Combemale, Cédric Brun, François Tanguy, Joël Champeau, Julien DeAntoni, Xavier Crégut
• Contacts: Benoît Combemale, Julien DeAntoni
• Participants: Didier Vojtisek, Dorian Leroy, Erwan Bousse, Fabien Coulon, Julien DeAntoni
• Partners: IRIT, ENSTA, I3S, OBEO, Thales TRT

6.1.4 Kevoree

• Keywords: M2M, Dynamic components, Iot, Heterogeneity, Smart home, Cloud, Software architecture, Dynamic deployment
• Scientific Description:

  Kevoree is an open-source models@runtime platform (http://www.kevoree.org ) to properly support the dynamic adaptation of distributed systems. Models@runtime basically pushes the idea of reflection [132] one step further by considering the reflection layer as a real model that can be uncoupled from the running architecture (e.g. for reasoning, validation, and simulation purposes) and later automatically resynchronized with its running instance.

  Kevoree has been influenced by previous work that we carried out in the DiVA project [132] and the Entimid project [135] . With Kevoree we push our vision of models@runtime [131] farther. In particular, Kevoree provides a proper support for distributed models@runtime. To this aim we introduced the Node concept to model the infrastructure topology and the Group concept to model semantics of inter node communication during synchronization of the reflection model among nodes. Kevoree includes a Channel concept to allow for multiple communication semantics between remoteComponents deployed on heterogeneous nodes. All Kevoree concepts (Component, Channel, Node, Group) obey the object type design pattern to separate deployment artifacts from running artifacts. Kevoree supports multiple kinds of very different execution node technology (e.g. Java, Android, MiniCloud, FreeBSD, Arduino, ...).

  Kevoree is distributed under the terms of the LGPL open source license.

  Main competitors:

  • the Fractal/Frascati eco-system (http://frascati.ow2.org/doc/1.4/frascati-userguide.html).
  • SpringSource Dynamic Module (http://spring.io/)
  • GCM-Proactive (http://proactive.inria.fr/)
  • OSGi (http://www.osgi.org)
  • Chef
  • Vagran (http://vagrantup.com/)

  Main innovative features:

  • distributed models@runtime platform (with a distributed reflection model and an extensible models@runtime dissemination set of strategies).
  • Support for heterogeneous node type (from Cyber Physical System with few resources until cloud computing infrastructure).
  • Fully automated provisioning model to correctly deploy software modules and their dependencies.
  • Communication and concurrency access between software modules expressed at the model level (not in the module implementation).
• Functional Description: Kevoree is an open-source models@runtime platform to properly support the dynamic adaptation of distributed systems. Models@runtime basically pushes the idea of reflection one step further by considering the reflection layer as a real model that can be uncoupled from the running architecture (e.g. for reasoning, validation, and simulation purposes) and later automatically resynchronized with its running instance.
• URL: http://kevoree.org/
• Authors: Jean Emile Dartois, Aymeric Hervieu, Olivier Barais
• Contact: Olivier Barais
• Participants: Aymeric Hervieu, Benoit Baudry, Francisco-Javier Acosta Padilla, Inti Gonzalez Herrera, Ivan Paez Anaya, Jacky Bourgeois, Jean Emile Dartois, Johann Bourcier, Manuel Leduc, Maxime Tricoire, Mohamed Boussaa, Noël Plouzeau, Olivier Barais

6.1.5 Melange

• Name: Melange
• Keywords: Model-driven engineering, Meta model, MDE, DSL, Model-driven software engineering, Dedicated langage, Language workbench, Meta-modelisation, Modeling language, Meta-modeling
• Scientific Description:

  Melange is a follow-up of the executable metamodeling language Kermeta, which provides a tool-supported dedicated meta-language to safely assemble language modules, customize them and produce new DSMLs. Melange provides specific constructs to assemble together various abstract syntax and operational semantics artifacts into a DSML. DSMLs can then be used as first class entities to be reused, extended, restricted or adapted into other DSMLs. Melange relies on a particular model-oriented type system that provides model polymorphism and language substitutability, i.e. the possibility to manipulate a model through different interfaces and to define generic transformations that can be invoked on models written using different DSLs. Newly produced DSMLs are correct by construction, ready for production (i.e., the result can be deployed and used as-is), and reusable in a new assembly.

  Melange is tightly integrated with the Eclipse Modeling Framework ecosystem and relies on the meta-language Ecore for the definition of the abstract syntax of DSLs. Executable meta-modeling is supported by weaving operational semantics defined with Xtend. Designers can thus easily design an interpreter for their DSL in a non-intrusive way. Melange is bundled as a set of Eclipse plug-ins.

• Functional Description: Melange is a language workbench which helps language engineers to mashup their various language concerns as language design choices, to manage their variability, and support their reuse. It provides a modular and reusable approach for customizing, assembling and integrating DSMLs specifications and implementations.
• URL: http://melange-lang.org
• Contacts: Benoît Combemale, Thomas Degueule, Olivier Barais, Jean-Marc Jézéquel, Didier Vojtisek
• Participants: Arnaud Blouin, Benoît Combemale, David Mendez Acuna, Didier Vojtisek, Dorian Leroy, Erwan Bousse, Fabien Coulon, Jean-Marc Jézéquel, Olivier Barais, Thomas Degueule

6.1.6 DSpot

• Keywords: Software testing, Test amplification
• Functional Description: DSpot is a tool that generates missing assertions in JUnit tests. DSpot takes as input a Java project with an existing test suite. As output, DSpot outputs new test cases on console. DSpot supports Java projects built with Maven and Gradle
• URL: https://github.com/STAMP-project/dspot
• Authors: Simon Allier, Benoit Baudry, Marcelino Rodriguez Cancio, Martin Monperrus
• Contacts: Benoit Baudry, Benjamin Danglot
• Participants: Benoit Baudry, Martin Monperrus, Benjamin Danglot
• Partner: KTH Royal Institute of Technology

6.1.7 ALE

• Name: Action Language for Ecore
• Keywords: Meta-modeling, Executable DSML
• Functional Description: Main features of ALE include:
  • Executable metamodeling: Re-open existing EClasses to insert new methods with their implementations
  • Metamodel extension: The very same mechanism can be used to extend existing Ecore metamodels and insert new features (eg. attributes) in a non-intrusive way
  • Interpreted: No need to deploy Eclipse plugins, just run the behavior on a model directly in your modeling environment
  • Extensible: If ALE doesn’t fit your needs, register Java classes as services and invoke them inside your implementations of EOperations.
• URL: http://gemoc.org/ale-lang/
• Contact: Benoît Combemale
• Partner: OBEO

6.1.8 InspectorGuidget

• Keywords: Static analysis, Software testing, User Interfaces
• Functional Description: InspectorGuidget is a static code analysing tool. InspectorGuidget analyses UI (user interface/interaction) code of a software system to extract high level information and metrics. InspectorGuidget also finds bad UI coding pratices, such as Blob listener instances. InspectorGuidget analyses Java code.
• URL: https://github.com/diverse-project/InspectorGuidget
• Publications: hal-01499106v5, hal-01308625v2
• Contact: Arnaud Blouin
• Participants: Arnaud Blouin, Benoit Baudry

6.1.9 Descartes

• Keywords: Software testing, Mutation analysis
• Functional Description:

  Descartes evaluates the capability of your test suite to detect bugs using extreme mutation testing.

  Descartes is a mutation engine plugin for PIT which implements extreme mutation operators as proposed in the paper Will my tests tell me if I break this code?.

• URL: https://github.com/STAMP-project/pitest-descartes
• Publications: hal-01870976, hal-01867423
• Contacts: Benoit Baudry, Oscar Luis Vera Perez, Olivier Barais, Martin Monperrus
• Participants: Oscar Luis Vera Perez, Benjamin Danglot, Benoit Baudry, Martin Monperrus
• Partner: KTH Royal Institute of Technology

6.1.10 PitMP

• Name: PIT for Multi-module Project
• Keywords: Mutation analysis, Mutation testing, Java, JUnit, Maven
• Functional Description: PIT and Descartes are mutation testing systems for Java applications, which allows you to verify if your test suites can detect possible bugs, and so to evaluate the quality of your test suites. They evaluate the capability of your test suite to detect bugs using mutation testing (PIT) or extreme mutation testing (Descartes). Mutation testing does it by introducing small changes or faults into the original program. These modified versions are called mutants. A good test suite should able to kill or detect a mutant. Traditional mutation testing works at the instruction level, e.g., replacing ">" by "<=", so the number of generated mutants is huge, as the time required to check the entire test suite. That's why Extreme Mutation strategy appeared. In Extreme Mutation testing, the whole body of a method under test is removed. Descartes is a mutation engine plugin for PIT which implements extreme mutation operators. Both provide reports combining, line coverage, mutation score and list of weaknesses in the source.
• URL: https://github.com/STAMP-project/pitmp-maven-plugin
• Contact: Caroline Landry
• Partners: CSQE, KTH Royal Institute of Technology, ENGINEERING

7.1.1 Deep software variability

7.1.2 Managing the software variability at the source code level

7.2.1 Foundations

7.2.2 Applications

7.3.1 Software architecture and cloud modeling

7.3.2 Leveraging unused heterogeneous resources for modular applications with SLA guarantees

7.4.1 Software Co-evolution

7.4.2 Privacy and Security

7.4.3 Software Verification

ADR Nokia

• Coordinator: Inria
• Dates: 2017-2021
• Abstract: The goal of this project is to integrate a chaos engineering principles to IoT Services frameworks to improve the robustness of the software-defined network services using this approach and to explore the concept of equivalence for software-defined network services and propose an approach to constantly evolve the attack surface of the network services.

BCOM

• Coordinator: UR1
• Dates: 2018-2024
• Abstract: The aim of the Falcon project is to investigate how to improve the resale of available resources in private clouds to third parties. In this context, the collaboration with DiverSE mainly aims at working on efficient techniques for the design of consumption models and resource consumption forecasting models. These models are then used as a knowledge base in a classical autonomous loop.

GLOSE

• Partners: Inria/CNRS/Safran
• Dates: 2017-2021
• Abstract: The GLOSE project develops new techniques for heterogeneous modeling and simulation in the context of systems engineering. It aims to provide formal and operational tools and methods to formalize the behavioral semantics of the various modeling languages used at system-level. These semantics will be used to extract behavioral language interfaces supporting the definition of coordination patterns. These patterns, in turn, can systematically be used to drive the coordination of any model conforming to these languages. The project is structured according to the following tasks: concurrent xDSML engineering, coordination of discrete models, and coordination of discrete/continuous models. The project is funded in the context of the network DESIR, and supported by the GEMOC initiative.

GLOSE Demonstrator

• Partners: Inria/Safran
• Dates: 2019-2020
• Abstract: Demonstrator illustrating the technologies involved in the WP5 off the GLOSE project. The use case chosen for the demonstrator is the high-level description of a remote control drone system, whose the main objective is to illustrate the design and simulation of the main functional chains, the possible interactivity with the model in order to raise the level of understanding over the models built, and possibly the exploration of the design space.

Debug4Science

• Partners: Inria/CEA DAM
• Dates: 2020-2022
• Abstract: Debug4Science aims to propose a disciplined approach to develop domain-specific debugging facilities for Domain-Specific Languages within the context of scientific computing and numerical analysis. Debug4Science is a bilateral collaboration (2020-2022), between the CEA DAM/DIF and the DiverSE team at Inria.

Orange

• Partners: UR1/Orange
• Dates: 2020-2023
• Abstract: Context aware adaptive authentification, Anne Bumiller's PhD Cifre project.

Obeo

• Partners: Inria/Obéo
• Dates: 2017-2020
• Abstract: Web engineering for domain-specific modeling languages, Fabien Coulon's PhD Cifre project.

OKWind

• Partners: UR1/OKWind
• Dates: 2017-2020
• Abstract: Models@runtime to improve self-consumption of renewable energies, Alexandre Rio's PhD Cifre project.

Keolis

• Partners: UR1/Keolis
• Dates: 2018-2021
• Abstract: Urban mobility: machine learning for building simulators using large amounts of data, Gauthier LYAN's PhD Cifre project.

FaberNovel

• Partners: UR1/FaberNovel
• Dates: 2018-2021
• Abstract: Abstractions for linked data and the programmable web, Antoine Cheron's PhD Cifre project.

9.1.1 Inria International Labs

9.2.1 Visits of international scientists

• Nelly Bencomo, Aston University, UK
• Gunter Mussbacher, McGill University, Canada

9.3.1 Collaborations with major European organizations

• Vipo Project. Vipo is an innovation project from EIT Digital. This year, we bring our expertise on native cloud architecture and adaptable architectures for this project.

9.4.1 ANR

9.4.2 DGA

10.1.1 Scientific events: organisation

10.1.2 Journal

10.1.3 Leadership within the scientific community

Arnaud Blouin:

• Founding member and co-organiser of the French GDR-GPL research action on Software Engineering and Human-Computer Interaction (GL-IHM).

Jean-Marc Jézéquel:

• Board member of Informatics Europe
• Member of the Scientific Committee of the GDR GPL of CNRS
• Member of the Advisory Board of the GEMOC Initiative: On the Globalization of Modeling Languages

Benoit Combemale:

• Chair of the steering committee of the ACM SIGPLAN Intl. Conference on Software Language Engineering (SLE)
• Founding member of the steerng committee of the Modeling Language Engineering and Execution (MLE) workshop series
• Funding Member of the Advisory Board of the GEMOC Initiative: On the Globalization of Modeling Languages

Djamel Khelladi:

• Co-organiser of the French GDR-GPL research action on Software Velocity - software engineering.

Olivier Zendra:

• Scientific Coordinattor of EU H2020 TeamPlay project
• Founder and member of the Steering Committee of the International Workshop on Implementation, Compilation, Optimization of OO Languages, Programs and Systems (ICOOOLPS)
• Member of the EU HiPEAC CSA project Steering Committee
• Member of the HiPEAC Vision Editorial Board

10.1.4 Scientific expertise

Olivier Barais:

• Advisory board member for the H2020 ENACT european Project
• Expert for the evaluation of the project provided by Ministères des affaires étrangères

Olivier Zendra:

• Scientific expert for CIR/JEI for Ministère de l'enseignement supérieur, de la recherche et de l'innovation

10.1.5 Research administration

Jean-Marc Jézéquel:

• Director of UMR6074 IRISA (850 persons)
• Director of EIT Digital in Rennes
• Coordinator of the Acaemic research of Pole d'Excellence Cyber

Olivier Barais:

• Vice Dean of ISTIC (1800 students, 75 associate profs or profs)

Olivier Zendra:

• Member of Inria Evaluation Committee.

10.2.1 Teaching

The DIVERSE team bears the bulk of the teaching on Software Engineering at the University of Rennes 1 and at INSA Rennes, for the first year of the Master of Computer Science (Project Management, Object-Oriented Analysis and Design with UML, Design Patterns, Component Architectures and Frameworks, Validation & Verification, Human-Computer Interaction) and for the second year of the MSc in software engineering (Model driven Engineering, Aspect-Oriented Software Development, Software Product Lines, Component Based Software Development, Validation & Verification, etc.).

Each of Jean-Marc Jézéquel, Noël Plouzeau, Olivier Barais, Benoit Combemale, Johann Bourcier, Arnaud Blouin, Stéphanie Challita and Mathieu Acher teaches about 250h in these domains for a grand total of about 2000 hours, including several courses at ENSTB, IMT, ENS Rennes and ENSAI Rennes engineering school.

Olivier Barais is deputy director of the electronics and computer science teaching department of the University of Rennes 1. Olivier Barais is the head of the Master in Computer Science at the University of Rennes 1. Johann Bourcier is the head of the Information Technology department and member of the management board at the ESIR engineering school in Rennes. Arnaud Blouin is in charge of industrial relationships for the computer science department at INSA Rennes and elected member of this CS department council.

The DIVERSE team also hosts several MSc and summer trainees every year.

10.2.2 Supervision

• PhD defense in 2020: Jean-Émile Dartois, Efficient resources management for hybrid cloud computing, 2016, O. Barais, Jalil Boukhobza.
• PhD defense in 2020: Tristan Ninet, Formal verification of the Internet Key Exchange (IKEv2) security protocol, 2016, O. Zendra.
• PhD in progress: Alexandre Rio, Demand Side Management A model driven approach to promote energy self-consumption , 2016, O. Barais, Y. Morel
• PhD in progress: Dorian Leroy, A generic and generative white-box testing framework for model transformations, 2017, B. Combemale.
• PhD in progress: Fabien Coulon, Web engineering for domain-specific modeling languages, 2017, B. Combemale, S. Begaudeau.
• PhD in progress: June Benvegnu-Sallou, Decision support for the assessment of risks associated with the operation of underground environments, 2018, J-R. De Dreuzy, B. Combemale, J. Bourcier.
• PhD in progress: Pierre JeanJean, Refining simulators by analyzing execution traces of complex systems, 2018, O. Barais, B. Combemale.
• PhD in progress: Alif Akbar-pranata, Chaos Engineering for IoT and Network Services, 2018, O. Barais, J. Bourcier.
• PhD in progress: Antoine Cheron, Abstractions for linked data and the programmable web, 2018, O. Barais, J. Bourcier.
• PhD in progress: Gauthier Lyan, Urban mobility: machine learning for building simulators using large amounts of data, 2018, J-M. Jééquel, D. Gross Amblard.
• PhD in progress: Hugo Martin, Learning variability, 2018, M. Acher.
• PhD in progress: Lamine Noureddine, Developing New Techniques for Packing Detection and Unpacking to Stop Malware Propagation, 2018, O. Zendra.
• PhD in progress: Cassius De Oliveira Puodzius, Machine learning for malware detection by aggregation of multiple threat feeds, 2019, O. Zendra.
• PhD in progress: Luc Lesoil, Deep variability in large-scaled systems, 2019, M. Acher. A. Blouin, JM Jézéquel.
• PhD in progress: Emmanuel Chebbi, Domain-Specific Language Reuse, 2019, B. Combemale, O. Barais, G. Leguernic
• PhD in progress: Mohamed Handaoui, Scheduling Big Data applications in the cloud: the case of machine learning algorithms, 2019, Jalil Boukhobza. Olivier Barais.
• PhD in progress: Quentin Le Dilavrec, Co-evolution between code, tests, and third-part libraries, 2020, Arnaud Blouin, Jean-Marc Jézéquel, Djamel Eddine Khelladi.
• PhD in progress: Gwendal Jouneaux, Self-Adaptive Language, 2020, B. Combemale, O. Barais, G. Mussbacher.
• PhD in progress: Anne Bumiller, Contextual Modeling of Adaptive Authentication Systems, 2020, Olivier Barais, Benoit Combemale, Stéphanie Challita.

10.2.3 Juries

International journals

• 24 articleMojtabaM. Bagherzadeh, KarimK. Jahed, BenoitB. Combemale and JuergenJ. Dingel. Live Modeling in the Context of State Machine Models and Code GenerationSoftware and Systems Modeling2020, 1-44
  HALDOIback to text
• 25 articleJean-MichelJ.-M. Bruel, BenoitB. Combemale, Esther ME. Guerra, Jean-MarcJ.-M. Jézéquel, JörgJ. Kienzle, JuanJ. De Lara, GunterG. Mussbacher, EugeneE. Syriani and HansH. Vangheluwe. Comparing and Classifying Model Transformation Reuse Approaches across MetamodelsSoftware and Systems Modeling1922020, 441-465
  HALDOIback to text
• 26 article StéphanieS. Challita, FabianF. Korte, JohannesJ. Erbel, FaiezF. Zalila, JensJ. Grabowski and PhilippeP. Merle. Model-Based Cloud Resource Management with TOSCA and OCCI Software and Systems Modeling 2021
  HAL back to text
• 27 articleBenoitB. Combemale, JörgJ. Kienzle, GunterG. Mussbacher, HyacinthH. Ali, DanielD. Amyot, MojtabaM. Bagherzadeh, EdouardE. Batot, NellyN. Bencomo, BenjaminB. Benni, Jean-MichelJ.-M. Bruel, JordiJ. Cabot, Betty H CB. Cheng, PhilippeP. Collet, GregorG. Engels, RobertR. Heinrich, Jean-MarcJ.-M. Jézéquel, AnneA. Koziolek, SébastienS. Mosser, RalfR. Reussner, HouariH. Sahraoui, RijulR. Saini, JuneJ. Sallou, SergeS. Stinckwich, EugeneE. Syriani and ManuelM. Wimmer. A Hitchhiker's Guide to Model-Driven Engineering for Data-Centric SystemsIEEE Software2020, 1-9
  HALDOIback to text
• 28 articleBenjaminB. Danglot, MartinM. Monperrus, WalterW. Rudametkin and BenoitB. Baudry. An approach and benchmark to detect behavioral changes of commits in continuous integrationEmpirical Software Engineering254July 2020, 2379-2415
  HALDOIback to text
• 29 article Francesca ArcelliF. Fontana, GillesG. Perrouin, ApostolosA. Ampatzoglou, MathieuM. Acher, BartoszB. Walter, MaximeM. Cordy, FabioF. Palomba and XavierX. Devroey. MALTESQUE 2019 Workshop Summary Software Engineering Notes January 2020
  HAL DOI
• 30 articleJörgJ. Kienzle, GunterG. Mussbacher, BenoitB. Combemale, LucyL. Bastin, NellyN. Bencomo, Jean-MichelJ.-M. Bruel, ChristophC. Becker, StefanieS. Betz, RuzannaR. Chitchyan, BettyB. Cheng, SonjaS. Klingert, RichardR. Paige, BirgitB. Penzenstadler, NorbertN. Seyff, EugeneE. Syriani and Colin CC. Venters. Towards Model-Driven Sustainability EvaluationCommunications of the ACM6332020, 80-91
  HALback to text
• 31 article RolandR. Kretschmer, Djamel EddineD. Khelladi and AlexanderA. Egyed. Transforming Abstract to Concrete Repairs with a Generative Approach of Repair Values Journal of Systems and Software 2021
  HAL back to text
• 32 article RolandR. Kretschmer, Djamel EddineD. Khelladi, Roberto ER. Lopez-Herrejon and AlexanderA. Egyed. Consistent Change Propagation within Models Software and Systems Modeling July 2020
  HAL DOI back to text
• 33 articleManuelM. Leduc, ThomasT. Degueule, EricE. Van Wyk and BenoitB. Combemale. The Software Language Extension ProblemSoftware and Systems Modeling1922020, 263-267
  HALback to text
• 34 articleManuelM. Leduc, GwendalG. Jouneaux, ThomasT. Degueule, GurvanG. Le Guernic, OlivierO. Barais and BenoitB. Combemale. Automatic generation of Truffle-based interpreters for Domain-Specific LanguagesThe Journal of Object Technology1922020, 1-21
  HALDOIback to text
• 35 article DorianD. Leroy, ErwanE. Bousse, ManuelM. Wimmer, TanjaT. Mayerhofer, BenoitB. Combemale and WielandW. Schwinger. Behavioral interfaces for executable DSLs Software and Systems Modeling April 2020
  HAL DOI back to text
• 36 articleDorianD. Leroy, PierreP. Jeanjean, ErwanE. Bousse, ManuelM. Wimmer and BenoitB. Combemale. Runtime Monitoring for Executable DSLsThe Journal of Object Technology1922020, 1-23
  HALDOIback to text
• 37 articleGunterG. Mussbacher, BenoitB. Combemale, JörgJ. Kienzle, SilviaS. Abrahão, HyacinthH. Ali, NellyN. Bencomo, MártonM. Búr, LoliL. Burgueño, GregorG. Engels, PierreP. Jeanjean, Jean-MarcJ.-M. Jézéquel, ThomasT. Kühn, SébastienS. Mosser, HouariH. Sahraoui, EugeneE. Syriani, DánielD. Varró and MartinM. Weyssow. Opportunities in Intelligent Modeling AssistanceSoftware and Systems Modeling2020, 1-7
  HALDOIback to text
• 38 article AlfonsoA. Pierantonio, Mark Van DenM. Brand and BenoitB. Combemale. Open Access: all you wanted to know and never dared to ask The Journal of Object Technology 2020
  HAL
• 39 articlePaulP. Temple, GillesG. Perrouin, MathieuM. Acher, BattistaB. Biggio, Jean-MarcJ.-M. Jézéquel and FabioF. Roli. Empirical Assessment of Generating Adversarial Configurations for Software Product LinesEmpirical Software EngineeringDecember 2020, 1-57
  HALback to text
• 40 articleXhevahireX. Tërnava and PhilippeP. Collet. A framework for managing the imperfect modularity of variability implementationsJournal of Computer LanguagesSeptember 2020, 1-39
  HALDOIback to text
• 41 articleAndreasA. Wortmann, OlivierO. Barais, BenoitB. Combemale and ManuelM. Wimmer. Modeling Languages in Industry 4.0: An Extended Systematic Mapping StudySoftware and Systems Modeling1912020, 67-94
  HALDOIback to text

International peer-reviewed conferences

• 42 inproceedings AbdelghaniA. Alidra, AntoineA. Beugnard, HubertH. Godfroy, PierreP. Kimmel and GurvanG. Le Guernic. A Language Agnostic Approach to Modeling Requirements: Specification and Verification MODELS ’20 Companion Virtual Event, Canada October 2020
  HAL DOI back to text
• 43 inproceedingsJulianaJ. Alves Pereira, MathieuM. Acher, HugoH. Martin and Jean-MarcJ.-M. Jézéquel. Sampling Effect on Performance Prediction of Configurable Systems: A Case StudyICPE 2020 - 11th ACM/SPEC International Conference on Performance EngineeringEdmonton, CanadaApril 2020, 1-13
  HALback to text
• 44 inproceedings FrancisF. Bordeleau, BenoitB. Combemale, RominaR. Eramo, MarkM. Van Den Brand and ManuelM. Wimmer. Towards Model-Driven Digital Twin Engineering: Current Opportunities and Future Challenges ICSMM 2020 - International Conference on Systems Modelling and Management Bergen, Norway June 2020
  HAL back to text
• 45 inproceedingsFabienF. Coulon, AlexA. Auvolat, BenoitB. Combemale, Yérom-DavidY.-D. Bromberg, FrançoisF. Taïani, OlivierO. Barais and NoëlN. Plouzeau. Modular and Distributed IDESLE 2020 - 13th ACM SIGPLAN International Conference on Software Language EngineeringVirtual, United StatesNovember 2020, 270–282
  HALDOIback to text
• 46 inproceedingsMohamedM. Handaoui, Jean-EmileJ.-E. Dartois, JalilJ. Boukhobza, OlivierO. Barais and LaurentL. D'orazio. ReLeaSER: A Reinforcement Learning Strategy for Optimizing Utilization Of Ephemeral Cloud ResourcesCloudCom 2020 - 12th IEEE International Conference on Cloud Computing Technology and ScienceBangkok, ThailandDecember 2020, 1-9
  HALback to text
• 47 inproceedingsMohamedM. Handaoui, Jean-EmileJ.-E. Dartois, LaurentL. Lemarchand and JalilJ. Boukhobza. Salamander: a Holistic Scheduling of MapReduce Jobs on Ephemeral Cloud ResourcesCCGRID 2020 - 20th IEEE/ACM International Symposium on Cluster, Cloud and Grid ComputingMelbourne, AustraliaNovember 2020, 1-10
  HALback to text
• 48 inproceedings PierreP. Jeanjean, BenoitB. Combemale and OlivierO. Barais. IDE as Code: Reifying Language Protocols as First-Class Citizens ISEC 2021 - Innovations in Software Engineering Conference Bhubaneswar / Virtual, India February 2021
  HAL
• 49 inproceedings Djamel EddineD. Khelladi, BenoitB. Combemale, MathieuM. Acher, OlivierO. Barais and Jean-MarcJ.-M. Jézéquel. Co-Evolving Code with Evolving Metamodels 42nd International Conference on Software Engineering Séoul, South Korea May 2020
  HAL back to text
• 50 inproceedings Djamel EddineD. Khelladi, BenoitB. Combemale, MathieuM. Acher and OlivierO. Barais. On the Power of Abstraction: a Model-Driven Co-evolution Approach of Software Code 42nd International Conference on Software Engineering, New Ideas and Emerging Results Séoul, South Korea May 2020
  HAL back to text
• 51 inproceedings LucL. Lesoil, MathieuM. Acher, ArnaudA. Blouin and Jean-MarcJ.-M. Jézéquel. Deep Software Variability: Towards Handling Cross-Layer Configuration VaMoS 2021 - 15th International Working Conference on Variability Modelling of Software-Intensive Systems Krems / Virtual, Austria https://vamos2021.fh-krems.ac.at/ February 2021
  HAL back to text
• 52 inproceedingsNanN. Messe, NicolasN. Belloir, VaneaV. Chiprianov, JamalJ. El-Hachem, RégisR. Fleurquin and SalahS. Sadou. An Asset-Based Assistance for Secure by DesignAPSEC 2020 - 27th Asia-Pacific Software Engineering ConferenceSingapore, SingaporeDecember 2020, 1-10
  HALback to text
• 53 inproceedingsNanN. Messe, VaneaV. Chiprianov, NicolasN. Belloir, JamalJ. El-Hachem, RégisR. Fleurquin and SalahS. Sadou. Asset-Oriented Threat ModelingTrustCom 2020 - 19th IEEE International Conference on Trust, Security and Privacy in Computing and CommunicationsGuangzhou, ChinaDecember 2020, 1-11
  HALback to text
• 54 inproceedingsGunterG. Mussbacher, BenoitB. Combemale, SilviaS. Abrahão, NellyN. Bencomo, LoliL. Burgueño, GregorG. Engels, JörgJ. Kienzle, ThomasT. Kühn, SébastienS. Mosser, HouariH. Sahraoui and MartinM. Weyssow. Towards an Assessment Grid for Intelligent Modeling AssistanceMDE Intelligence 2020 - 2nd Workshop on Artificial Intelligence and Model-driven Engineering10Montreal, CanadaOctober 2020, 1-10
  HALback to text
• 55 inproceedings LamineL. Noureddine, AnnelieA. Heuser, CassiusC. Puodzius and OlivierO. Zendra. SE-PAC: A Self-Evolving PAcker Classifier against rapid packers evolution CODASPY '21: Eleventh ACM Conference on Data and Application Security and Privacy Virtual Event, United States April 2021
  HAL DOI back to text
• 56 inproceedingsJuliana AlvesJ. Pereira, HugoH. Martin, PaulP. Temple and MathieuM. Acher. Machine Learning and Configurable Systems: A Gentle IntroductionSPLC 2020 - 24th ACM International Systems and Software Product Line ConferenceMontreal, CanadaOctober 2020, 1
  HALDOI
• 57 inproceedingsAlif AkbarA. Pranata, OlivierO. Barais, JohannJ. Bourcier and LudovicL. Noirie. Misconfiguration Discovery with Principal Component Analysis for Cloud-Native Services2020 IEEE/ACM 13th International Conference on Utility and Cloud Computing (UCC)UCC 2020 - 13th IEEE/ACM International Conference on Utility and Cloud ComputingLeicester / Virtual, United KingdomDecember 2020, 269-278
  HALback to text
• 58 inproceedingsJuneJ. Sallou, AlexandreA. Gauvain, JohannJ. Bourcier, BenoitB. Combemale and Jean-RaynaldJ.-R. De Dreuzy. Loop Aggregation for Approximate Scientific ComputingComputational Science – ICCS 2020International Conference on Computational ScienceLecture Notes in Computer Science book seriesAmsterdam, NetherlandsJune 2020, 141-155
  HALDOIback to text
• 59 inproceedingsL. Thomas Van Binsbergen, Mauricio VeranoM. Merino, PierreP. Jeanjean, TijsT. Van Der Storm, BenoitB. Combemale and OlivierO. Barais. A principled approach to REPL interpretersSPLASH 2020 - ACM SIGPLAN conference on Systems, Programming, Languages, and Applications: Software for HumanityChicago / Virtual, United StatesNovember 2020, 1-17
  HALDOIback to text

Scientific book chapters

• 60 inbook BenoitB. Baudry, Yérom-DavidY.-D. Bromberg, DavideD. Frey, AlejandroA. Gómez-Boix, PierreP. Laperdrix and FrançoisF. Taïani. Profilage de navigateurs : état de l’art et contre-mesures Le profilage en ligne : entre libéralisme et régulation October 2020
  HAL back to text

Doctoral dissertations and habilitation theses

• 61 thesis Jean-EmileJ.-E. Dartois. Leveraging Cloud unused heterogeneous resources for applications with SLA guarantees Univ-Rennes1 September 2020
  HAL back to text