3.1.1 Tools for understanding applications

3.1.2 Remodularization analyses

3.1.3 Software Quality

3.2.1 Traits-based program reuse

3.2.2 Reconciling Dynamic Languages and Isolation

7.1.1 Moose

• Name:
  Moose: Software and Data Analysis Platform
• Keywords:
  Software engineering, Meta model, Software visualisation
• Functional Description:
  Moose is an extensive platform for software and data analysis. It offers multiple services ranging from importing and parsing data, to modeling, to measuring, querying, mining, and building interactive and visual analysis tools. The development of Moose has been evaluated to 200 person-years.
• URL:
  http://­www.­moosetechnology.­org
• Contact:
  Stephane Ducasse
• Participants:
  Anne Etien, Nicolas Anquetil, Stephane Ducasse
• Partners:
  Université de Berne, Sensus, Pleiad, USI, Vrije Universiteit Brussel

7.1.2 Pharo

• Keywords:
  Live programmation objet, Reflective system, Web Application
• Functional Description:
  Pharo is a pure object reflective and dynamic language inspired by Smalltalk. In addition, Pharo comes with a full advanced programming environment developed under the MIT License. It provides a platform for innovative development both in industry and research. By providing a stable and small core system, excellent developer tools, and maintained releases, Pharo's goal is to be a platform to build and deploy mission critical applications, while at the same time continue to evolve.
• URL:
  http://­www.­pharo.­org
• Contact:
  Marcus Denker
• Participants:
  Christophe Demarey, Damien Pollet, Esteban Lorenzano, Marcus Denker, Stephane Ducasse, Guillermo Polito, Pablo Tesone
• Partners:
  BetaNine, Reveal, Inceptive, Netstyle, Feenk, ObjectProfile, GemTalk Systems, Greyc Université de Caen - Basse-Normandie, Université de Berne, Yesplan, RMod, Sensus, Université de Bretagne Occidentale, École des Mines de Douai, ENSTA, Uqbar foundation Argentina, ZWEIDENKER, LifeWare, JPMorgan Chase, KnowRoaming, ENIT, Spesenfuchs, FINWorks, Esug, FAST, Ingenieubüro Schmidt, Projector Software, HRWorks, Inspired.org, Palantir Solutions, High Octane, Soops, Osoco, Ta Mère SCRL, University of Yaounde 1, Software Quality Laboratory, University of Novi Sad, Software Institute Università della Svizzera italiana, Universdad Nacional de Quilmes, UMMISCO IRD, Université technique de Prague

7.1.3 Pillar

• Keywords:
  HTML, LaTeX, HTML5
• Functional Description:
  Pillar is a markup syntax and associated tools to write and generate documentation and books. Pillar is currently used to write several books and other documentation. It is used in the tools developed by Feenk.com.
• URL:
  https://­github.­com/­Pillar-markup/­pillar
• Contact:
  Stephane Ducasse
• Partner:
  Feenk

Analyzing Permission Transfer Channels for Dynamically Typed Languages.

Communicating Sequential Process (CSP) is nowadays a popular concurrency model in which threads/processes communicate by exchanging data through channels. Channels help in orchestrating concurrent processes but do not solve perse data races. To prevent data races in the channel model, many programming languages rely on type systems to express ownership and behavioural restrictions such as immutability. However, dynamically-typed languages require run-time mechanisms because of the lack of type information at compile-time. We propose to augment channels with four different permission transfer semantics. We explore two mechanisms to implement such permission transfers at run time: write barriers and partial-read barriers. To validate our approach we implemented a channel framework in Pharo, and we extended it with different permission transfer semantics. We report on performance measurements of both (a) the transfer overhead on a single object and on a graph of objects, and (b) the per-object access overhead incurred by ownership checks. This work stands as a cornerstone of future work on adaptive optimizations for permission transfer channels. 18

Tool demo: fine-grained run-time reflection in Python with Reflectivipy.

Reflectivipy is a Python implementation of sub-method, partial behavioral reflection (SPBR). SPBR provides selective reflection operations applicable to sub-elements of methods (e.g., sub-expressions). SPBR helps in run-time code instrumentation with various application, from advanced debugging to hot patching of running programs. We briefly describe SPBR and its Reflectivipy API and implementation. We illustrate Reflectivipy through two examples: first we build and demonstrate a basic object-centric debugger and describe how SPBR favors its implementation and second, we hot patch a running REST server. 25

Static Basic Block Reordering Heuristics for Implicit Control Flow in Baseline JITs.

