3.2.1 Model-Driven Engineering

Model-Driven Engineering (MDE) aims at reducing the accidental complexity associated with developing complex software-intensive systems (e.g., use of abstractions of the problem space rather than abstractions of the solution space)  109. It provides DIVERSE with solid foundations to specify, analyze and reason about the different forms of diversity that occur throughout the development life cycle. A primary source of accidental complexity is the wide gap between the concepts used by domain experts and the low-level abstractions provided by general-purpose programming languages  81. MDE approaches address this problem through modeling techniques that support separation of concerns and automated generation of major system artifacts from models (e.g., test cases, implementations, deployment and configuration scripts). In MDE, a model describes an aspect of a system and is typically created or derived for specific development purposes  65. Separation of concerns is supported through the use of different modeling languages, each providing constructs based on abstractions that are specific to an aspect of a system. MDE technologies also provide support for manipulating models, for example, support for querying, slicing, transforming, merging, and analyzing (including executing) models. Modeling languages are thus at the core of MDE, which participates in the development of a sound Software Language Engineering, including a unified typing theory that integrates models as first class entities  111.

Incorporating domain-specific concepts and a high-quality development experience into MDE technologies can significantly improve developer productivity and system quality. Since the late nineties, this realization has led to work on MDE language workbenches that support the development of domain-specific modeling languages (DSMLs) and associated tools (e.g., model editors and code generators). A DSML provides a bridge between the field in which domain experts work and the implementation (programming) field. Domains in which DSMLs have been developed and used include, among others, automotive, avionics, and cyber-physical systems. A study performed by Hutchinson et al.  86 indicates that DSMLs can pave the way for wider industrial adoption of MDE.

More recently, the emergence of new classes of systems that are complex and operate in heterogeneous and rapidly changing environments raises new challenges for the software engineering community. These systems must be adaptable, flexible, reconfigurable and, increasingly, self-managing. Such characteristics make systems more prone to failure when running and thus the development and study of appropriate mechanisms for continuous design and runtime validation and monitoring are needed. In the MDE community, research is focused primarily on using models at the design, implementation, and deployment stages of development. This work has been highly productive, with several techniques now entering a commercialization phase. As software systems are becoming more and more dynamic, the use of model-driven techniques for validating and monitoring runtime behavior is extremely promising  95.

3.2.2 Variability modeling

While the basic vision underlying Software Product Lines (SPL) can probably be traced back to David Parnas' seminal article  102 on the Design and Development of Program Families, it is only quite recently that SPLs have started emerging as a paradigm shift towards modeling and developing software system families rather than individual systems  99. SPL engineering embraces the ideas of mass customization and software reuse. It focuses on the means of efficiently producing and maintaining multiple related software products, exploiting what they have in common and managing what varies among them.

Several definitions of the software product line concept can be found in the research literature. Clements et al. define it as a set of software-intensive systems sharing a common, managed set of features that satisfy the specific needs of a particular market segment or mission and are developed from a common set of core assets in a prescribed way  100. Bosch provides a different definition 71: A SPL consists of a product line architecture and a set of reusable components designed for incorporation into the product line architecture. In addition, the PL consists of the software products developed using the mentioned reusable assets. In spite of the similarities, these definitions provide different perspectives of the concept: market-driven, as seen by Clements et al., and technology-oriented for Bosch.

SPL engineering is a process focusing on capturing the commonalities (assumptions true for each family member) and variability (assumptions about how individual family members differ) between several software products  77. Instead of describing a single software system, a SPL model describes a set of products in the same domain. This is accomplished by distinguishing between elements common to all SPL members, and those that may vary from one product to another. Reuse of core assets, which form the basis of the product line, is key to productivity and quality gains. These core assets extend beyond simple code reuse and may include the architecture, software components, domain models, requirements statements, documentation, test plans or test cases.

The SPL engineering process consists of two major steps:

1. Domain Engineering, or development for reuse, focuses on core assets development.
2. Application Engineering, or development with reuse, addresses the development of the final products using core assets and following customer requirements.

Central to both processes is the management of variability across the product line  83. In common language use, the term variability refers to the ability or the tendency to change. Variability management is thus seen as the key feature that distinguishes SPL engineering from other software development approaches  72. Variability management is thus increasingly seen as the cornerstone of SPL development, covering the entire development life cycle, from requirements elicitation  113 to product derivation  117 to product testing  98, 97.

Halmans et al.  83 distinguish between essential and technical variability, especially at the requirements level. Essential variability corresponds to the customer's viewpoint, defining what to implement, while technical variability relates to product family engineering, defining how to implement it. A classification based on the dimensions of variability is proposed by Pohl et al.  104: beyond variability in time (existence of different versions of an artifact that are valid at different times) and variability in space (existence of an artifact in different shapes at the same time) Pohl et al. claim that variability is important to different stakeholders and thus has different levels of visibility: external variability is visible to the customers while internal variability, that of domain artifacts, is hidden from them. Other classification proposals come from Meekel et al.  92 (feature, hardware platform, performance and attributes variability) or Bass et al.  63 who discusses about variability at the architectural level.

