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:
  https://­modularmoose.­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

Unanticipated Object Synchronisation for Dynamically-Typed Languages

Developing concurrent programs requires the use of threadsafe abstractions to avoid race conditions. Nevertheless, many libraries are not thread-safe either because it was not a concern for the developer or the developer purposely traded thread-safety for performance. All calls to such a library require to be synchronised in the client program. While different synchronisation mechanisms exist, only lock-based solutions and transaction solutions allow one to add synchronisation without anticipation. But they are both about reasoning in terms of execution. It forces developers to explore the whole execution to identify when synchronisation is required. A developer accidentally missing a synchronisation point circumvents the mechanism. Instead by ensuring exclusive access to an object for a thread prevents other thread to access it and thus allows developers to miss synchronisation points without circumventing the mechanism. We propose the Atomic Samurai, a synchronisation model that is object-based, unanticipated, and while the object is synchronised the rest of the program normally runs concurrently. It relies on 3 mechanisms: pointer swapping to ensure reference unicity, proxies to control object accesses and late binding to intercept and redirect messages sent. We validate our approach by showing how Atomic Samurai helps both solving examples extracted from the literature and a real-world scenario from the Pharo community on font rendering. We also measure the impact in performance of our solution by comparing it with a semaphore-based solution. In term of performance, our solution is 5 orders of magnitude slower than the semaphore-based solution, but scales better with the number of processes. 29

How Fast is AI in Pharo? Benchmarking Linear Regression

As many other modern programming languages, Pharo spreads its applications into computationally demanding fields such as machine learning, big data, cryptocurrency, etc. This raises a need for fast numerical computation libraries. In this work, we propose to speed up the low-level computations by calling the routines from highly optimized external libraries, e.g., LAPACK or BLAS through the foreign function interface (FFI). As a proof of concept, we build a prototype implementation of linear regression based on the DGELSD routine of LAPACK. Using three benchmark datasets of different sizes, we compare the execution time of our algorithm agains pure Pharo implementation and scikit-learn - a popular Python library for machine learning. We show that LAPACK/Pharo is up to 2103 times faster than pure Pharo. We also show that scikit-learn is 8-5 times faster than our prototype, depending on the size of the data. Finally, we demonstrate that pure Pharo is up to 15 times faster than the equivalent implementation in pure Python. Those findings can lay the foundation for the future work in building fast numerical libraries for Pharo and further using them in higher-level libraries such as pharo-ai. 23

What do developers consider magic literals? A smalltalk perspective

Literals are constant values (numbers, strings, etc.) used in the source code. Magic literals are such values used without an explicit explanation of their meaning. Such undocumented values may hinder sourcecode comprehension, negatively impacting maintenance. Relatively little literature can be found on the subject beyond the usual (and very old) recommendation of avoiding literals and preferring named constants. Yet, magic literals are still routinely found in source code. We studied literal values in source code to understand when they should be considered magic or not (i.e., acceptable). First, we perform a qualitative study of magic literals, to establish why and under which conditions they are considered harmful. We formalize hypotheses about the reasoning behind how literals are considered magic. Second, we perform a quantitative study on seven real systems ranging from small (a few classes) to large (thousands of classes). We report the literals' types (number, string, Boolean,. . .), their grammatical function (e.g., argument in a call, operand in an expression, value assigned,. . .), or the purpose of the code in which they appear (test methods, regular code). Third, we report on another study involving 26 programmers who analyzed about 24,000 literals, to understand which ones they consider magic. Finally, we evaluate the hypotheses defining specific conditions under which literals are acceptable. We show that (1) literals still exist and are relatively frequent (found in close to 50% of the methods considered); (2) they are more frequent in test methods (in 80% of test methods); (3) to a large extent, they were considered acceptable (only 25% considered magic); and (4) the hypotheses concerning acceptable literals are valid to various degrees. Conclusion: We thus pave the way to future research on magic literals, for example, with tools that could help developers deciding if a literal is acceptable. 7

Differential Testing of Simulation-Based Virtual Machine Generators Automatic Detection of VM Generator Semantic Gaps Between Simulation and Generated VMs