Baseline JIT compilers in dynamically-typed languages often use techniques such as static type predictions to optimize common execution paths using static heuristics. Such compilations exhibit implicit slow paths, defined by the language implementation and not by a developer, representing uncommon execution paths e.g., automatic type coercions, type validations and operation reifications. At run time implicit slow paths need to be jumped over and penalize overall execution. Removing implicit slow paths from the main execution path requires code reordering techniques. However, such heuristics are generally designed to work with profiling information. Based on the insight that implicit slow paths are known at compile-time, and thus do not require runtime-profiles, we experimented with two different code reordering algorithms: Pettis-Hansen Bottom-Up augmented with static code layout heuristics, and a slow-to-end heuristic.Our results show that many micro-benchmarks improve their run time by 1.2x. Benchmarks governed by more expensive computations such as message sends or garbage collections show in general no visible performance improvement nor degradations, while very few cases show degradations of up to 1.2x. We show that such static heuristics have low performance impact at compile-time and have great potential when static type predictions are present in the JIT compiler. 28

Profiling Code Cache Behaviour via Events.

Virtual machine performance tuning for a given application is an arduous and challenging task. For example, parametrizing the behaviour of the JIT compiler machine code caches affects the overall performance of applications while being rather obscure for final users not knowledgeable about VM internals. Moreover, VM components are often heavily coupled and changes in some parameters may affect several seemingly unrelated components and may have unclear performance impacts. Therefore, choosing the best parametrization requires to have precise information. We present Vicoca, a tool that allows VM users and developers to obtain detailed information about the behaviour of the code caches and their interactions with other virtual machine components. We present a complex optimization problem due to the heavy interaction of components in the Pharo VM, and we explain it using Vicoca. The information produced by the tool allows developers to produce an optimized configuration for the VM. Vicoca is based on event recording that are manipulated during offline analysis. Vicoca not only allows us to understand this given problem, but it opens the door to future work such as automatic detection of application characteristics, identification of performance issues, and automatic hinting. 19

Cross-ISA Testing of the Pharo VM: Lessons Learned While Porting to ARMv8.

Testing and debugging a Virtual Machine is a laborious task without the proper tooling. This is particularly true for VMs with JIT compilation and dynamic code patching for techniques such as inline caching. In addition, this situation is getting worse when the VM builds and runs on multiple target architectures. We report on several lessons we learned while testing the Pharo VM, particularly during the port of its Cogit JIT compiler to the AArch64 architecture. The Pharo VM presented already a simulation environment that is very handy to simulate full executions and live-develop the VM. However, this full simulation environment makes it difficult to reproduce short and simple testing scenarios. We extended the pre-existing simulation environment with a testing infrastructure and a methodology that allow us to have fine-grained control of testing scenarios, making tests small, fast, reproducible, and cross-ISA. We report on how this testing infrastructure allowed us to cope with two different development scenarios: (1) porting the Cogit JIT compiler to AArch64 without early access to real hardware and (2) debugging memory corruptions due to GC bugs. 17

A debugging approach for live Big Data applications.

Many frameworks exist for programmers to develop and deploy Big Data applications such as Hadoop Map/Reduce and Apache Spark. However, very little debugging support is currently provided in those frameworks. When an error occurs, developers are lost in trying to understand what has happened from the information provided in log files. Recently, new solutions allow developers to record& replay the application execution, but replaying is not always affordable when hours of computation need to be re-executed. We present an online approach that allows developers to debug Big Data applications in isolation by moving the debugging session to an external process when a halting point is reached. We introduce IDRA MR , our prototype implementation in Pharo. IDRA MR centralizes the debugging of parallel applications by introducing novel debugging concepts, such as composite debugging events, and the ability to dynamically update both the code of the debugged application and the same configuration of the running framework. We validate our approach by debugging both application and configuration failures for two driving scenarios. The scenarios are implemented and executed using Port, our Map/Reduce framework for Pharo, also introduced. 7

Time-Traveling Debugging Queries: Faster Program Exploration.

Efficiently debugging a program requires program comprehension. To acquire it, developers explore the program execution, a task often performed using interactive debuggers. Unfortunately, exploring a program execution through standard interactive debuggers is a tedious and costly task. We propose Time-Traveling Queries (TTQs) to ease program exploration. TTQs is a mechanism that automatically explores program executions to collect execution data. This data is used to time-travel through execution states, facilitating the exploration of program executions. We built a set of key TTQs based on typical questions developers ask when trying to understand programs. We conducted a user study with 34 participants to evaluate the impact of our queries on program comprehension activities. Results show that, compared to traditional debugging tools, TTQs significantly improve developers' precision, while reducing required time and efforts when performing program comprehension tasks. 21

Practical Online Debugging of Spark-like applications.