Central to the modeling of variability is the notion of feature, originally defined by Kang et al. as: a prominent or distinctive user-visible aspect, quality or characteristic of a software system or systems  88. Based on this notion of feature, they proposed to use a feature model to model the variability in a SPL. A feature model consists of a feature diagram and other associated information: constraints and dependency rules. Feature diagrams provide a graphical tree-like notation depicting the hierarchical organization of high level product functionalities represented as features. The root of the tree refers to the complete system and is progressively decomposed into more refined features (tree nodes). Relations between nodes (features) are materialized by decomposition edges and textual constraints. Variability can be expressed in several ways. Presence or absence of a feature from a product is modeled using mandatory or optional features. Features are graphically represented as rectangles while some graphical elements (e.g., unfilled circle) are used to describe the variability (e.g., a feature may be optional).

Features can be organized into feature groups. Boolean operators exclusive alternative (XOR), inclusive alternative (OR) or inclusive (AND) are used to select one, several or all the features from a feature group. Dependencies between features can be modeled using textual constraints: requires (presence of a feature requires the presence of another), mutex (presence of a feature automatically excludes another). Feature attributes can be also used for modeling quantitative (e.g., numerical) information. Constraints over attributes and features can be specified as well.

Modeling variability allows an organization to capture and select which version of which variant of any particular aspect is wanted in the system  72. To implement it cheaply, quickly and safely, redoing by hand the tedious weaving of every aspect is not an option: some form of automation is needed to leverage the modeling of variability  67. Model Driven Engineering (MDE) makes it possible to automate this weaving process  87. This requires that models are no longer informal, and that the weaving process is itself described as a program (which is as a matter of fact an executable meta-model  96) manipulating these models to produce for instance a detailed design that can ultimately be transformed to code, or to test suites  103, or other software artifacts.

3.2.3 Component-based software development

Component-based software development  112 aims at providing reliable software architectures with a low cost of design. Components are now used routinely in many domains of software system designs: distributed systems, user interaction, product lines, embedded systems, etc. With respect to more traditional software artifacts (e.g., object oriented architectures), modern component models have the following distinctive features  78: description of requirements on services required from the other components; indirect connections between components thanks to ports and connectors constructs  90; hierarchical definition of components (assemblies of components can define new component types); connectors supporting various communication semantics  75; quantitative properties on the services  70.

In recent years component-based architectures have evolved from static designs to dynamic, adaptive designs (e.g., SOFA  75, Palladio  68, Frascati  93). Processes for building a system using a statically designed architecture are made of the following sequential lifecycle stages: requirements, modeling, implementation, packaging, deployment, system launch, system execution, system shutdown and system removal. If for any reason after design time architectural changes are needed after system launch (e.g., because requirements changed, or the implementation platform has evolved, etc) then the design process must be reexecuted from scratch (unless the changes are limited to parameter adjustment in the components deployed).

Dynamic designs allow for on the fly redesign of a component based system. A process for dynamic adaptation is able to reapply the design phases while the system is up and running, without stopping it (this is different from a stop/redeploy/start process). Dynamic adaptation processes support chosen adaptation, when changes are planned and realized to maintain a good fit between the needs that the system must support and the way it supports them  89. Dynamic component-based designs rely on a component meta-model that supports complex life cycles for components, connectors, service specification, etc. Advanced dynamic designs can also take platform changes into account at runtime, without human intervention, by adapting themselves  76, 115. Platform changes and more generally environmental changes trigger imposed adaptation, when the system can no longer use its design to provide the services it must support. In order to support an eternal system  69, dynamic component based systems must separate architectural design and platform compatibility. This requires support for heterogeneity, since platform evolution can be partial.

The Models@runtime paradigm denotes a model-driven approach aiming at taming the complexity of dynamic software systems. It basically pushes the idea of reflection one step further by considering the reflection layer as a real model “something simpler, safer or cheaper than reality to avoid the complexity, danger and irreversibility of reality  107”. In practice, component-based (and/or service-based) platforms offer reflection APIs that make it possible to introspect the system (to determine which components and bindings are currently in place in the system) and dynamic adaptation (by applying CRUD operations on these components and bindings). While some of these platforms offer rollback mechanisms to recover after an erroneous adaptation, the idea of Models@runtime is to prevent the system from actually enacting an erroneous adaptation. In other words, the “model at run-time” is a reflection model that can be uncoupled (for reasoning, validation, simulation purposes) and automatically resynchronized.

Heterogeneity is a key challenge for modern component based systems. Until recently, component based techniques were designed to address a specific domain, such as embedded software for command and control, or distributed Web based service oriented architectures. The emergence of the Internet of Things paradigm calls for a unified approach in component based design techniques. By implementing an efficient separation of concern between platform independent architecture management and platform dependent implementations, Models@runtime is now established as a key technique to support dynamic component based designs. It provides DIVERSE with an essential foundation to explore an adaptation envelope at run-time. The goal is to automatically explore a set of alternatives and assess their relevance with respect to the considered problem. These techniques have been applied to craft software architecture exhibiting high quality of services properties  82. Multi Objectives Search based techniques  80 deal with optimization problem containing several (possibly conflicting) dimensions to optimize. These techniques provide DIVERSE with the scientific foundations for reasoning and efficiently exploring an envelope of software configurations at run-time.

3.2.4 Validation and verification

Validation and verification (V&V) theories and techniques provide the means to assess the validity of a software system with respect to a specific correctness envelope. As such, they form an essential element of DIVERSE's scientific background. In particular, we focus on model-based V&V in order to leverage the different models that specify the envelope at different moments of the software development lifecycle.