Testing and debugging language Virtual Machines (VMs) is a laborious task without the proper tooling. This complexity is aggravated when the VM targets multiple architectures. To solve this problem, simulation-based VM generator frameworks allow one to write test cases on the simulation, but those test cases do not ensure the correctness of the generated artifact due to the semantic gaps between the simulated VM and generated VMs. We propose Test Transmutation to extend simulation-based VM generator frameworks to support test case generation. It validates the generated VM by also running test cases generated from existing simulation test cases. Results of the generated test cases are compared against the simulation test cases using differential testing. Moreover, test cases are automatically mutated with non-semanticpreserving mutations. Test Transmutation detects bugs that are representative of typical VM modifications. We demonstrate its effectiveness by applying it to a set of real test cases of the Pharo VM. It allowed us to find several issues that were unknown to the VM development team. Our approach shows promising results to test simulationbased VM generator frameworks. 13

Differential testing of simulation-based VM generators

Testing and debugging language Virtual Machines (VMs) is a laborious task without the proper tooling. This complexity is aggravated when the VM targets multiple architectures. Simulation-based VM generator frameworks allow one to write test cases on the simulation, however they do not ensure the correctness of the generated artifact due to the semantic gap between the environments. In this article we propose Test Transmutation. It extends simulation-based VM generator frameworks to also generate simulation test cases and execute them on the generated VMs. It extends such frameworks to translate test cases and applies differential testing and non-semantic-preserving mutations. Test Transmutation detects bugs that are representative of typical VM modifications. Moreover, we apply it to a set of real test cases of the Pharo VM and find several issues. Our approach shows promising results to test simulation-based VM generator frameworks. 14

Ease Virtual Machine Level Tooling with Language Level Ordinary Object Pointers

Virtual Machines (VMs) are critical language execution engines. When tooling the VM level, developers face an important abstraction gap. For instance, a VM supporting an Object-oriented Programming language often manipulates its memory using addresses whereas these addresses are hidden in the language this VM supports. This discourages tooling at the VM level. We propose to use language level object ordinary pointer (LLOOP) to reduce the abstraction gap. LLOOP combine VM level and language level knowledge at the VM level to ease VM tooling. We present our implementation on the Pharo language, which is supported by the Pharo VM. Moreover, we created two tools solving two real-world major bugs in the Pharo environment. These tools required VM level support. First, we investigate how to fix a meta error that was breaking a Pharo environment, preventing it to open. We repair the broken environment by tracking and fixing the language level method responsible for the error at the VM level. Second, we investigate a corrupted Pharo image. A few objects in the Pharo memory space were corrupted i.e., the VM was not able to read and manipulate them. We are able to identify and remove the corrupted objects, fixing the Pharo environment. 15

Interpreter Register Autolocalisation: Improving the performance of efficient interpreters

Interpreter performance has been a hot topic for a long time, where several solutions have been proposed with different ranges of complexity and portability. On the one hand, some work proposes to optimize language-specific features in interpreters such as type dispatches using static type predictions, quickening or type specializations. On the other hand, many solutions focus on improving general interpreter behavior by minimizing branch miss-predictions of interpreter dispatches and stack caching. Some solutions aim for minimizing branch miss-predictions by modifying the intermediate code (e.g., bytecode) design with super-instructions and register-based instructions. Stack caching proposes to optimize the access of operands by caching the top of the stack. interpreter registers are also related to stack caching: interpreter variables that are critical to the efficient execution of the interpreter loop. Examples of such variables are the instruction pointer (IP), the stack pointer (SP), and the frame pointer (FP). Interpreter registers put pressure on the overall design and implementation of the interpreter: Req1: Value access outside the interpreter loop. VM routines outside of the interpreter loop may require access to interpreter registers. For example, this is the case of garbage collectors that need to traverse the stack to find root objects, routines that unwind or reify the stack, or give access to stack values to native methods. Req2: Efficiency. Interpreter registers are used on each instruction to manipulate the instruction stream and the stack. Under-efficient implementations have negative impacts on performance. 16

Porting a JIT Compiler to RISC-V: Challenges and Opportunities

The RISC-V Instruction Set Architecture (ISA) is an open-source, modular and extensible ISA. The ability to add new instructions into a dedicated core opens up perspectives to accelerate VM components or provide dedicated hardware IPs to applications running on top. However, the RISC-V ISA design is clashing on several aspects with other ISAs and therefore software historically built around them. Among them, the lack of condition codes and instruction expansion through simple instruction combination. We present the challenges of porting Cogit, the Pharo's JIT compiler tightly linked to the x86 ISA, on RISC-V. We present concrete examples of them and the rationale behind their inclusion in the RISC-V ISA. We show how those mismatches are solved through design choices of the compilation process or through tools helping development: a VM simulation framework to keep the development in a high-level environment for the most part, an ISA-agnostic test harness covering main VM functionalities and a machine code debugger to explore and execute generated machine code. We also present a way to prototype custom instructions and execute them in the Pharo environment. 12