Apache Spark is a framework widely used for writing Big Data analytics applications that offers a scalable and fault-tolerant model based on rescheduling failing tasks on other nodes. While this is well-suited for hardware and infrastructure errors, it is not for application errors as they will reappear in the rescheduled tasks. As a result, applications are killed, losing all the progress and forcing developers to restart them from scratch. Despite the popularity of such a failure-recovery model, understanding and debugging Sparklike applications remain challenging. When an error occurs, developers need to analyze huge log files or undergo timeconsuming replays to find the bug. To address these concerns, we present an online debugging approach tailored to Big Data analytics applications. Our approach includes local debugging of remote parallel exceptions through dynamic local checkpoints, extended with domain-specific debugging operations and live code updating functionality. To deal with data-cleaning errors, we extend our model to easily allow developers to automatically ignore exceptions that happen at runtime. We validate our solution through performance benchmarks that show how our debugging approach is comparable or better than state-of-theart debugging solutions for Big Data. Furthermore, we conduct a user study to compare our approach with another state-of-theart debugging approach, and results show a lower time to find the solution to a bug using our approach, as well as a generally good perception of the features of the debugger. 14

Reflectivipy: building python debuggers with sub-method, partial behavioral reflection.

Building debugging tools is hard and requires powerful tools and libraries. In object-oriented technologies, it is common to use fine-grained reflection to implement debuggers. In this tool presentation, we describe how partial behavioral reflection applied to sub-elements of a method helps in the implementation of advanced debugger features. As an example, we present an implementation of object-centric breakpoints in python. 30

Rotten Green Tests in Java, Pharo and Python: An Empirical Study.

Rotten Green Tests are tests that pass, but not because the assertions they contain are true: a rotten test passes because some or all of its assertions are not actually executed. The presence of a rotten green test is a test smell, and a bad one, because the existence of a test gives us false confidence that the code under test is valid, when in fact that code may not have been tested at all. This article reports on an empirical evaluation of the tests in a corpus of projects found in the wild. We selected approximately one hundred mature projects written in each of Java, Pharo, and Python. We looked for rotten green tests in each project, taking into account test helper methods, inherited helpers, and trait composition. Previous work has shown the presence of rotten green tests in Pharo projects; the results reported here show that they are also present in Java and Python projects, and that they fall into similar categories. Furthermore, we found code bugs that were hidden by rotten tests in Pharo and Python. We also discuss two test smells-missed fail and missed skip-that arise from the misuse of testing frameworks, and which we observed in tests written in all three languages.5

Reuse in component-based prototyping: an industrial experience report from 15 years of reuse.

At Thales Defense Mission Systems, software products first go through an industrial prototyping phase. We elaborate evolutionary prototypes which implement complete business behavior and fulfill functional requirements. We elaborate and evolve our solutions directly with end-users who act as stake-holders in the products' design. Prototypes also serve as models for the final products development. Because software products in the defense industry are developed over many years, this prototyping phase is crucial. Therefore, reusing software is a high-stakes issue in our activities. Component-oriented development helps us to foster reuse throughout the life cycle of our products. The work presented in our paper 6 stems from 15 years of experience in developing prototypes for the defense industry. We directly reuse component implementations to build new prototypes from existing ones. We reuse component interfaces transparently in multiple prototypes, whatever the underlying implementation solutions. This kind of reuse spans prototypes and final products which are deployed on different execution platforms. We reuse non-component legacy software that we integrate in our component architectures. In this case, we seamlessly augment standard classes

From GWT to Angular: An Experiment Report on Migrating a Legacy Web Application.

Berger-Levrault is an international company that developed applications in GWT for more than 10 years. However, GWT is no longer actively maintained, with only one major update since 2015. To avoid being stuck with legacy technology, the company decided to migrate its applications to Angular. However, because of the size of the applications (more than 500 web pages per application), rewriting from scratch is not desirable. To ease the migration, we designed a semi-automated migration approach that helps developers migrate applications' front-end from GWT to Angular and a tool that performs the migration. We present our approach and tool. We validated the approach on concrete application migration and compared its benefits to redeveloping the application manually. We report that the semi-automated migration offers an effort reduction over a manual migration. Finally, we present recommendations for future migration projects. 10

GUI visual aspect migration: a framework agnostic solution.

With the generalization of mobile devices and Web applications, GUI frameworks evolve at a fast pace: JavaFX replaced Swing, Angular 8 replaced Angular 1.4 which had replaced GWT (Google Web Toolkit). This situation forces organizations to migrate their applications to modern frameworks regularly so they do not become obsolete. There has been research in the past on automatic GUI migration. However, and concurrently, large organisations' applications use many dierent technologies. For example, the IT company with which we are working, Berger-Levrault, wishes to migrate applications written in generic programming language (Java/GWT), proprietary 4th generation languages (VisualBasic 6, PowerBuilder), or markup languages (Silverlight). Furthermore, one must expect that in a few years time, new frameworks will appear and new migrations will be required. Thus, there is a need for a language-agnostic migration approach allowing one to migrate various legacy GUI to the latest technologies. None of the existing solutions allow to deal with such a variety of GUI framework. They also typically focus on a subpart of the migration (i.e.how to extract a specific GUI framework) ignoring the re-engineering/forward-engineering part of the migration (which is straightforward for a single technology). This makes it difficult to adapt these solutions to other GUI frameworks. We propose an approach to migrate the GUI part of applications. It is based on meta-models to represent the visual element structure and layout. We detail how to create both the GUI extractors and generators, with guidelines to support new markup and programming languages. We evaluate our approach by implementing three extractors and generators for web-based or desktop-based user interfaces defined with generic programming languages (Java, Pharo, TypeScript) or markup languages (XML, HTML). We comment case studies on five applications, opened and closed source, of different sizes. The implementations of our generic approach detect 99% of the widgets and identify (i.e.determine the type of the widget) of them. We give examples of the migrated GUIs, both successful and not. 9