Model-based testing consists in analyzing a formal model of a system (e.g., activity diagrams, which capture high-level requirements about the system, statecharts, which capture the expected behavior of a software module, or a feature model, which describes all possible variants of the system) in order to generate test cases that will be executed against the system. Model-based testing  114 mainly relies on model analysis, constraint solving  79 and search-based reasoning  91. DIVERSE leverages in particular the applications of model-based testing in the context of highly-configurable systems and 116 interactive systems  94 as well as recent advances based on diversity for test cases selection  85.

Nowadays, it is possible to simulate various kinds of models. Existing tools range from industrial tools such as Simulink, Rhapsody or Telelogic to academic approaches like Omega  101, or Xholon. All these simulation environments operate on homogeneous environment models. However, to handle diversity in software systems, we also leverage recent advances in heterogeneous simulation. Ptolemy  74 proposes a common abstract syntax, which represents the description of the model structure. These elements can be decorated using different directors that reflect the application of a specific model of computation on the model element. Metropolis  64 provides modeling elements amenable to semantically equivalent mathematical models. Metropolis offers a precise semantics flexible enough to support different models of computation. ModHel'X  84 studies the composition of multi-paradigm models relying on different models of computation.

Model-based testing and simulation are complemented by runtime fault-tolerance through the automatic generation of software variants that can run in parallel, to tackle the open nature of software-intensive systems. The foundations in this case are the seminal work about N-version programming   62, recovery blocks  106 and code randomization  66, which demonstrated the central role of diversity in software to ensure runtime resilience of complex systems. Such techniques rely on truly diverse software solutions in order to provide systems with the ability to react to events, which could not be predicted at design time and checked through testing or simulation.

3.2.5 Empirical software engineering

The rigorous, scientific evaluation of DIVERSE's contributions is an essential aspect of our research methodology. In addition to theoretical validation through formal analysis or complexity estimation, we also aim at applying state-of-the-art methodologies and principles of empirical software engineering. This approach encompasses a set of techniques for the sound validation contributions in the field of software engineering, ranging from statistically sound comparisons of techniques and large-scale data analysis to interviews and systematic literature reviews  110, 108. Such methods have been used for example to understand the impact of new software development paradigms  73. Experimental design and statistical tests represent another major aspect of empirical software engineering. Addressing large-scale software engineering problems often requires the application of heuristics, and it is important to understand their effects through sound statistical analyses  61.

3.3.1 Axis #1: Software Language Engineering

Overall objective.

The disruptive design of new, complex systems requires a high degree of flexibility in the communication between many stakeholders, often limited by the silo-like structure of the organization itself (cf. Conway’s law). To overcome this constraint, modern engineering environments aim to: (i) better manage the necessary exchanges between the different stakeholders; (ii) provide a unique and usable place for information sharing; and (iii) ensure the consistency of the many points of view. Software languages are the key pivot between the diverse stakeholders involved, and the software systems they have to implement. Domain-Specific (Modeling) Languages enable stakeholders to address the diverse concerns through specific points of view, and their coordinated use is essential to support the socio-technical coordination across the overall software system life cycle.

Our perspectives on Software Language Engineering over the next period is presented in Figure 2 and detailed in the following paragraphs.

3.3.2 Axis #2: Spatio-temporal Variability in Software and Systems

Overall objective.

Leveraging our longstanding activity on variability management for software product lines and configurable systems covering diverse scenarios of use, we will investigate over the next period the impact of such a variability across the diverse layers, incl. source code, input/output data, compilation chain, operating systems and underlying execution platforms. We envision a better support and assistance for the configuration and optimisation (e.g., non-functional properties) of software systems according to this deep variability. Moreover, as software systems involve diverse artefacts (e.g., APIs, tests, models, scripts, data, cloud services, documentation, deployment descriptors...), we will investigate their continuous co-evolution during the overall lifecycle, including maintenance and evolution. Our perspectives on spatio-temporal variability over the next period is presented in Figure 3 and is detailed in the following paragraphs.

3.3.3 Axis #3: DevSecOps and Resilience Engineering for Software and Systems

Overall objective.

The production and delivery of modern software systems involves the integration of diverse dependencies and continuous deployment on diverse execution platforms in the form of large distributed socio-technical systems. This leads to new software architectures and programming models, as well as complex supply chains for final delivery to system users. In order to boost cybersecurity, we want to provide strong support to software engineers and IT teams in the development and delivery of secure and resilient software systems, ie. systems able to resist or recover from cyberattacks. Our perspectives on DevSecOps and Resilience Engineering over the next period are presented in Figure 4 and detailed in the following paragraphs.

6.1.1 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.2 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.
  • Monilog, an extension for monitoring and logging executable domain-specific 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
• Contact:
  Benoît Combemale
• Participants:
  Didier Vojtisek, Dorian Leroy, Erwan Bousse, Fabien Coulon, Julien DeAntoni
• Partners:
  IRIT, ENSTA, I3S, OBEO, Thales TRT

6.1.3 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/
• 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.4 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
• Contact:
  Benoît Combemale
• Participants:
  Arnaud Blouin, Benoît Combemale, David Mendez Acuna, Didier Vojtisek, Dorian Leroy, Erwan Bousse, Fabien Coulon, Jean-Marc Jezequel, Olivier Barais, Thomas Degueule

6.1.5 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
• Contact:
  Benjamin Danglot