Interpreter-guided Differential JIT Compiler Unit Testing

Modern language implementations using Virtual Machines feature diverse execution engines such as byte-code interpreters and machine-code dynamic translators, a.k.a. JIT compilers. Validating such engines requires not only validating each in isolation, but also that they are functionally equivalent. Tests should be duplicated for each execution engine exercising the same execution paths on each of them. We present a novel automated testing approach for virtual machines featuring byte-code interpreters. Our solution uses concolic meta-interpretation: it applies concolic testing to a byte-code interpreter to explore all possible execution interpreter paths and obtain a list of concrete values that explore such paths. We then use such values to apply differential testing on the VM interpreter and JIT compiler. This solution is based on two insights: (1) both the interpreter and compiler implement the same language semantics and (2) interpreters are simple executable specifications of those semantics and thus promising targets to (meta-) interpretation using concolic testing. We validated it on 4 different compilers of the open-source Pharo Virtual Machine and found 468 differences between them, produced by 91 different causes, organized in 6 different categories. 17

Reflection as a Tool to Debug Objects

We share our experience with using reflection as a systematic tool to build advanced debuggers. We illustrate the usage and combination of reflection techniques for the implementation of object-centric debugging. Object-centric debugging is a technique for object-oriented systems that scopes debugging operations to specific objects. The implementation of this technique is not straightforward, as there are, to the best of our knowledge, no description in the literature about how to build such debugger. We describe an implementation of object-centric breakpoints. We built these breakpoints with Pharo, a highly reflective system, based on the combination of different classical reflection techniques: proxy, anonymous subclasses, and sub-method partial behavioral reflection. Because this implementation is based on common reflective techniques, it is applicable to other reflective languages and systems for which a set of identified primitives are available. 11

Towards Object-Centric Time-Traveling Debuggers

Object-centric debugging aims at facilitating the debugging of object-oriented programs by focusing debugging operations on specific objects. This technique is tedious to use because developers have to manually find objects to debug, which is not straightforward. Time-traveling debuggers allows developers to explore executions back and forth in time. It has been shown that time-traveling features effectively facilitate debugging and program understanding. We propose to combine these techniques to benefit from both of them to debug objectoriented programs. Time-travel navigation could help finding and remembering objects by providing means to explore executions back and forth. Object-centric debugging could extend time-traveling debugging with object-centric exploration features. These techniques have never been combined, and the challenges and benefits of such combination have never been explored. We present SeekerOC, a time-traveling debugger prototype which provides object-centric debugging support. To combine both techniques, we use Time-Traveling Queries, a query system to automatically explore executions. We discuss the expected benefits of this combination, and we argue that exploring object-centric time-traveling debugging will open new research perspectives towards more effective debugging techniques and tools for object-oriented systems. 20

Understanding Class Name Regularity: A Simple Heuristic and Supportive Visualization.

Studies have shown that more than 50% of software maintenance time is spent reading code to understand it. This puts a strong emphasis on the understandability of source code. Class names constitute one of the first pieces of information developers have access to. To assist developers in understanding the logic and regularity of class names, we present a new and simple visualization, called ClassName Distribution. It brings together package and inheritance as structural perspectives on class names. ClassName Distribution allows one to spot naming irregularities in large hierarchies scattered over multiple packages. We show (1) how this visualization helps capture recurrent patterns relative to concept reference in class names and (2) that this visualization supports the evolution of software systems by monitoring and guiding class renamings over multiple versions. To evaluate our approach we did a consequent assessment with real practitioners and open-source software structured in two different setups: in the first one, we asked domain experts to use the visualization: three groups of engineers applied our tool to the the software they develop or maintain. They proposed and performed respectively 91, 68, and 24 class renamings. In the second setup, as authors of the visualization and the tool (visualization experts), we applied our tool to a new UI framework for Pharo. We sent 34 pull requests for renaming classes and 32 were accepted. Finally, we applied our visualizations to 50 Java projects and identified visual patterns in most of them. Consequently, it shows that the proposed visualization is effective for spotting class name inconsistencies, and this by both developers of the system and external persons. 6

Deprewriter: On the fly rewriting method deprecations