Risk and Complexity Assessment on the Context of Language Migration.

Language Migration is a highly risky and complex process. Many authors have provided different ways to tackle down the problem, but it is still not completely resolved, even-more it is considered almost impossible on many circumstances. Despite the approaches and solutions available, no work has been done on measuring the risks and complexity of a migration process based on the technological gap. In this article we contribute a first iteration on Language Migration complexity metrics, we apply and interpret metrics on an industrial project. We end the article with a discussion and proposing future works. 11

Report From The Trenches A Case Study In Modernizing Software Development Practices.

One factor of success in software development companies is their ability to deliver good quality products, fast. For this, they need to improve their software development practices. We work with a medium-sized company modernizing its development practices. The company introduced several practices recommended in agile development. If the benefits of these practices are well documented, the impact of such changes on the developers is less well known. We follow this modernization before and during the COVID-19 outbreak. We present an empirical study of the perceived benefit and drawback of these practices as well as the impact of COVID-19 on the company's employees. One of the conclusions, is the additional difficulties created by obsolete technologies to adapt the technology itself and the development practices it encourages to modern standards. 13

Software Migration: A Theoretical Framework.

Software migration has been a research subject for a long time. Major research and industrial implementations were conducted, shaping not only the techniques available nowadays, but also a good part of Software evolution jargon. To understand systematically the literature and grasp the major concepts is challenging and time-consuming. Even more, research evolves, and it does based on the assumption that many words (such as migration) have a single well-known meaning that we all share. Since since these words meanings are rarely explicit, and their usage heterogeneous, these words end up polluted with multiple and many times opposite or incompatible meanings. In our quest to understand, share and contribute in this domain, we recognize this situation as a problem. To tackle down this problem we propose a taxonomy on the sub- ject as a theoretical framework grounded on a systematic literature review. In this study we contribute a bottom-up taxonomy that links from the object of a migration to the procedure nature migration, passing by migration drivers, objectives and approaches. We contribute a classification of all our readings, and a list of research directions discovered on the process of this study. 2926

Migrating GUI behavior: from GWT to Angular.

In a collaboration with Berger-Levrault, a major IT company, we are working on the migration of GWT applications to Angular. We focus on the GUI aspect of this migration which requires a framework switch (GWT to Angular) and a programming language switch (Java to TypeScript). Previous work identified that the GUI can be split into the UI structure and the GUI behavioral code. GUI behavioral code is the code executed when the user interacts with the UI. Although the migration of UI structure has already been studied, the migration of the GUI behavioral code has not. To help developers during the migration of their applications, we propose a generic approach in four steps that uses a meta-model to represent the GUI behavioral code. This approach includes a separation of the GUI behavioral code into events (caller code) and the code executed when an event is fired (called code). We present the approach and its implementation for a real industrial case study. The application comprises 470 Java (GWT) classes representing 56 web pages. We give examples of the migrated code. We evaluate the quality of the generated code with standard tools (SonarQube, codelizer) and compare it to another Java to TypeScript converter. The results show that our code has 53% fewer warnings and rule violations for SonarQube, and 99% fewer for codelizer. 20

Evaluating Machine-Learning Techniques for Detecting Smart Ponzi Schemes.

Ethereum is one of the most popular platforms for exchanging cryptocurrencies as well as the most established for peer to peer programming and smart contracts publishing [3]. The versatility of the Solidity language allows developers to program general-purpose smart contracts. Among the various smart contracts, there may be some fraudulent ones, whose purpose is to steal Ether from the network participants. A notorious example of such cases are Ponzi schemes, i.e. a financial frauds that require investors to be repaid through the investments of others who have just entered the scheme. Within the Ethereum blockchain, several contracts have been identified as being Ponzi schemes. We propose a machine learning model that uses textual classification techniques to recognize contracts emulating the behavior of a Ponzi scheme. Starting from a contracts dataset containing exclusively Ponzi schemes uploaded between 2016 and 2018, we built models able to properly classify Ponzi schemes contracts. We tested several models, some of which returned an overall accuracy of 99% on classification. The best model turned out to be the linear Support Vector Machine and the Multinomial Naive Bayes model, which provides the best results in terms of metrics evaluation. 12