• Participants:
  Benoit Baudry, Martin Monperrus, Benjamin Danglot
• Partner:
  KTH Royal Institute of Technology

6.1.6 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.7 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.8 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
• Contact:
  Benoit Baudry
• Participants:
  Oscar Luis Vera Perez, Benjamin Danglot, Benoit Baudry, Martin Monperrus
• Partner:
  KTH Royal Institute of Technology

6.1.9 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

6.1.10 SE-PAC

• Name:
  Self-Evolving-PAcker Classifier
• Keywords:
  Packers, Malware, Obfuscation, Classification, Incremental clustering
• Functional Description:

  SE-PAC is a Self-Evolving PAcker Classifier software that identifies the class of the packer used to pack a (malicious) Win32 executable file. It has the the ability to identify both known and unknown packer classes, as well as self-updating its packer knowledge with the predicted packer classes.

  SE-PAC relies on incremental clustering in a semi-supervised fashion. It is composed of an offline phase and an online phase. In the offline phase, a set of features is extracted from a collection of packed binaries provided with their ground truth labels, then a density-based clustering algorithm (DBSCAN) is used to group similar packers together into clusters with respect to a distance measure. In this step, the similarity threshold is tuned in order to form the clusters that fit the best with the set of labels provided. In the online phase, SE-PAC reproduces the same operations of feature extraction and distance calculation, then uses a customized version of the incremental clustering algorithm DBSCAN in order to classify incoming packed samples, either in known packer classes by extending existing clusters or new packer classes by forming new clusters, or temporarily leave them unclassified (see notion of noise of DBSCAN). The clusters formed after each update serve as a baseline for SE-PAC to self-evolve.

  Finally, SE-PAC includes a post-clustering selection strategy that extracts a set of relevant samples from the clusters found in order to reduce the cost of the post-clustering packer processing.

• Release Contributions:
  Version 1.1 brings: - Implementation of so-called SRPs (Scattered Representative Points) for reducing the complexity of the incremental process. - Implementation of a post-grouping strategy for the selection of relevant samples from the constituted groups. - Better modularity of the code.
• Publication:
  hal-03149211
• Contact:
  Olivier Zendra

7.1.1 Foundations of Software Language Engineering

7.1.2 DSL for Scientific Computing

7.1.3 Design lab

In the context of the research on the design lab axis, we worked this year on new abstractions of interaction and we also studied how to build a simulation tool combining modeling techniques and data analysis in the field of transportation with an industrial partner.

ADR Nokia

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

SLIMFAST

• Partners: DGA
• Dates: 2021-2022
• Abstract: Debloating software variability for improving non-functional properties (e.g. security)

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-2021
• Abstract: Demonstrator illustrates 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-2021
• Abstract: Web engineering for domain-specific modeling languages, Fabien Coulon's PhD Cifre project.

OKWind

• Partners: UR1/OKWind
• Dates: 2017-2021
• 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 Associate Teams in the framework of an Inria International Lab or in the framework of an Inria International Program

9.2.1 Visits of international scientists

9.3.1 FP7 & H2020 projects

9.4.1 ANR

9.4.2 DGA

9.4.3 DGAC

IPSCO

• Coordinator: IPSCO
• Partners: UR1, Jamespot, Logpickr.
• Dates: 2021-2023
• Abstract: The IPSCO (Intelligent Support Processes and Communities) project aims to develop a new customer support platform for digital companies and public services. Both by implementing intelligent mechanisms for filtering and processing public requests (customers and partners) and by providing analysis on the organization of the response to these requests. In addition, in order to provide a robust product for small teams, the solution will allow the effective management of expert user communities to foster their autonomy and the emergence of best practices. The integration of this product into an enterprise collaborative platform redefines support by placing it at the heart of its activity. This paradigm shift is part of a fundamental phenomenon that is currently sweeping through companies.

10.1.1 Scientific events: organisation

10.1.2 Scientific events: selection

10.1.3 Journal

10.1.4 Invited talks

Jean-Marc Jézéquel:

• Keynote at 17th European Conference on Modelling Foundations and Applications, Co-located with STAF 2021. Bergen, Norway, June 2021.
• Keynote at ICPE workshop on Performance Modeling. Rennes, France, April 2021

10.1.5 Leadership within the scientific community

• Mathieu Acher:
  • Member of the Steering committee of SPLC conference
  • Member of the Steering committee of VaMoS conference

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

• Benoit Combemale:
  • Chair of the Steering Committee of the ACM SIGPLAN Intl. Conference on Software Language Engineering
  • Funding Member of the Advisory Board of the GEMOC Initiative: On the Globalization of Modeling Languages
  • Steering Committee member of the Modeling Language Engineering and Execution (MLE) workshop
  • Founding member of the International Workshop on Model-Driven Engineering of Digital Twins (ModDiT’21)

• Jean-Marc Jézéquel:
  • Vice-President Informatics Europe
  • Executive Board of the GDR GPL of CNRS
  • Chair of the Software Product Line Most Influencial Paper Award Committee
  • Scientific Advisory Board of Center for Cyber Defense and Information Security, KTH, Sweden

• Olivier Zendra:
  • founder and a member of the Steering Committee of ICOOOLPS (International Workshop on Implementation, Compilation, Optimization of OO Languages, Programs and Systems).
  • Scientific Coordinator of EU H2020 TeamPlay project
  • Member of the EU HiPEAC CSA project Steering Committee
  • Member of the HiPEAC Vision Editorial Board