Deprecations are a common way to indicate that a given feature or API will not be available in subsequent versions of a library or framework. While raising deprecation warnings lets developers of libraries evolve their APIs, the developers of client applications often have to manually rewrite their applications to adapt to the deprecation (removal, new APIs...). Some may use static analysis tools to support the rewriting. However, dynamically-typed languages or the use of reflective features often produce incorrect rewrite candidates. This is a costly activity that can lead to bug introductions. In this article, we present a method deprecation approach and a tool called DEPREWRITER that can automatically rewrite the callers of deprecated methods during program execution. Clients of a deprecated API execute their program and associated tests, and DEPREWRITER dynamically rewrites the source code of methods that called a deprecated API to use the new API. The implementation of DEPREWRITER is based on dynamic program transformation: when a deprecated method is executed, a program transformation engine rewrites and recompiles the caller's code before continuing the execution. The approach presented in this article has been developed by the Pharo consortium. Since 2016, DEPREWRITER is used in production in multiple distributions of the Pharo programming language: Pharo 6, 7, 8, and 9 alpha. This article presents and validates this approach. The validation is done in two steps: first with an analysis of deprecations available in Pharo 8 and second with an open survey of software developers about DEPREWRITER. We studied 367 Pharo 8 deprecations, among which we analyzed the 218 rewriting deprecations that use transformation rules. We identified the validity conditions and reported defects to the community. We also proposed 33 transformation rules to be added to the non-rewriting deprecations. Both contributions were accepted into Pharo 9 alpha. We classified the rules and identified possible points of improvement. In addition, we performed a user survey and collected information from 46 software developers: some of them used existing DEPREWRITER' rules and executed them on their code, others used DEPREWRITER to create rewriting deprecations, and finally, some were not aware of DEPREWRITER. 28 of 46 developers (60%) reported that the rewriting deprecations helped them, while 10 stated the inverse and 8 were uncertain. After discussing the current implementation, we sketch possible implementations for other languages than Pharo, showing that the approach is general enough to be applied to other languages. 8

A New Generation of Class Blueprint

In object-oriented programming, classes are the primary abstraction mechanism used by and exposed to developers. Understanding classes is key for the development and evolution of object-oriented applications. The fundamental problem faced by developers is that while classes are intrinsically structured entities, in IDEs they are represented as a blob of text. The idea behind the original CLASS BLUEPRINT visualization was to represent the internal structure of classes in terms of fields, their accesses, and the method call flow. Additional information was depicted using colors. The thus created visualization proved to be an effective means to support program comprehension. However, a number of omissions rendered it only partially useful. We propose CLASS BLUEPRINT V2 (in short BLUEPRINTV2), which in addition to the information depicted by CLASS BLUEPRINT also supports dead code identification, methods under tests, and calling relationships between class and instance level methods. In addition, BLUEPRINTV2 enhances the understanding of fields by showing how fields of super/subclasses are accessed. We present the enhanced visualization and report on a first validation with 26 developers and 18 projects. 9

Transformation-based Refactorings: a First Analysis

Refactorings are behavior preserving transformations. Little work exists on the analysis of their implementation and in particular how refactorings could be composed from smaller, reusable, parts (being simple transformations or other refactorings) and how (non behavior preserving) transformations could be used in isolation or to compose new refactoring operators. In this article we study the seminal implementation and evolution of Refactorings as proposed in the PhD of D. Roberts. Such an implementation is available as the Refactoring Browser package in Pharo. In particular we focus on the possibilities to reuse transformations independently from the behavior preserving aspect of a refactoring. The long term question we want to answer is: Is it possible to have more atomic transformations and refactorings composed out of such transformations? We study preconditions of existing refactorings and identify several families. We identify missed opportunities of reuse in the case of implicit composite refactorings. We analyze the refactorings that are explicitly composed out of other refactorings to understand whether the composition could be expressed at another level of abstraction. This analysis should be the basis for a more systematic expression of composable refactorings as well as the reuse of logic between transformations and refactorings. 10

DepMiner: Automatic Recommendation of Transformation Rules for Method Deprecation

Software applications often depend on external libraries and must be updated when one of those libraries releases a new version. To make this process easier, library developers try to reduce the negative effect of breaking changes by deprecating the API elements before removing them and suggesting replacements to the clients. Modern programming languages and IDEs provide powerful tools for deprecations that can reference the replacement or incorporate the rules written by library developers and use them to automatically update the client code. However, in practice library developers often miss the deprecation opportunities and fail to document the deprecations. In this work, we propose to help library developers support their clients with better deprecations. We rely on the transforming deprecations offered by Pharo and use data mining to detect the missing deprecation opportunities and generate the transformation rules. We implemented our approach for Pharo in a prototype tool called DepMiner. We have applied our tool to five open-source projects and proposed the generated deprecations to core developers of those projects. 63 recommended deprecations were accepted as pull requests. 21