Smart-Graph: Graphical Representations for Smart Contract on the Ethereum Blockchain.

The Ethereum blockchain enables executing and recording smart contracts. The smart contracts can facilitate, verify, and implement the negotiation between multiple parties, also guaranteeing transactions without a traditional legal entity. Many tools supporting the smart contracts development in different areas are flourishing because in Ethereum blockchain valuable assets are often involved. Some of the tools help the developer to find security vulnerabilities via static and/or dynamic analysis or to reduce the Gas fees consumption. Despite the plethora of such tools, there is no tool supporting smart contracts evaluation and analysis via a graphical representation for expert developers. 15

Analysis of Source Code Duplication in Ethreum Smart Contracts.

The practice of writing smart contracts for the Ethereum blockchain is quite recent and still in development. A blockchain developer should expect constant changes in the security software field, as new bugs and security risks are discovered, and new good practices are developed. Following the security practices accepted in the blockchain community is not enough to ensure the writing of secure smart contracts. We discusses the advantages and the disadvantages of code duplication in the Ethereum blockchain ecosystem. 16

A User-Oriented Model for Oracles' Gas Price Prediction.

The Ethereum blockchain is a distributed database of transactions, where the Gas Oracles suggest the users the Gas price's categories to get a transaction recorded. We explore the idea that the Gas Oracles are based on a data-centered model which does not provide users with a reliable prediction. We present an empirical study to test the reliability of the existing Gas Oracles from both the points of view of the Gas price predictions and the existing categories. The study reveals that the Gas Oracles' predictions fail more often than advertised and shows that the Gas price categories do not correspond to the categories set by the users. Therefore we propose a user-oriented model for the Oracles' Gas price prediction, based on two Gas price categories actually corresponding to the users' interests and a new method to estimate the Gas price. The new method, performing the Poisson regression at smaller intervals of time, predicts the Gas price to pay with a lower margin of error when compared to the actual one. The predictions based on the user-oriented model thus provide the users with a more effective Gas price to set. 8

10.1.1 Inria associate team not involved in an IIL or an international program

10.1.2 Inria international partners

University of Chile, Chile

Participants: Stéphane Ducasse.

A. Bergel is working on software analyses. The Moose platform heavily uses Roassal developed in the team of Bergel. We will continue our collaboration. We will use their knowledge on profilers. Prof. J.P. Sandoval is taking a new position in Chile. We co-supervised master students and received interns. We are working on supporting transformations and refactorings as well as recovering variable names.

University of Novi Sad, Serbia

Participants: Stéphane Ducasse, Anne Etien, Nicolas Anquetil, Vincent Aranega.

We started to collaborate with two groups of the University of Novi Sad ( G. Rakic and G. Milosavljevic). We hope post COVID will let us restart our efforts.

Vrije Universiteit Brussel (VUB), Belgium – SOFT

Participants: Guillermo Polito, Matteo Marra.

We collaborate since several years with the Soft team (previously PROG) of the Vrije Universiteit Brussels (Prof E. Gonzalez Boix). We got a large number of exchanges between our two teams - this was slowed down because of COVID. G. Polito co-supervises the PhD of M. Marra with E. Gonzales Boix on debugging map reduce applications.

Université de Chicoutimi au Quebec, Canada

Participants: Steven Costiou, Stéphane Ducasse, from 2020.

We collaborate with F. Petrillo, who builds cloud infrastructures for large-scale evaluation of debuggers. We use these infrastructures for the empirical evaluation of our debugging tools.

University of Zurich, Switzerland

Participants: Steven Costiou, Stéphane Ducasse, from 2020.

We collaborate with A. Bachelli on large-scale evaluations of debugging tools. This collaboration involves 3 researchers and 2 PhD students.

Instituto Federal de Educação Ciência e Tecnologia do Ceará, Brazil

Parcipants: Vincent Aranega, from 2020.

Collaboration with Pr. Antonio Wendell de Oliveira Rodrigues on smart language and DSL for live coding semi-autonomous physical systems (drones).

University of Cagliari, Italy

Participants: Stéphane Ducasse, A. Pierro.

We are working with Prof. Tonelli and Marchesi from University of Cagliari. A. Pierro split his time between the two teams.

Open University, UK

Participants: Marcus Denker and Pablo Tessone, from 2020.

With Prof. Simon Holland and Günter Khyo (Vienna/Austria) we are working on Direct Combination using the new traits model of Pharo.

University of Prague, Czech Republic

Participants: Stéphane Ducasse. From 2015, ongoing.

We are working with Dr. Robert Pergl from the University of Prague. Stéphane Ducasse gave a lecture at the University of Prague in 2018, the next lecture is planned for 2021.

10.2.1 Visits to international teams

10.3.1 FP7 & H2020 projects