10.1.6 Scientific expertise

• Arnaud Blouin: reviewer for the "Initiatives de Recherche à Grenoble Alpes" (IRGA) french research project call.

• Olivier Zendra: reviewer for the PhD thesis grants 2021 call of the "Pôle de recherche cyber" (French Cybersecurity Research Center); reviewer of the "Appel à projets génériques" 2021 of ANR (generic research projets call from French National Research Agency); reviewer for the HiPEAC collaboration Grants 2022; scientific CIR/JEI expert for the MESRI

• Olivier Barais:
  • scientific reviewer for WASP NEST Sweden research program
  • member of the scientific board of Pole de compétitivité Image et Réseau
  • scientific reviewer for FRQNT- Programme Samuel-de-Champlain (Quebec)
  • external expert for the H2020 ENACT project
  • scientific expertise for DGRI international program (20 proposals per year)
  • AutoActive board of expert (Norvegian project)

10.1.7 Research administration

Olivier Zendra is a Member of Inria Evaluation Committee.

Olivier Barais lead the jury for hiring a full professor position at University of Rennes 1.

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 Computer Science department and member of the management board at the ESIR engineering school in Rennes until 08/2021, and Benoit Combemale took the responsability afterward. 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 defenses 

Hugo Martin successfully defended his PhD thesis entitled “Machine Learning for Performance Modelling on Colossal Software Configuration Space”. Mathieu Acher and Jean-Marc Jézéquel were the supervisors of the thesis.

Lamine Noureddine successfully defended on 21/12/2021 his PhD thesis in computer science at Université Rennes 1 on “Packing detection and classification relying on machine learning to stop malware propagation” 60. Olivier Zendra has been co-director of this thesis.

Antoine Cheron successfully defended on 17/12/2021 his PhD thesis in computer science at Université Rennes 1 on “Conception, maintenance et évolution non-cassante des API REST”. Olivier Barais and Johann Bourcier have been co-director of this thesis.

Alexandre Rio successfully defended on 26/02/2021 his PhD thesis in computer science at Université Rennes 1 on “Optimisation de l’utilisation des énergies renouvelables : un jumeau numérique pour les microgrilles”. Olivier Barais has been co-director of this thesis.

10.2.3 Juries

• Mathieu Acher was in the jury (reviewer) of Marcel Heinz (University of Koblenz-Landau) PhD thesis "Knowledge Engineering for Software Languages and Software Technologies"
• Jean-Marc Jézéquel was in the jury of Mathieu Acher's HDR of University of Rennes on "Modelling, Reverse Engineering, and Learning Software Variability"
• Olivier Zendra was in the jury of Inès BEN EL OUAHMA PhD thesis of SORBONNE UNIVERSITE on Robustness analysis and assembly codes securisation against physical attacks.
• Olivier Barais was in the jury (reviewer) of Sophie Ebersold's HDR of University of Toulouse on: "Modélisation des systèmes complexes et Points de vue : l’Ingénierie des Modèles centrée utilisateur pour L’Ingénierie Système"
• Olivier Barais was in the jury (president) of Mulugeta Ayalew Tamiru's PhD of Universite of Rennes on: "Automatic resource management in geo-distributed multi-cluster environments"
• Olivier Barais was in the jury (reviewer) of Nikolaos Antoniadis's PhD of Universite of Luxembourg on: "Enhancing Smart Grid Resilience and Reliability by Using and Combining Simulation and Optimization Methods"
• Olivier Barais was in the jury (president) of Elyes Cherfa's PhD of Universite of South Brittany on: "Assistance à la spécification de contraintes OCL dans les métamodèles"

10.3.1 Articles and contents

Olivier Zendra, as a member of its editorial board, contributed to the HiPEAC Vision 2021  57. Our world is evolving very rapidly, both from the technological point of view — with impressive advances in artificial intelligence and new hardware challenging longstanding PC hardware traditions, for example — and as a result of unexpected events. The year 2020 was quite exceptional, an annus horribilis, according to some. It is hard to disagree with this statement, but every dark cloud has a silver lining. 2020 was also the year that accelerated digital transformation beyond what could have been imagined in 2019. Vaccine development happened faster than would ever have been conceivable a year ago, digital payment became the norm for many people and e-commerce and online sales threatened brick and mortar shops. Employees were encouraged to work from home – with its advantages and disadvantages, videoconferencing became the de facto way to interact with both family and colleagues, schools were forced to experiment with distance learning. The list goes on. After living for over a year in an online world, most people will not return completely to the “old normal”. They will go for a combination of the “old normal” and things they discovered and experimented with in the circumstances forced upon us by COVID-19; they might keep their home office on some days, and be in the workplace on other days. Higher education will certainly also continue to offer online teaching. The rapidly evolving digital world has also had an impact on the HiPEAC Vision: updating it every two years no longer seems quite in keeping with the speed of the evolution of computing systems. Therefore, we decided to move from producing a large roadmap document every other year, to an agile, rapidly evolving electronic magazine-like set of articles. The HiPEAC Vision 2021 has two main parts: 1) A set of recommendations for the HiPEAC community. It will also introduce the second part of the Vision and will be updated periodically, or on particular occasions. 2) A set of “articles”, such as in magazines, that will be regularly updated, the purpose of which is to support the set of recommendations, or to introduce new topics or situations. This will guarantee that the HiPEAC Vision keeps evolving and remains up to date. These articles are intended to be self-sufficient and can be read independently. They are grouped into four themes or dimensions: technical, business, societal and European. New articles will be added over the course of the years (and outdated ones might be removed). A further element of this new approach to the Vision is that the editorial board asked and will ask various authors to contribute to those articles. "is adds heterogeneity and a diversity of point of view that could be helpful for better analysis of the computing systems landscape as well as improve the quality of the recommendations.