A Hybrid Architecture for the Incremental Migration of a Web Front-end

Nowadays, software migration is an effective solution to adopt new technologies while reusing the business value of existing applications. Among other challenges, the size and complexity of large applications are obstacles that increase the risks of migration projects. Moreover, the migration can imply a switch of programming languages. This is the case when migrating from Java to TypeScript. Thus, it is hard to migrate large and complex applications in one straightforward step. Incremental approaches have been designed to counter this problem. These approaches are based on hybrid architecture usages. However, none of the approaches use a hybrid architecture for GUI defined with different programming languages. We propose a new hybrid architecture that enables the incremental migration of web applications. Our architecture is based on Web Components that allow legacy technology artifacts to work with modern ones. We implement the architecture and use it in the case of migrating GWT applications to Angular. Then, we validate its usability in a real context by migrating an industrial web application. 19

How Libraries Evolve: A Survey of Two Industrial Companies and an Open-Source Community

The evolution of software libraries is a process that requires a joint effort of two groups of developers: the library developers who prepare the release and client developers who need to update their applications to the new versions. To build better tools that support both library and client developers throughout the evolution, we need to understand what problems they face and how they react to those problems. We present the result of two surveys: one for library developers and one for client developers. Our surveys involved developers from two industrial companies and an open-source community. We assess (1) how they perceive the impact of library evolution and (2) what is the support that library developers can provide to their clients. By approaching those questions from the perspectives of library and client developers, we try to assess how challenging library update is for each of those groups and how motivated they are to overcome those challenges. 22

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

10.1.2 Participation in other International Programs

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-supervised 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, Marcus Denker 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).

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 of international scientists

10.2.2 Visits to international teams

10.3.1 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

10.3.2 Digital Europe

Steven Costiou: Work Package Leader : "Skills and Formation" for Inria Lille Nord Europe, European Digital Innovation Hub - GreenPowerIT (Hauts de France). 2022. EDIH

11.1.1 Scientific events: organisation

• ESUG 2022 Novi Sad Serbia.
• Pharo Days March 3-4 2022 Lille, France.

11.1.2 Scientific events: selection

11.1.3 Journal

11.1.4 Invited talks

• Milton Mamani-Torres: Open Source Experience. Talk about About Visualization with Roassal  (09/11/2022)
• Anne Etien: Software Maintenance: Around Test and Program Comprehension at LS2N (12/12/22)
• Guillermo Polito gave an invited talk in Argentina (LAFHIS group, Universidad de Buenos Aires): Máquinas Virtuales Performantes y Robustas: Desafíos Actuales y Pharo como Motor de Research (8/11/22) (Performant and Robust Virtual Machines: Challenges and Pharo as Research Engine)
• Guillermo Polito gave an invited talk in Argentina (Uqbar Foundation, Universidad Tecnológica Nacional Buenos Aires): Implementación de lenguajes y Open Source: mi experiencia en Pharo (Language implementation and Open Source: my Pharo Experience) (12/11/22)

11.1.5 Leadership within the scientific community

GT GLIA working group of the CNRS GDR GPL

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

GT Debugging working group of the CNRS GDR GPL

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. (from 2020)

11.1.6 Scientific expertise

Stéphane Ducasse: Evaluation CIR et JEI (Jeune entreprise innovante)

11.1.7 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