RMOD is part of the COST project CERCIRAS: Connecting Education and Research Communities for an Innovative Resource Aware Society.

www.cost.eu/actions/CA19135

11.1.1 Scientific events: organisation

Due to COVID, many events had to be cancelled.

11.1.2 Journal

• Stéphane Ducasse: Ecoop 2022
• Stéphane Ducasse: IST Journal
• Stéphane Ducasse: Infosid
• Anne Etien: Empirical Software Engineering Journal
• Nicolas Anquetil – Empirical Software Engineering Journal
• Nicolas Anquetil – Information and Software Technology Journal
• Nicolas Anquetil – IET Software Journal
• Nicolas Anquetil – Journal of Software: Evolution and Process

11.1.3 Leadership within the scientific community

GT GLIA working group of the CNRS GDR GPL

from 2020

Anne Etien is co-leader of the GT GLIA working group of the Cnrs GDR-GPL (Software Engineering and artificial intelligence)

GT Debugging working group of the CNRS GDR GPL

from 2020

Steven Costiou is leader of the GT Debugging working group of the CNRS GDR GPL. This working group aims to gather any researcher, engineer or GDR team interested in software debugging problems.

11.1.4 Scientific expertise

• Nicolas Anquetil, "Crédit Impôt Recherche" expert evaluation for MINISTÈRE DE L’ENSEIGNEMENT SUPÉRIEUR, DE LA RECHERCHE ET DE L’INNOVATION
• Stéphane Ducasse, "Crédit Impôt Recherche" expert evaluation for MINISTÈRE DE L’ENSEIGNEMENT SUPÉRIEUR, DE LA RECHERCHE ET DE L’INNOVATION

11.1.5 Research administration

• Anne Etien animates the thematic group of Software Engineering and is member of scientific council of CRIStAL lab.
• Anne Etien: Directrice des Études de la L3 MIAGE, Université de Lille

11.2.1 Teaching

• Master: Stéphane Ducasse, Programmation orientée objet, Centrale Lille, 5h CM 5hTD
• Master: Stéphane Ducasse, Meta, Université de Lille, 12hTD
• Licence: Anne Etien, Introduction à la programmation, 40h, L1, Université de Lille
• Licence: Anne Etien, projet, 24h, L2, Université de Lille
• Licence: Anne Etien, Conception orientée objet, 18, L3, Université de Lille
• Licence: Anne Etien, Bases de données relationnelles, 16h, L3, Université de Lille
• Licence: Anne Etien, Génie Logiciel, 27h, L3, Université de Lille
• Master: Anne Etien, Bases de données avancées, 30h, M1, Université de Lille
• Master: Anne Etien, Metamodelisation, 30h, M2, Université de Lille
• Licence: Vincent Aranega, Programmation avancée, Polytech Lille, 35h
• Licence: Vincent Aranega, Meta, Université de Lille, 10h
• Licence: Vincent Aranega, Programmation C, 45h
• Master: Vincent Aranega, Concepts et paradigmes de programmation par la pratique, 120h
• Master: Vincent Aranega, Langages et Modèles Dédiés, 30h
• Master: Vincent Aranega, Méta-Modélisation, 30h
• Master: Steven Costiou, Programmation orientée objet, Centrale Lille, 5h CM 5hTD
• Master: Steven Costiou, Conception et modélisation objet, Polytech Lille, 12h CM 12hTD
• Master: Steven Costiou, Fondamentaux du debugging, Université de Lille, 10hCM 14hTD
• Licence: Nicolas Anquetil, Conception OO Avancée, 48h, L2, IUT- A, Université de Lille, France
• Licence: Nicolas Anquetil, Programation Mobile, 30h, L2, IUT-A, Université de Lille, France
• Licence: Nicolas Anquetil, Projets Agiles, 12h, L2, IUT-A, Université de Lille, France
• Licence: Nicolas Anquetil, Interfaces Hommes-Machines, 32h, L2, IUT-A, Université de Lille, France

11.2.2 Supervision

• PhD: Benoît Verhaeghe, Support à l’automatisation de la migration d’interface d’applications Web : le cas de GWT vers Angular, Oct 21, 2021, Anne Etien, Nicolas Anquetil 24
• PhD: Carolina Hernández, Tools for MicroKernels, Nov 5, 2021. Guillermo Polito and Luc Fabresse 23
• PhD in progress: Oleksandr Zaitsev, Machine Learning-Based Tools to Support Software Evolution, started Jul 2019, Stéphane Ducasse, Nicolas Anquetil
• PhD in progress: Théo Rogliano, On multiple language kernel, started Oct 2019, Stéphane Ducasse, Luc Fabresse
• PhD in progress: Pierre Misse-Chanabier, Modular, green, versatile Virtual Machines, started Oct 2019, Stéphane Ducasse, Noury Bouraqadi
• PhD in progress: Mahugnon Honoré Houekpetodji, Multi-Facet Actionable for Information System Rejuvenation, SPI Lille, France, Stéphane Ducasse, Nicolas Anquetil, Nicolas Dias, Jérome Sudich
• PhD in progress: Santiago Bragagnolo Migration de programmes légataires vers des architectures Web: le cas de de la migration de programmes Microsoft Access vers Angular / Microservices, CIFRE Berger-Levrault, Stéphane Ducasse, Nicolas Anquetil.
• PhD in progress: Maximilian Ignacio Willembrinck Santander, Scriptable Time-Traveling Debuggers, since october 2020, Inria, Anne Etien, Steven Costiou