In 55, we advocate that cybersecurity must come to IT systems now. After decades of apparently low-intensity cyber attacks, during which security was not really thought of on most IT systems, recent years have brought a flurry of well-organized, larger-scale attacks that have caused billions of Euros of damage. This was made possible by the plethora of IT systems that have been produced with no or low security, a trend that has further increased with the rise of ubiquitous computing, with smartphones, IoT and smart-* being everywhere with extremely low control. However, although the current situation in IT systems can still be considered as critical and very much working in favour of cyber attackers, there are definitely paths to massive but doable technical improvements that can lead us to a much more secure and sovereign IT ecosystem, along with strong business opportunities in Europe.

In 54, we claim that whether you're aware of it or not, privacy does matter. While privacy used to be a concern of only a limited number of people, in recent years awareness of it has been growing. This has been for a number of reasons including the enactment of the GDPR, the growing impact of data leaks, data logging by governments and companies, and even the recent discussions about COVID-19 contact tracing. At the same time, most of us are knowingly or unknowingly sending more and more private data to the cloud, which increases the risk of it being leaked or abused in some way. In order to try and reconcile these two opposing directions, consumers and companies alike should increase their usage of privacy-enhancing technologies, and businesses should integrate privacy by design into their development.

In 56, we advocate taming the IT systems complexity hydra. Although most people remain unaware of its presence in the background, the ever-increasing complexity of IT, with its multiple sources, has been an ongoing issue for quite some time. It can even be qualified as a crisis, in both hardware and software. Indeed, this complexity has reached the point where systems are no longer fully understandable by human beings, which raises the question of how we can continue being in full control of their functioning. It is of course a matter of cost for the IT industry. But a number of incidents caused by bugs or a misunderstanding of some part of an IT system have already occurred. With an IT world that is permanently connected on a worldwide scale, the risk of damage caused by the lack of control of IT systems is both real and growing, with errors and malevolent attacks the most likely culprits.Taming the IT complexity hydra is thus more necessary than ever. Fortunately, various solutions can be proposed to tackle the various heads of the hydra (i.e. the various aspects of complexity); these are solutions based on existing methodologies, tools and resources or extensions thereof.

International journals

• 24 articleJ.Juliana Alves Pereira, H.Hugo Martin, M.Mathieu Acher, J.-M.Jean-Marc Jézéquel, G.Goetz Botterweck and A.Anthony Ventresque. Learning Software Configuration Spaces: A Systematic Literature Review.Journal of Systems and SoftwareAugust 2021
  HALDOIback to text
• 25 articleA.Arnaud Blouin and J.-M.Jean-Marc Jézéquel. Interacto: A Modern User Interaction Processing Model.IEEE Transactions on Software Engineering2021, 1-20
  HALDOIback to text
• 26 articleS.Stéphanie Challita, F.Fabian Korte, J.Johannes Erbel, F.Faiez Zalila, J.Jens Grabowski and P.Philippe Merle. Model-Based Cloud Resource Management with TOSCA and OCCI.Software and Systems ModelingFebruary 2021, 1-23
  HALDOIback to text
• 27 articleB.Benoit Combemale, J.Jörg Kienzle, G.Gunter Mussbacher, H.Hyacinth Ali, D.Daniel Amyot, M.Mojtaba Bagherzadeh, E.Edouard Batot, N.Nelly Bencomo, B.Benjamin Benni, J.-M.Jean-Michel Bruel, J.Jordi Cabot, B. H.Betty H C Cheng, P.Philippe Collet, G.Gregor Engels, R.Robert Heinrich, J.-M.Jean-Marc Jézéquel, A.Anne Koziolek, S.Sébastien Mosser, R.Ralf Reussner, H.Houari Sahraoui, R.Rijul Saini, J.June Sallou, S.Serge Stinckwich, E.Eugene Syriani and M.Manuel Wimmer. A Hitchhiker's Guide to Model-Driven Engineering for Data-Centric Systems.IEEE Software3842021
  HALDOIback to text
• 28 articleJ.-E.Jean-Emile DARTOIS, J.Jalil Boukhobza, A.Anas Knefati and O.Olivier Barais. Investigating Machine Learning Algorithms for Modeling SSD I/O Performance for Container-based Virtualization.IEEE transactions on cloud computing93July 2021, 1103-1116
  HALDOIback to text
• 29 articleR.Romina Eramo, F.Francis Bordeleau, B.Benoit Combemale, M.Mark Van Den Brand, M.Manuel Wimmer and A.Andreas Wortmann. Conceptualizing Digital Twins.IEEE Software2021, 1-7
  HALback to text
• 30 articleR.Roland Kretschmer, D. E.Djamel Eddine Khelladi and A.Alexander Egyed. Transforming Abstract to Concrete Repairs with a Generative Approach of Repair Values.Journal of Systems and Software1752021, 19
  HALDOIback to text