• 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, Programation Web, 16h, L2, IUT-A, Université de Lille, France
• Licence: Nicolas Anquetil, Projets Agiles, 12h, L2, IUT-A, Université de Lille, France
• Master: Santiago Bragagnolo, Navigation autonome , 28h, CM, M1, ISEN
• Master: Santiago Bragagnolo, Initiation aux technologies Blockchain, 6h, CM, M2, Universite de lille (MFCA)
• Master: Steven Costiou, Conception et modélisation objet, Polytech Lille, 12hCM 12hTD
• Master: Steven Costiou, Fondamentaux du debugging, Université de Lille, 4hCM 8hTD
• Master: Steven Costiou, Debugging: bases and implementation, Université de Brest, 4hCM 8hTD
• Master: Stéphane Ducasse, Programmation orientée objet, Centrale Lille, 5h CM 5hTD
• Master: Stéphane Ducasse, Meta, Université de Lille, 12hTD
• Master: Stéphane Ducasse, Conception avancée, Université de Lille, 60hTD
• 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, Metamodelisation, 30h, M2, Université de Lille
• Licence: Carolina Hernandez, Algorithmique et Programmation, 12h, L3, IMT Nord Europe, France
• Licence: Carolina Hernandez, Introduction à la Programmation par Objets avec Java, 20h, L3, IMT Nord Europe, France
• Master: Guillermo Polito, Analyse et Verification de Logiciel, Université de Lille, 16h CM
• Master: Guillermo Polito, Conception et Paradigmes de Programmations par la Pratique, Université de Lille, 48hTD
• Licence: Guillermo Polito, Meta, Université de Lille, 13hTD
•  Licence: Pablo Tesone, Project Programation orientée objet, 20, L3, Polytech Lille

11.2.2 Supervision

• PhD: Pierre Misse-Chanabier, Modular, green, versatile Virtual Machines, started Oct 2019, Stéphane Ducasse, Noury Bouraqadi, finished 16/12/2022
• PhD: Oleksandr Zaitsev, Machine Learning-Based Tools to Support Software Evolution, started Jul 2019, Stéphane Ducasse, Nicolas Anquetil, finished 28/10/2022
• PhD: Mahugnon Honoré Houekpetodji, Multi-Facet Actionable for Information System Rejuvenation, SPI Lille, France, Stéphane Ducasse, Nicolas Anquetil, Nicolas Dias, Jérome Sudich, finished 24/06/2022
• 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
• PhD in progress: Iona Thomas, Elements of Language Strenghtening, since 2021 Stéphane Ducasse, Pablo Tesone, Guillermo Polito
• PhD in progress: Nour-Dijene Agouf, Visualisations for Real software systeme, since 2021, CIFRE Arolla, Stéphane Ducasse, Anne Etien
• PhD in progress: Aless Hosry, Model transformations for automatic source code modification, Nicolas Anquetil.
• PhD in progress: Gabriel Darbord, Automatic Test Generation, since october 2022, Inria through the EPC with BL, Anne Etien, Nicolas Anquetil.
• PhD in progress: Valentin Bourcier, Reducing the cost of debugging with the first generation of object-centric debuggers, since october 2022, Inria, Steven Costiou
• PhD in progress: Nahuel Palumbo, Virtual Machine Generation Techniques, since november 2022, Inria, Stéphane Ducasse, Guillermo Polito

11.2.3 Juries

• Anne Etien: Faezeh Khorram, A Testing Framework for Executable Domain Specific Languages, IMT Atlantic, 12 December 2023, Anne Etien, reviewer.
• Nicolas Anquetil: "confirmation jury" (end of phd 2nd year) of Céline Deknop, supervised by Kim Mens at UC Louvain

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
• Guillermo Polito is a member of the Argentinian Uqbar Foundation
• Guillermo Polito and Marcus Denker are members of the Pharo Board

11.3.2 Articles and contents

• Pharo with Style got published by BOD 24
• Pharo by Example 9 got published by BOD 25
• Article on Inria website: The importance of debugging

11.3.3 Interventions

• We organized Pharo Days March 3-4.
• Pharo Workshop at Inria March 2.
• Multiple public Pharo Sprints in Lille/Online.

International journals

• 6 articleN. J.Nour Jihene Agouf, S.Stéphane Ducasse, A.Anne Etien, A.Abdelghani Alidra and A.Arnaud Thiefaine. Understanding Class Name Regularity: A Simple Heuristic and Supportive Visualization..The Journal of Object Technology212022
  HALDOIback to text
• 7 articleN.Nicolas Anquetil, J.Julien Delplanque, S.Stéphane Ducasse, O.Oleksandr Zaitsev, C.Christopher Fuhrman and Y.-G.Yann-Gael Guéhéneuc. What do developers consider magic literals? A smalltalk perspective.Information and Software Technology149September 2022
  HALDOIback to text
• 8 articleS.Stéphane Ducasse, G.Guillermo Polito, O.Oleksandr Zaitsev, M.Marcus Denker and P.Pablo Tesone. Deprewriter: On the fly rewriting method deprecations..The Journal of Object Technology2112022, 1-23
  HALDOIback to text