11.2.3 Juries

Anne Etien

• Zakaria Ournani, Université de Lille, 7 Nov 2021
• Quentin Perez, Mines d'Ales, 13 Dec 2021
• Elles Cherfa, Université Bretagne Sud, 16 Dec 2021

11.3.1 Internal or external Inria responsibilities

• Anne Etien is elected member of the center committee of Inria Lille Nord Europe center.
• Marcus Denker is a member of the AGOS board (Section culture) of Inria Lille

11.3.2 Articles and contents

• books.pharo.org contains two collections of books a technological one and a textbook one. Both collections are edited by S. Ducasse.
• The booklet Concurrent Programming in Pharo was released 22.

11.3.3 Education

• A new version of the MOOC for Pharo was released (Stéphane Ducasse) for its fourth iteration. mooc.pharo.org.

11.3.4 Interventions

• Multiple public remote Pharo Sprints in Lille.

International journals

• 5 articleV.Vincent Aranega, J.Julien Delplanque, M.Matias Martinez, A. P.Andrew P Black, S.Stéphane Ducasse, A.A Etien, C.Christopher Fuhrman and G.Guillermo Polito. Rotten Green Tests in Java, Pharo and Python: An Empirical Study.Empirical Software EngineeringSeptember 2021
  HALback to text
• 6 articleP.Pierre Laborde, S.Steven Costiou, É.Éric Le Pors and A.Alain Plantec. Reuse in component-based prototyping: an industrial experience report from 15 years of reuse.Innovations in Systems and Software EngineeringDecember 2021
  HALback to text
• 7 articleM.Matteo Marra, G.Guillermo Polito and E.Elisa Gonzalez Boix. A debugging approach for live Big Data applications.Science of Computer Programming2021
  HALback to text
• 8 articleG. A.Giuseppe Antonio Pierro, H.Henrique Rocha, S.Stéphane Ducasse, M.Michele Marchesi and R.Roberto Tonelli. A User-Oriented Model for Oracles' Gas Price Prediction.Future Generation Computer SystemsSeptember 2021
  HALback to text
• 9 articleB.Benoît Verhaeghe, N.Nicolas Anquetil, A.Anne Etien, S.Stéphane Ducasse, A.Abderrahmane Seriai and M.Mustapha Derras. GUI visual aspect migration: a framework agnostic solution.Automated Software Engineering282November 2021
  HALDOIback to text
• 10 articleB.Benoit Verhaeghe, A.Anas Shatnawi, A.Abderrahmane Seriai, A.Anne Etien, N.Nicolas Anquetil, M.Mustapha Derras and S.Stephane Ducasse. From GWT to Angular: An Experiment Report on Migrating a Legacy Web Application.IEEE Software2021
  HALDOIback to text

International peer-reviewed conferences

• 11 inproceedingsS.Santiago Bragagnolo, A.Abderrahmane Seriai, S.Stéphane Ducasse and M.Mustapha Derras. Risk and Complexity Assessment on the Context of Language Migration.QUATIC 2021 - 14th International Conference on the Quality of Information and Communications TechnologyFaro / Virtual, PortugalSeptember 2021
  HALback to text
• 12 inproceedingsG.Giacomo Ibba, G. A.Giuseppe Antonio Pierro and M.Marco Di. Evaluating Machine-Learning Techniques for Detecting Smart Ponzi Schemes.2021 IEEE/ACM 4th International Workshop on Emerging Trends in Software Engineering for Blockchain (WETSEB)Madrid, SpainMay 2021
  HALback to text
• 13 inproceedingsH.Houékpétodji Mahugnon Honoré, N.Nicolas Anquetil, S.Stéphane Ducasse, F.Fatiha Djareddir and J.Jérôme Sudich. Report From The Trenches A Case Study In Modernizing Software Development Practices.IEEE International Conference on Software Maintenance and Evolution--Industrial trackLuxembourg, LuxembourgSeptember 2021
  HALback to text
• 14 inproceedingsM.Matteo Marra, G.Guillermo Polito and E.Elisa Gonzalez Boix. Practical Online Debugging of Spark-like applications.IEEE QRS 2021 : International Conference on Software Security and ReliabilityIEEE QRS 2021 : International Conference on Software Security and ReliabilityHainan Island, ChinaDecember 2021
  HALback to text