• 31 articleR.Roland Kretschmer, D. E.Djamel Eddine Khelladi, R. E.Roberto E Lopez-Herrejon and A.Alexander Egyed. Consistent Change Propagation within Models.Software and Systems Modeling202April 2021, 539-555
  HALDOIback to text
• 32 articleD.Dorian Leroy, J.June Sallou, J.Johann Bourcier and B.Benoit Combemale. When Scientific Software Meets Software Engineering.Computer2021, 1-11
  HALback to text
• 33 articleG.Gauthier Lyan, D.David Gross-Amblard, J.-M.Jean-Marc Jézéquel and S.Simon Malinowski. Impact of Data Cleansing for Urban Bus Commercial Speed Prediction.Springer Nature Computer ScienceNovember 2021, 1-11
  HALback to text
• 34 articleH.Hugo Martin, M.Mathieu Acher, J. A.Juliana Alves Pereira, L.Luc Lesoil, J.-M.Jean-Marc Jézéquel and D. E.Djamel Eddine Khelladi. Transfer Learning Across Variants and Versions: The Case of Linux Kernel Size.IEEE Transactions on Software Engineering2021, 1-17
  HALback to textback to text

International peer-reviewed conferences

• 35 inproceedingsM.Mathieu Acher. Reproducible Science and Deep Software Variability.VaMoS 2022 - 16th International Working Conference on Variability Modelling of Software-Intensive SystemsFlorence, ItalyFebruary 2022
  HAL
• 36 inproceedingsR.Romain Belafia, P.Pierre Jeanjean, O.Olivier Barais, G.Gurvan Le Guernic and B.Benoit Combemale. From Monolithic to Microservice Architecture: The Case of Extensible and Domain-Specific IDEs.MODELS 2021: ACM/IEEE 24th International Conference on Model Driven Engineering Languages and SystemsVirtual, JapanIEEEOctober 2021, 1-10
  HALback to text
• 37 inproceedingsP.Pierre Jeanjean, B.Benoit Combemale and O.Olivier Barais. IDE as Code: Reifying Language Protocols as First-Class Citizens.ISEC 2021 - Innovations in Software Engineering ConferenceBhubaneswar / Virtual, IndiaFebruary 2021, 1-5
  HALback to textback to text
• 38 inproceedingsG.Gwendal Jouneaux, O.Olivier Barais, B.Benoit Combemale and G.Gunter Mussbacher. SEALS: A framework for building Self-Adaptive Virtual Machines.SLE 2021 - 14th ACM SIGPLAN International Conference on Software Language EngineeringChicago, United StatesACMOctober 2021, 1-14
  HALDOIback to text
• 39 inproceedingsG.Gwendal Jouneaux, O.Olivier Barais, B.Benoit Combemale and G.Gunter Mussbacher. Towards Self-Adaptable Languages.Onward! 2021 - ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and SoftwareChicago, United StatesACMOctober 2021, 1-16
  HALback to text
• 40 inproceedingsQ.Quentin Le Dilavrec, D. E.Djamel Eddine Khelladi, A.Arnaud Blouin and J.-M.Jean-Marc Jézéquel. Untangling Spaghetti of Evolutions in Software Histories to Identify Code and Test Co-evolutions.ICMSE'21 - 37th International Conference on Software Maintenance and EvolutionVirtual Event, LuxembourgSeptember 2021, 1-11
  HALback to text
• 41 inproceedingsD.Dorian Leroy, B.Benoît Lelandais, M.-P.Marie-Pierre Oudot and B.Benoit Combemale. Monilogging for Executable Domain-Specific Languages.SLE 2021 - 13th International Conference on Software Language EngineeringChicago, United StatesACMOctober 2021, 1-14
  HALDOIback to text
• 42 inproceedingsL.Luc Lesoil, M.Mathieu Acher, A.Arnaud Blouin and J.-M.Jean-Marc Jézéquel. Deep Software Variability: Towards Handling Cross-Layer Configuration.VaMoS 2021 - 15th International Working Conference on Variability Modelling of Software-Intensive SystemsKrems / Virtual, AustriaFebruary 2021, 1-8
  HALback to text
• 43 inproceedingsL.Luc Lesoil, M.Mathieu Acher, X.Xhevahire Tërnava, A.Arnaud Blouin and J.-M.Jean-Marc Jézéquel. The Interplay of Compile-time and Run-time Options for Performance Prediction.SPLC 2021 - 25th ACM International Systems and Software Product Line Conference - Volume ALeicester, United KingdomACMSeptember 2021, 1-12
  HALDOIback to text
• 44 inproceedingsL.Luc Lesoil, H.Hugo Martin, M.Mathieu Acher, A.Arnaud Blouin and J.-M.Jean-Marc Jézéquel. Transferring Performance between Distinct Configurable Systems : A Case Study.16th International Working Conference on Variability Modelling of Software-Intensive SystemsFlorence, ItalyFebruary 2022
  HALDOIback to text
• 45 inproceedingsG.Gauthier Lyan, D.David Gross-Amblard and J.-M.Jean-Marc Jézéquel. On the Quality of Compositional Prediction for Prospective Analytics on Graphs.DEXA 2021 - Database and Expert Systems Applications - WorkshopsDaWaK 2021 - 23rd International Conference on Big Data Analytics and Knowledge DiscoveryDatabase and Expert Systems Applications - DEXA 2021 WorkshopsLinz, AustriaSeptember 2021, 91-105
  HALDOIback to text