International peer-reviewed conferences

• 9 inproceedingsN. J.Nour Jihene Agouf, S.Stéphane Ducasse, A.Anne Etien and M.Michele Lanza. A New Generation of Class Blueprint.VISSOFT 2022 - IEEE Working Conference on Software VisualizationLimassol, CyprusOctober 2022
  HALDOIback to textback to text
• 10 inproceedingsN.Nicolas Anquetil, M.M Campero, S.Stéphane Ducasse, J.-P.J.-P Sandoval and P.Pablo Tesone. Transformation-based Refactorings: a First Analysis.IWST 22 - International Workshop of Smalltalk TechnologiesNovisad, SerbiaAugust 2022
  HALback to text
• 11 inproceedingsS.Steven Costiou, V.Vincent Aranega and M.Marcus Denker. Reflection as a Tool to Debug Objects.SLE 2022 - 15th ACM SIGPLAN International Conference on Software Language EngineeringAuckland, New ZealandDecember 2022
  HALDOIback to text
• 12 inproceedingsQ.Quentin Ducasse, G.Guillermo Polito, P.Pablo Tesone, P.Pascal Cotret and L.Loïc Lagadec. Porting a JIT Compiler to RISC-V: Challenges and Opportunities.Proceedings of the 19th International Conference on Managed Programming Languages and Runtimes (MPLR '22)Brussels, BelgiumSeptember 2022
  HALback to text
• 13 inproceedingsP.Pierre Misse-Chanabier, G.Guillermo Polito, N.Noury Bouraqadi, S.Stéphane Ducasse, L.Luc Fabresse and P.Pablo Tesone. Differential Testing of Simulation-Based Virtual Machine Generators Automatic Detection of VM Generator Semantic Gaps Between Simulation and Generated VMs.International Conference on Software and Software ReuseMontpellier, FranceJune 2022
  HALback to text
• 14 inproceedingsP.Pierre Misse-Chanabier, G.Guillermo Polito, S.Stéphane Ducasse, N.Noury Bouraqadi, L.Luc Fabresse and P.Pablo Tesone. Differential testing of simulation-based VM generators.SAC '22: Proceedings of the 37th ACM/SIGAPP Symposium on Applied ComputingVirtual Event, FranceApril 2022
  HALDOIback to text
• 15 inproceedingsP.Pierre Misse-Chanabier and T.Théo Rogliano. Ease Virtual Machine Level Tooling with Language Level Ordinary Object Pointers.Proceedings of the 14th ACM SIGPLAN International Workshop on Virtual Machines and Intermediate Languages (VMIL '22)Auckland, New ZealandDecember 2022
  HALDOIback to text
• 16 inproceedingsG.Guillermo Polito, N.Nahuel Palumbo, P.Pablo Tesone, S.Soufyane Labsari and S.Stéphane Ducasse. Interpreter Register Autolocalisation: Improving the performance of efficient interpreters.MoreVMs 2022Porto, PortugalMarch 2022
  HALback to text
• 17 inproceedingsG.Guillermo Polito, P.Pablo Tesone and S.Stéphane Ducasse. Interpreter-guided Differential JIT Compiler Unit Testing.Programming Language Design and Implementation - PLDI 2022San Diego, United StatesJune 2022
  HALDOIback to textback to text
• 18 inproceedingsG.Guillermo Polito, P.Pablo Tesone, J.Jean Privat, N.Nahuel Palumbo and S.Stéphane Ducasse. Heap Fuzzing: Automatic Garbage Collection Testing with Expert-Guided Random Events.International Conference on Software TestingDublin, IrelandApril 2023
  HAL
• 19 inproceedingsB.Benoît Verhaeghe, A.Anas Shatnawi, A.Abderrahmane Seriai, A.Anne Etien, N.Nicolas Anquetil, M.Mustapha Derras and S.Stéphane Ducasse. A Hybrid Architecture for the Incremental Migration of a Web Front-end.ICSOFT 2022 - 17th International Conference on Software TechnologiesProceedings of the 17th International Conference on Software Technologies - ICSOFTLisbon, FranceSCITEPRESS - Science and Technology PublicationsJuly 2022, 101-110
  HALDOIback to text
• 20 inproceedingsM.Maximilian Willembrinck, S.Steven Costiou, A.Adrien Vanègue and A.Anne Etien. Towards Object-Centric Time-Traveling Debuggers.International Workshop on Smalltalk Technologies : IWST 22Novi Sad, SerbiaACM Digital LibrariesAugust 2022
  HALback to text
• 21 inproceedingsO.Oleksandr Zaitsev, S.Stéphane Ducasse, N.Nicolas Anquetil and A.Arnaud Thiefaine. DepMiner: Automatic Recommendation of Transformation Rules for Method Deprecation.ICSR 2022 - 20th International Conference on Software and System ReuseMontpellier, FranceJune 2022
  HALback to text
• 22 inproceedingsO.Oleksandr Zaitsev, S.Stéphane Ducasse, N.Nicolas Anquetil and A.Arnaud Thiefaine. How Libraries Evolve: A Survey of Two Industrial Companies and an Open-Source Community.29th Asia-Pacific Software Engineering Conference (APSEC 2022)Virtual, JapanDecember 2022
  HALback to text
• 23 inproceedingsO.Oleksandr Zaitsev, S.Sebastian Jordan Montaño and S.Stéphane Ducasse. How Fast is AI in Pharo? Benchmarking Linear Regression.IWST22 - International Workshop on Smalltalk TechnologiesNovi Sad, SerbiaAugust 2022
  HALback to textback to text

Scientific books

• 24 bookS.Stéphane Ducasse. Pharo with Style.Books on DemandMarch 2022
  HALback to text
• 25 bookS.Stéphane Ducasse, G.Gordana Rakic, S.Sebastijan Kaplar and Q.Quentin Ducasse. Pharo 9 by Example.Books on Demand Collection / Série : The Pharo Technology CollectionMarch 2022
  HALback to text

Reports & preprints

• 26 miscS.Santiago Bragagnolo, S.Stéphane Ducasse, N.Nicolas Anquetil, A.Abderrahmane Seriai and M.Mustapha Derras. Alce: Predicting Software Migration.2022
  HAL
• 27 reportM.Marcus Denker, N.Nicolas Anquetil, V.Vincent Aranega, S.Steven Costiou, S.Stéphane Ducasse and A.Anne Etien. Project-Team RMOD 2021 Activity Report.INRIA Lille - Nord EuropeApril 2022
  HAL
• 28 reportG.Guillermo Polito, S.Stéphane Ducasse, P.Pablo Tesone, L.Luc Fabresse, G.G Thomas, M.M Bacou, L.Loïc Lagadec and P.Pascal Cotret. Remarkable Challenges of High-Performance Language Virtual Machines.Inria Lille - Nord EuropeSeptember 2022
  HAL
• 29 reportT.Théo Rogliano, G.Guillermo Polito, P.Pablo Tesone, L.Luc Fabresse and S.Stéphane Ducasse. Technical Report: Unanticipated Object Synchronisation for Dynamically-Typed Languages.INRIA Lille - Nord EuropeSeptember 2022
  HALback to text
• 30 reportT.Théo Rogliano, G.Guillermo Polito, P.Pablo Tesone, L.Luc Fabresse and S.Stéphane Ducasse. Technical report: Object-centric Access Control Mechanisms in Dynamic Languages.Inria Lille Nord Europe - Laboratoire CRIStAL - Université de LilleSeptember 2022
  HAL

Other scientific publications

• 31 miscS.Stéphane Ducasse, G.Guillermo Polito, P.Pablo Tesone, G.Gaël Thomas and L.Loïc Lagadec. High-performance language virtual machines: an analysis and challenges.March 2022
  HAL
• 32 inproceedingsN.Nahuel Palumbo, P.Pablo Tesone, G.Guillermo Polito and S.Stéphane Ducasse. Selecting Semi-Permanent Object Candidates in Dynamically-Typed Reflective Languages.MPLR 2022 - Managed Programming Languages and RuntimesBrussels, BelgiumSeptember 2022
  HALDOI
• 33 inproceedingsN. M.Nicolás Mauricio Rainhart, G.Guillermo Polito, P.Pablo Tesone and S.Stéphane Ducasse. Analyzing the cost of safety for Vectorized bytecode in dynamically-typed languages.MPLR 2022 - Managed Programming Languages and RuntimesBrussels, BelgiumSeptember 2022
  HALDOI
• 34 inproceedingsM.Maximilian Willembrinck, S.Steven Costiou, A.Anne Etien and S.Stéphane Ducasse. Time-Traveling Queries for Faster Debugging and Program Comprehension.Journées Nationales du Génie de la Programmation et du Logiciel 2022Vannes, FranceJune 2022
  HALback to text