• 15 inproceedingsG. A.Giuseppe Antonio Pierro. Smart-Graph: Graphical Representations for Smart Contract on the Ethereum Blockchain.2021 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER)Honolulu, United StatesMarch 2021
  HALback to text
• 16 inproceedingsG. A.Giuseppe Antonio Pierro and R.Roberto Tonelli. Analysis of Source Code Duplication in Ethreum Smart Contracts.2021 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER)Honolulu, United StatesMarch 2021
  HALback to text
• 17 inproceedingsG.Guillermo Polito, P.Pablo Tesone, S.Stéphane Ducasse, L.Luc Fabresse, T.Théo Rogliano, P.Pierre Misse-Chanabier and C. H.Carolina Hernandez Phillips. Cross-ISA Testing of the Pharo VM: Lessons Learned While Porting to ARMv8.MPLR ’21, GermanyMünster, GermanySeptember 2021
  HALDOIback to text
• 18 inproceedingsT.Théo Rogliano, G.Guillermo Polito, L.Luc Fabresse and S.Stéphane Ducasse. Analyzing Permission Transfer Channels for Dynamically Typed Languages.DLS 2021 - 17th ACM SIGPLAN International Symposium on Dynamic LanguagesDLS 2021 - 17th ACM SIGPLAN International Symposium on Dynamic LanguagesChicago, FranceOctober 2021
  HALback to text
• 19 inproceedingsP.Pablo Tesone, G.Guillermo Polito and S.Stéphane Ducasse. Profiling Code Cache Behaviour via Events.MPLR ’21Münster, GermanySeptember 2021
  HALDOIback to text
• 20 inproceedingsB.Benoît Verhaeghe, A.Anas Shatnawi, A.Abderrahmane Seriai, N.Nicolas Anquetil, A.Anne Etien, S.Stéphane Ducasse and M.Mustapha Derras. Migrating GUI behavior: from GWT to Angular.International Conference on Software Maintenance and EvolutionInternational Conference on Software Maintenance and EvolutionLuxembourg city, LuxembourgSeptember 2021
  HALback to text
• 21 inproceedingsM.Maximilian Willembrinck, S.Steven Costiou, A.Anne Etien and S.Stéphane Ducasse. Time-Traveling Debugging Queries: Faster Program Exploration.International Conference on Software Quality, Reliability, and SecurityHainan Island, ChinaDecember 2021
  HALback to text

Scientific books

• 22 bookS.Stéphane Ducasse and G.Guillermo Polito. Concurrent Programming in Pharo.September 2021, 52
  HALback to text

Doctoral dissertations and habilitation theses

• 23 thesisC.Carolina Hernández Phillips. Bootstrap-Based Language Development: Turning an existing VM into a polyglot VM.Université de Lille; IMT Lille DouaiNovember 2021
  HALback to text
• 24 thesisB.Benoît Verhaeghe. Incremental Approach for Application GUI Migration using Metamodels.Université de LilleOctober 2021
  HALback to text

Reports & preprints

• 25 reportV.Vincent Aranega, S.Steven Costiou and M.Marcus Denker. Tool demo: fine-grained run-time reflection in Python with Reflectivipy.InriaDecember 2021
  HALback to text
• 26 reportS.Santiago Bragagnolo, N.Nicolas Anquetil, S.Stéphane Ducasse, A.Abderrahmane Seriai and M.Mustapha Derras. Software Migration: A Theoretical Framework (A Grounded Theory approach on Systematic Literature Review).Inria Lille Nord Europe - Laboratoire CRIStAL - Université de Lille2021
  HALback to text
• 27 reportM.Marcus Denker, N.Nicolas Anquetil, V.Vincent Aranega, S.Steven Costiou, S.Stéphane Ducasse, A.Anne Etien and D.Damien Pollet. Project-Team RMoD 2020 Activity Report.INRIA LilleJuly 2021
  HAL
• 28 miscG.Guillermo Polito, S.Stéphane Ducasse and P.Pablo Tesone. Static Basic Block Reordering Heuristics for Implicit Control Flow in Baseline JITs.August 2021
  HALback to text

Other scientific publications

• 29 miscS.Santiago Bragagnolo, N.Nicolas Anquetil, S.Stéphane Ducasse, A.Abderrahmane Seriai and M.Mustapha Derras. Appendix To Software Migration: A Theoretical Framework A Grounded Theory approach on Systematic Literature Review.March 2021
  HALback to text
• 30 inproceedingsS.Steven Costiou, V.Vincent Aranega and M.Marcus Denker. Reflectivipy: building python debuggers with sub-method, partial behavioral reflection.GPL 2021 - Génie de la Programmation et du Logiciel : Journée du Groupement de RechercheOnline, FranceJune 2021
  HALback to text