• 46 inproceedingsG.Gauthier Lyan, J.-M.Jean-Marc Jézéquel, D.David Gross-Amblard and B.Benoit Combemale. DataTime: a Framework to smoothly Integrate Past, Present and Future into Models.MODELS 2021 - ACM/IEEE 24th International Conference on Model Driven Engineering Languages and SystemsFukuoka, JapanOctober 2021, 1-11
  HALback to text
• 47 inproceedingsH.Hugo Martin, M.Mathieu Acher, J. A.Juliana Alves Pereira and J.-M.Jean-Marc Jézéquel. A comparison of performance specialization learning for configurable systems.SPLC '21: Proceedings of the 25th ACM International Systems and Software Product Line ConferenceSPLC 2021 - 25th ACM International Systems and Software Product Line ConferenceALeicester, United KingdomACMSeptember 2021, 46-57
  HALDOIback to textback to text
• 48 inproceedingsJ.Johann Mortara, X.Xhevahire Tërnava, P.Philippe Collet and A.-M.Anne-Marie Dery-Pinna. Extending the Identification of Object-Oriented Variability Implementations using Usage Relationships.SPLC 2021 - 25th ACM International Systems and Software Product Line ConferenceVolume BSPLC 2021 - Proceedings of the 25th ACM International Systems and Software Product Line Conference - Volume BLeicester, United KingdomACMSeptember 2021, 1-8
  HALDOI
• 49 inproceedingsL.Lamine Noureddine, A.Annelie Heuser, C.Cassius Puodzius and O.Olivier Zendra. SE-PAC: A Self-Evolving PAcker Classifier against rapid packers evolution.CODASPY '21 - 11th ACM Conference on Data and Application Security and PrivacyVirtual Event, United StatesACMApril 2021, 1-12
  HALDOIback to text
• 50 inproceedingsA. A.Alif Akbar Pranata, O.Olivier Barais, J.Johann Bourcier and L.Ludovic Noirie. ChaT: Evaluation of Reconfigurable Distributed Network Systems Using Metamorphic Testing.GLOBCOM 2021 - IEEE Global Communications ConferenceMadrid, SpainIEEEDecember 2021, 1-6
  HALback to text
• 51 inproceedingsC.Cassius Puodzius, O.Olivier Zendra, A.Annelie Heuser and L.Lamine Noureddine. Accurate and Robust Malware Analysis through Similarity of External Calls Dependency Graphs (ECDG).IWCC 2021 - 10th International Workshop on Cyber Crime (held in conjunction with ARES 2021)ARES 2021 - The 16th International Conference on Availability, Reliability and SecurityVirtual, AustriaACMAugust 2021, 1-12
  HALDOIback to textback to text
• 52 inproceedingsX.Xhevahire Tërnava, L.Luc Lesoil, G. A.Georges Aaron Randrianaina, D. E.Djamel Eddine Khelladi and M.Mathieu Acher. On the Interaction of Feature Toggles.VaMoS 2022 - 16th International Working Conference on Variability Modelling of Software-Intensive SystemsThe Proceedings of 16th International Working Conference on Variability Modelling of Software-Intensive SystemsFlorence, ItalyFebruary 2022
  HALDOI

National peer-reviewed Conferences

• 53 inproceedingsA.Arnaud Blouin and J.-M.Jean-Marc Jézéquel. Programmez vos IHM avec Interacto: une démonstration.GDR GPL 2021 - Journées du Groupement de Recherche du Génie de la Programmation et du LogicielVirtuelle, FranceJune 2021, 1-2
  HAL

Scientific book chapters

• 54 inbookB.Bart Coppens and O.Olivier Zendra. Privacy: whether you're aware of it or not, it does matter!HiPEAC Vision 2021January 2021, 1-6
  HALDOIback to text
• 55 inbookO.Olivier Zendra and B.Bart Coppens. Cybersecurity must come to IT systems now.HiPEAC Vision 2021January 2021, 1-6
  HALback to text
• 56 inbookO.Olivier Zendra and K.Koen De Bosschere. Taming the IT systems complexity hydra.HiPEAC Vision 2021January 2021, 1-8
  HALDOIback to text

Edition (books, proceedings, special issue of a journal)

• 57 bookM.Marc Duranton, K.Koen De Bosschere, B.Bart Coppens, C.Christian Gamrat, t.thomas hoberg, H.Harm Munk, C.Catherine Roderick, T.Tullio Vardanega and O.Olivier Zendra. HiPEAC Vision 2021: High Performance Embedded Architecture And Compilation: Vision 2021.January 2021, 1-228
  HALback to text

Doctoral dissertations and habilitation theses

• 58 thesisM.Mathieu Acher. Modelling, Reverse Engineering, and Learning Software Variability.Université de Rennes 1November 2021
  HAL
• 59 thesisG.Gauthier Lyan. Urban mobility : leveraging machine learning and data masses for the building of simulators.Université Rennes 1September 2021
  HAL
• 60 thesisL.Lamine Noureddine. Packing detection and classification relying on machine learning to stop malware propagation.UNIVERSITE DE RENNES 1; INRIA Rennes - Bretagne AtlantiqueDecember 2021
  HALback to textback to text