Selected Articles
4 publications
Are Abstract-Interpreter Baseline JITs Worth It? An Empirical Evaluation through Metacompilation.IEEE/ACM International Symposium on Code Generation and Optimization (CGO 2026)2026DOIConference paperA* Heap Fuzzing: Automatic Garbage Collection Testing with Expert-Guided Random Events.International Conference on Software Testing2023Conference paperA Interpreter-guided Differential JIT Compiler Unit Testing.Programming Language Design and Implementation (PLDI'22)2022PDFHALConference paperA* Rotten Green Tests.2019 International Conference on Software Engineering (ICSE), pp. 500–5112019DOIPDFHALConference paperA*
No publications match your search.
Publications
88 publications
Are Abstract-Interpreter Baseline JITs Worth It? An Empirical Evaluation through Metacompilation.IEEE/ACM International Symposium on Code Generation and Optimization (CGO 2026)2026DOIConference paperA* Evaluating Package-Level Scoping Strategies for Repository-Level Code Completion in Pharo.Journal of Computer Languages, vol. 892026DOIHALJournal articleIF 2.40 · SJR Q2 Safe and Efficient Message-Passing Control in Pharo with MethodProxies.Journal of Computer Languages, vol. 892026DOIHALJournal articleIF 2.40 · SJR Q2 Validation of Famix Model Importers with Model Shuffling and Input Reduction.Proceedings of the ACM/IEEE 29th International Conference on Model Driven Engineering Languages and Systems (MODELS 2026), pp. 939–9432026DOIWorkshop paper Building Blocks for Object-Oriented Refactoring Engines.Conference on Information Technology and Its Applications 2025, pp. 473–4892025DOIConference paper Meta-Compilation of Baseline JIT Compilers with Druid.The Art, Science, and Engineering of Programming, vol. 102025DOIHALJournal articleIF N/A · SJR N/A On the Effectiveness of Interpreter-Guided Compiler Testing.Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming2025Workshop paper Package-Aware Approach for Repository-Level Code Completion in Pharo.International Workshop on Smalltalk Technologies (IWST 2025)2025HALWorkshop paper PiNodes in the Druid Meta-Compiler.Proceedings of the International Workshop on Smalltalk Technologies 20252025HALWorkshop paper Towards Better Assessing Performance Effectiveness: A First Analysis with Mutation Testing.Proceedings of the International Workshop on Smalltalk Technologies 20252025HALWorkshop paper A VM-Agnostic and Backwards Compatible Protected Modifier for Dynamically-Typed Languages.The Art, Science, and Engineering of Programming, vol. 82024DOIPDFHALJournal articleIF N/A · SJR N/A Abstract
In object-oriented languages, method visibility modifiers hold a key role in separating internal methods from the public API. Protected visibility modifiers offer a way to hide methods from external objects while authorizing internal use and overriding in subclasses. While present in main statically-typed languages, visibility modifiers are not as common or mature in dynamically-typed languages. In this article, we present ProtDyn, a self-send-based visibility model calculated at compile time for dynamically-typed languages relying on name-mangling and syntactic differentiation of self vs non self sends. We present #Pharo, a ProtDyn implementation of this model that is backwards compatible with existing programs, and its port to Python. Using these implementations we study the performance impact of ProtDyn on the method lookup, in the presence of global lookup caches and polymorphic inline caches. We show that our name mangling and double method registration technique has a very low impact on performance and keeps the benefits from the global lookup cache and polymorphic inline cache. We also show that the memory overhead on a real use case is between 2 % and 13 % in the worst-case scenario. Protected modifier semantics enforces encapsulation such as private but allow developers to still extend the class in subclasses. ProtDyn offers a VM-agnostic and backwards-compatible design to introduce protected semantics in dynamically-typed languages.
Assessing Reflection Usage with Mutation Testing Augmented Analysis.21st International Conference on Software and Systems Reuse (ICSR 2024)2024DOIHALConference paper Evaluating Finalization-Based Object Lifetime Profiling.Proceedings of the 2024 ACM SIGPLAN International Symposium on Memory Management (ISMM)2024DOIHALConference paper MethodProxies: A Safe and Fast Message-Passing Control Library.International Workshop on Smalltalk Technologies 20242024HALWorkshop paper Modular and Extensible Extract Method.International Workshop on Smalltalk Technologies (IWST 2024)2024HALWorkshop paper Pharo: A Reflective Language—Analyzing the Reflective API and Its Internal Dependencies.Journal of Computer Languages, vol. 80, pp. 1012742024DOIHALJournal articleIF 2.40 · SJR Q2 Heap Fuzzing: Automatic Garbage Collection Testing with Expert-Guided Random Events.International Conference on Software Testing2023Conference paperA 2022 Activity Report Project-Team RMOD.INRIA2023PDFHALTechnical report Abstract
This is the yearly report of the RMOD team (http://rmod.inria.fr/). A good way to understand what we are doing.
A Classification of Runtime Reflective Operations in Pharo.Inria2023HALTechnical report Automatic Benchmark Generation.Inria2023WebsiteTechnical report Garbage Collector Tuning in Pathological Allocation Pattern Applications.IWST 2023: International Workshop on Smalltalk Technologies2023HALWorkshop paper ILLIMANI Memory Profiler: A Technical Report.Inria2023HALTechnical report Improving Performance Through Object Lifetime Profiling: The DataFrame Case.IWST 2023: International Workshop on Smalltalk Technologies2023HALWorkshop paper Pharo: A Reflective Language—A First Systematic Analysis of Reflective APIs.IWST 23: International Workshop on Smalltalk Technologies2023HALWorkshop paper Testing in Pharo.Books on Demand2023HALbook Interpreter-guided Differential JIT Compiler Unit Testing.Programming Language Design and Implementation (PLDI'22)2022PDFHALConference paperA* Analyzing the Cost of Safety for Vectorized Bytecode in Dynamically-Typed Languages.Proceedings of the 19th ACM SIGPLAN International Conference on Managed Programming Languages and Runtimes (MPLR 2022)2022DOIHALPoster Deprewriter: On the fly rewriting method deprecations.Journal of Object Technologies (JOT), vol. 212022DOIPDFHALJournal articleIF 1.41 · SJR Q3 Differential Testing of Simulation-Based Virtual Machine Generators.International Conference on Software and Software Reuse (ICSR'22), pp. 103–1192022PDFHALConference paper Differential testing of simulation-based VM generators: automatic detection of VM generator semantic gaps between simulation and generated VMs.Proceedings of the 37th ACM/SIGAPP Symposium on Applied Computing (SAC'22), pp. 1280–12832022PDFHALConference paper High-Performance Language Virtual Machines: An Analysis and Challenges.2022HALOther publication Interpreter Register Autolocalisation: Improving the performance of efficient interpreters.More VM internatlonal Workshop2022PDFHALWorkshop paper Ordering Optimisations in Meta-Compilation of Primitive Methods.FAST Workshop on Smalltalk Related Technologies2022HALWorkshop paper Porting a JIT Compiler to RISC-V: Challenges and Opportunities.Proceedings of the 19th International Conference on Managed Programming Languages and Runtimes (MPLR '22)2022PDFHALWebsiteConference paper Remarkable Challenges of High-Performance Language Virtual Machines.Inria2022HALTechnical report Selecting Semi-Permanent Object Candidates in Dynamically-Typed Reflective Languages.Proceedings of the 19th ACM SIGPLAN International Conference on Managed Programming Languages and Runtimes (MPLR 2022)2022DOIHALPoster Technical report: Object-centric Access Control Mechanisms in Dynamic Languages.Inria Lille Nord Europe - Laboratoire CRIStAL - Université de Lille2022PDFHALWebsiteTechnical report Technical Report: Unanticipated Object Synchronisation for Dynamically-Typed Languages.INRIA Lille - Nord Europe2022PDFHALWebsiteTechnical report Testing Finalization Mechanisms with Heap Fuzzing.FAST Workshop on Smalltalk Related Technologies 20222022Workshop paper Analyzing Permission Transfer Channels for Dynamically Typed Languages.DLS 2021 - 17th ACM SIGPLAN International Symposium on Dynamic Languages2021PDFHALConference paper Cross-ISA Testing of the Pharo VM: Lessons Learned While Porting to ARMv8.Proceedings of the 18th international conference on Managed Programming Languages and Runtimes (MPLR '21)2021DOIPDFHALWebsiteConference paper Pharo Space and Time.2021WebsiteOther publication Abstract
An small project to add some statistics generating code for used space and time for Pharo
Practical Online Debugging of Spark-like Applications.2021 IEEE 21st International Conference on Software Quality, Reliability and Security (QRS)2021DOIHALConference paper Profiling Code Cache Behaviour via Events.Managed Programming Languages and Runtimes (MPLR '21)2021DOIPDFHALWebsiteConference paper Rotten Green Tests in Java, Pharo and Python An Empirical Study.Journal of Empirical Software Engineering2021DOIPDFHALJournal articleIF 4.59 · SJR Q1 Static Basic Block Reordering Heuristics for Implicit Control Flow in Baseline JITs.Inria2021PDFHALTechnical report A debugging approach for live Big Data applications.Science of Computer Programming, vol. 194, pp. 1024602020DOIPDFHALJournal articleIF 1.90 · SJR Q2 Abstract
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. In this paper, 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 IDRAMR, our prototype implementation in Pharo. IDRAMR 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 in this paper.
A new modular implementation for Stateful Traits.Science of Computer Programming, vol. 195, pp. 1–372020DOIPDFHALJournal articleIF 1.90 · SJR Q2 Concurrent Programming in Pharo.Square Bracket Associates, pp. 522020PDFHALWebsiteBooklet Framework-aware debugging with stack tailoring.International Symposium on Dynamic Languages (DSL 20), pp. 71–842020DOIPDFHALConference paper Manage Your Code with Git and Iceberg.Square Bracket Associates, pp. 612020PDFHALWebsiteBooklet Microdown: a Clean and extensible markup language to support Pharo documentation.Proceedings of the 2020 International Workshop on Smalltalk Technologies2020PDFHALWorkshop paper Preserving Instance State during Refactorings in Live Environments.Future Generation Computer Systems, vol. 110, pp. 1-172020DOIPDFHALJournal articleIF 9.19 · SJR Q1 Unified FFI - Calling Foreign Functions from Pharo.Square Bracket Associates, pp. 672020PDFHALWebsiteBooklet Rotten Green Tests.2019 International Conference on Software Engineering (ICSE), pp. 500–5112019DOIPDFHALConference paperA* Abstract
Unit tests are a tenant of agile programming methodologies, and are widely used to improve code quality and prevent code regression. A green (passing) test is usually taken as a robust sign that the code under test is valid. However, some green tests contain assertions that are never executed. We call such tests Rotten Green Tests. Rotten Green Tests represent a case worse than a broken test: they report that the code under test is valid, but in fact do not test that validity. We describe an approach to identify rotten green tests by combining simple static and dynamic call-site analyses. Our approach takes into account test helper methods, inherited helpers, and trait compositions, and has been implemented in a tool called DrTest. DrTest reports no false negatives, yet it still reports some false positives due to conditional use or multiple test contexts. Using DrTest we conducted an empirical evaluation of 19,905 real test cases in mature projects of the Pharo ecosystem. The results of the evaluation show that the tool is effective; it detected 294 tests as rotten-green tests that contain assertions that are not executed. Some rotten tests have been "sleeping" in Pharo for at least 5 years.
Challenges in Debugging Bootstraps of Reflective Kernels.IWST19 - International workshop on Smalltalk Technologies2019PDFHALWorkshop paper DPPy: DPP Sampling with Python.Journal of Machine Learning Research, vol. 20, pp. 1-72019WebsiteJournal articleIF 7.96 · SJR Q1 GildaVM: a Non-Blocking I/O Architecture for the Cog VM.International Workshop on Smalltalk Technologies2019HALWebsiteWorkshop paper Illicium A modular transpilation toolchain from Pharo to C.International workshop of Smalltalk Technologies (IWST'19)2019PDFHALWorkshop paper Sindarin: A Versatile Scripting API for the Pharo Debugger.International Symposium on Dynamic Languages (DSL'19), pp. 67–792019DOIPDFHALConference paper Towards easy program migration using language virtualization.International Workshop of Smalltalk Technology 20192019PDFHALWebsiteWorkshop paper Towards Scalable Blockchain Analysis.2019 IEEE/ACM 2nd International Workshop on Emerging Trends in Software Engineering for Blockchain (WETSEB), pp. 1-72019DOIHALWorkshop paper Abstract
Analysing the blockchain is becoming more and more relevant for detecting attacks and frauds on cryptocurrency exchanges and smart contract activations. However, this is a challenging task due to the continuous growth of the blockchain. For example, in early 2017 Ethereum was estimated to contain approximately 300GB of data [1], a number that keeps growing day after day. In order to analyse such ever-growing amount of data, this paper argues that blockchain analysis should be treated as a novel type of application for Big Data platforms. In this paper we explore the application of parallelization techniques from the Big Data domain, in particular Map/Reduce, to extract and analyse information from the blockchain. We show that our approach significantly improves the index generation by 7.77 times, with a setup of 20 worker nodes, 1 Ethereum node and 1 Database node. We also share our findings of our massively parallel setup for querying Ethereum in terms of architecture and the bottlenecks. This should help researchers setup similar infrastructures for analysing the blockchain in the future.
Virtualization for Porting Programs or Tools to Solve a Puzzle.IWST 2019: International Workshop on Smalltalk Technologies2019HALWorkshop paper Dynamic Software Update from Development to Production.Journal of Object Technology, vol. 17, pp. 1–362018DOIPDFHALJournal articleIF 1.41 · SJR Q3 Abstract
Dynamic Software Update (DSU) solutions update applications while they are executing. These solutions are typically used in production to minimize application downtime, or in integrated development environments to provide live programming support. Each of these scenarios presents different challenges, forcing existing solutions to be designed with only one of these use cases in mind. For example, DSUs for live programming typically do not implement safe point detection or instance migration, while production DSUs require manual generation of patches and lack IDE integration. Also, these solutions have limited ability to update themselves or the language core libraries, and some of them present execution penalties outside the update window. We propose a DSU (gDSU) that works for both live programming and production environments. Our solution implements safe update point detection using call stack manipulation and a reusable instance migration mechanism to minimize manual intervention in patch generation. Moreover, it also offers updates of core language libraries and the update mechanism itself. This is achieved by the incremental copy of the modified objects and an atomic commit operation. We show that our solution does not affect the global performance of the application and it presents only a run-time penalty during the update window. Our solution is able to apply an update impacting 100,000 instances in 1 second. In this 1 second, only during 250 milliseconds the application is not responsive. The rest of the time the application runs normally while gDSU is looking for the safe update point. The update only requires to copy the elements that are modified.
Implementing Modular Class-based Reuse Mechanisms on Top of a Single Inheritance VM.Symposium on Applied Computing (SAC'18)2018DOIPDFHALWebsiteConference paper Abstract
Code reuse is a good strategy to avoid code duplication and speed up software development. Existing object-oriented programming languages propose different ways of combining existing and new code such as e.g., single inheritance, multiple inheritance, Traits or Mixins. All these mechanisms present advantages and disadvantages and there are situations that require the use of one over the other. To avoid the complexity of implementing a virtual machine (VM), many of these mechanisms are often implemented on top of an existing high-performance VM, originally meant to run a single inheritance object-oriented language. These implementations require thus a mapping between the programming model they propose and the execution model provided by the VM. Moreover, reuse mechanisms are not usually composable, nor it is easy to implement new ones for a given language. In this paper, we propose a modular meta-level runtime architecture to implement and combine different code reuse mechanisms. This architecture supports dynamic combination of several mechanisms without affecting runtime performance in a single inheritance object-oriented VM. It includes moreover a reflective Meta-Object Protocol to query and modify classes using the programming logical model instead of the underlying low-level runtime model. Thanks to this architecture, we implemented Stateful Traits, Mixins, CLOS multiple inheritance, CLOS Standard Method Combinations and Beta prefixing in a modular and composable way.
Out-Of-Place debugging: a debugging architecture to reduce debugging interference.The Art, Science, and Engineering of Programming, vol. 32018DOIPDFHALWebsiteJournal articleIF N/A · SJR N/A Abstract
Context Recent studies show that developers spend most of their programming time testing, verifying and debugging software. As applications become more and more complex, developers demand more advanced debugging support to ease the software development process. Inquiry Since the 70's many debugging solutions have been introduced. Amongst them, online debuggers provide good insight on the conditions that led to a bug, allowing inspection and interaction with the variables of the program. However, most of the online debugging solutions introduce debugging interference to the execution of the program, i.e. pauses, latency, and evaluation of code containing side-effects. Approach This paper investigates a novel debugging technique called out-of-place debugging. The goal is to minimize the debugging interference characteristic of online debugging while allowing online remote capabilities. An out-of-place debugger transfers the program execution and application state from the debugged application to the debugger application, each running in a different process. Knowledge On the one hand, out-of-place debugging allows developers to debug applications remotely, overcoming the need of physical access to the machine where the debugged application is running. On the other hand, debugging happens locally on the remote machine avoiding latency. That makes it suitable to be deployed on a distributed system and handle the debugging of several processes running in parallel. Grounding We implemented a concrete out-of-place debugger for the Pharo Smalltalk programming language. We show that our approach is practical by running several benchmarks, comparing our approach with a classic remote online debugger. We show that our prototype debugger outperforms a traditional remote debugger by 1000 times in several scenarios. Moreover, we show that the presence of our debugger does not impact the overall performance of an application. Importance This work combines remote debugging with the debugging experience of a local online debugger. Out-of-place debugging is the first online debugging technique that can minimize debugging interference while debugging a remote application. Yet, it still keeps the benefits of online debugging (e.g., step-by-step execution). This makes the technique suitable for modern applications which are increasingly parallel, distributed and reactive to streams of data from various sources like sensors, UI, network, etc.
Physche: A Little Scheme in Pharo.Square Bracket Associates, pp. 502018PDFHALWebsiteBooklet PTm: State-Aware Transactional Live Programming.IWST 2018: International Workshop on Smalltalk Technologies2018HALWorkshop paper Rotten Green Tests: a First Analysis.Inria2018PDFHALTechnical report Abstract
Unit tests are a tenant of agile programming methodologies, and are widely used to improve code quality and prevent code regression. A passing (green) test is usually taken as a robust sign that the code under test is valid. However, we have noticed that some green tests contain assertions that are never executed; these tests pass not because they assert properties that are true, but because they assert nothing at all. We call such tests Rotten Green Tests. Rotten Green Tests represent a worst case: they report that the code under test is valid, but in fact do nothing to test that validity, beyond checking that the code does not crash. We describe an approach to identify rotten green tests by combining simple static and dynamic analyses. Our approach takes into account test helper methods, inherited helpers, and trait compositions, and has been implemented in a tool called DrTest. We have applied DrTest to several test suites in Pharo 7.0, and identified many rotten tests, including some that have been " sleeping " in Pharo for at least 5 years.
Scoped Extension Methods in Dynamically-Typed Languages.The Art, Science, and Engineering of Programming, vol. 2, pp. 1-262018DOIPDFHALJournal articleIF N/A · SJR N/A An Experiment with lexically-bound extension methods for a dynamic language.Inria Lille-Nord Europe2017PDFHALWebsiteTechnical report Abstract
An extension method is a method declared in a package other than the package of its host class. Thanks to extension methods, developers can adapt classes they do not own to their needs: adding methods to core classes is a typical use case. This is particularly useful for adapting software and therefore increasing reusability. In most dynamically-typed languages, extension methods are globally visible. Because any developer can define extension methods for any class, naming conflicts occur: if two developers define an extension method with the same signature in the same class, only one extension method is visible and overwrites the other. Similarly, if two developers each define an extension method with the same name in a class hierarchy, one overrides the other. Existing solutions typically rely on a dedicated and slow method lookup algorithm to resolve conflicts at runtime. In this article, we present a model of scoped extension methods that minimizes accidental overrides and we present an implementation in Pharo that incurs little performance overhead. This implementation is based on lexical scope and hierarchy-first strategy for extension scoping.
Analysis and exploration for new generation debuggers.Proceedings of the 12th Edition of the International Workshop on Smalltalk Technologies, pp. 5:1–5:62017DOIPDFHALWorkshop paper Abstract
Locating and fixing bugs is a well-known time consuming task. Advanced approaches such as object-centric or back-in-time debuggers have been proposed in the literature, still in many scenarios developers are left alone with primitive tools such as manual breakpoints and execution stepping. In this position paper we explore several advanced on-line debugging techniques such as advanced breakpoints and on-line execution comparison, that could help developers solve complex debugging scenarios. We analyse the challenges and underlying mechanisms required by these techniques. We present some early but promising prototypes we built on the Pharo programming language. We finally identify future research paths by analysing existing research and connecting it to the techniques we presented before.
Debugging Cyber-Physical Systems with Pharo.Proceedings of the 12th Edition of the International Workshop on Smalltalk Technologies, pp. 8:1–8:102017DOIPDFHALWebsiteWorkshop paper Abstract
Cyber-Physical Systems (CPS) integrate sensors and actua-tors to collect data and control entities in the physical world. Debugging CPS systems is hard due to the time-sensitive nature of a distributed applications combined with the lack of control on the surrounding physical environment. This makes bugs in CPS systems hard to reproduce and thus to fix. In this context, on-line debugging techniques are helpful because the debugger is connected to the device when an exception or crash occurs. This paper reports on our experiences on applying two different on-line debugging techniques for a CPS system: remote debugging using the Pharo remote debugger and our IDRA debugger. In contrast to traditional remote debug-ging, IDRA allows to on-line debug an application locally in another client machine by reproducing the runtime context where the bug manifested. Our qualitative evaluation shows that IDRA provides almost the same interaction capabilities than Pharo's remote debugger and is less intrusive when performing hot-modifications. Our benchmarks also show that IDRA is significantly faster than the Pharo remote debugger, although it increases the amount of data transferred over the network.
First-Class Undefined Classes for Pharo.Proceedings of the 12th Edition of the International Workshop on Smalltalk Technologies, pp. 9:1–9:82017DOIPDFHALWebsiteWorkshop paper Abstract
Loading code inside a Pharo image is a daily concern for a Pharo developer. Nevertheless, several problems may arise at loading time that can prevent the code to load or even worse let the system in an inconsistent state. In this paper, we focus on the problem of loading code that references a class that does not exist in the system. We discuss the different flavors of this problem, the limitations of the existing Undeclared mechanism and the heterogeneity of Pharo tools to solve it. Then, we propose an unified solution for Pharo that reifies Undefined Classes. Our model of Undefined Classes is the result of an objective selection among different alternatives. We then validate our solution through two cases studies: migrating old code and loading code with circular dependencies. This paper also presents the integration of this solution into Pharo regarding the needed Meta-Object Protocol for Undefined Classes and the required modifications of existing tools.
N2S3, an Open-Source Scalable Spiking Neuromorphic Hardware Simulator.Université de Lille2017HALTechnical report Run-Fail-Grow: Creating Tailored Object-Oriented Runtimes.The Journal of Object Technology, vol. 16, pp. 2:1-362017DOIPDFHALWebsiteJournal articleIF 1.41 · SJR Q3 Abstract
Producing a small deployment version of an application is a challenge because static abstractions such as packages cannot anticipate the use of their parts at runtime. Thus, an application often occupies more memory than actually needed. Tailoring is one of the main solutions to this problem i.e., extracting used code units such as classes and methods of an application. However, existing tailoring techniques are mostly based on static type annotations. These techniques cannot efficiently tailor applications in all their extent (e.g., runtime object graphs and metadata) nor be used in the context of dynamically-typed languages. We propose a run-fail-grow technique to tailor applications using their runtime execution. Run-fail-grow launches (a) a reference application containing the original application to tailor and (b) a nurtured application containing only a seed with a minimal set of code units the user wants to ensure in the final application. The nurtured application is executed, failing when it founds missing objects, classes or methods. On failure, the necessary elements are installed into the nurtured application from the reference one, and the execution resumes. The nurtured application is executed until it finishes, or until the developer explicitly finishes it, for example in the case of a web application. resulting in an object memory (i.e., a heap) with only objects, classes and methods required to execute the application. To validate our approach we implemented a tool based on Virtual Machine modifications, namely Tornado. Tornado succeeds to create very small memory footprint versions of applications e.g., a simple object-oriented heap of 11kb. We show how tailoring works on application code, base and third-party libraries even supporting human interaction with user G. interfaces. These experiments show memory savings ranging from 95% to 99%.
Instance Migration in Dynamic Software Update.Meta'162016PDFHALWebsiteConference paper A Bootstrapping Infrastructure to Build and Extend Pharo-Like Languages.Onward! 20152015PDFHALConference paper Abstract
Bootstrapping is well known in the context of compilers, where a bootstrapped compiler can compile its own source code. Bootstrapping is a beneficial engineering practice because it raises the level of abstraction of a program making it easier to understand, optimize, evolve, etc. Bootstrapping a reflective object-oriented language is however more challenging, as we need also to initialize the runtime of the language with its initial objects and classes besides writing its compiler. In this paper, we present a novel bootstrapping infrastructure for Pharo-like languages that allows us to easily extend and modify such languages. Our bootstrapping process relies on a first-class runtime. A first-class runtime is a meta-object that represents a program's runtime and provides a MOP to easily load code into it and manipulate its objects. It decouples the virtual machine (VM) and language concerns by introducing a clear VM-language interface. Using this process, we show how we succeeded to bootstrap a Smalltalk-based language named Candle and then extend it with traits in less than 250 lines of high-level Smalltalk code. We also show how we can bootstrap with minimal effort two other languages (Pharo and MetaTalk) with similar execution semantics but different object models.
DeltaImpactFinder: Assessing Semantic Merge Conflicts with Dependency Analysis.IWST'15: International Workshop on Smalltalk Technologies 20152015PDFHALWebsiteWorkshop paper Abstract
In software development, version control systems (VCS) provide branching and merging support tools. Such tools are popular among developers to concurrently change a codebase in separate lines and reconcile their changes automatically afterwards. However, two changes that are correct independently can introduce bugs when merged together. We call semantic merge conflicts this kind of bugs. Change impact analysis (CIA) aims at estimating the effects of a change in a codebase. In this paper, we propose to detect semantic merge conflicts using CIA. On a merge, DELTAIMPACTFINDER analyzes and compares the impact of a change in its origin and destination branches. We call the difference between these two impacts the delta-impact. If the delta-impact is empty, then there is no indicator of a semantic merge conflict and the merge can continue automatically. Otherwise, the delta-impact contains what are the sources of possible conflicts.
Virtualization Support for Application Runtime Specialization and Extension.University Lille 1 - Sciences et Technologies - France2015PDFHALPhD thesis Abstract
An application runtime is the set of software elements that represent an application during its execution. Application runtimes should be adaptable to different contexts. Advances in computing technology both in hardware and software indeed demand it. For example, on one hand we can think about extending a programming language to enhance the developers' productivity. On the other hand we can also think about transparently reducing the memory footprint of applications to make them fit in constrained resource scenarios e.g., low networks or limited memory availability. We propose Espell, a virtualization infrastructure for object-oriented high-level language runtimes. Espell provides a general purpose infrastructure to control and manipulate object-oriented runtimes in different situations. A first-class representation of an object-oriented runtime provides a high-level API for the manipulation of such runtime. A hypervisor uses this first-class object and manipulates it either directly or by executing arbitrary expressions into it. We show with our prototype that this infrastructure supports language bootstrapping and application runtime tailoring. Using bootstrapping we describe an object-oriented high-level language initialization in terms of itself. A bootstrapped language takes advantage of its own abstractions and is easier to extend. With application runtime tailoring we generate specialized applications by extracting the elements of a program that are used during execution. A tailored application encompasses only the classes and methods it needs and avoids the code bloat that appears from the usage of third-party libraries and frameworks.
Virtualization Support for Dynamic Core Library Update.Onward! 20152015PDFHALConference paper Abstract
Dynamically updating language runtime and core libraries such as collections and threading is challenging since the update mechanism uses such libraries at the same time that it modifies them. To tackle this challenge, we present Dy- namic Core Library Update (DCU) as an extension of Dy- namic Software Update (DSU) and our approach based on a virtualization architecture. Our solution supports the up- date of core libraries as any other normal library, avoiding the circular dependencies between the updater and the core libraries. Our benchmarks show that there is no evident performance overhead in comparison with a default execution. Finally, we show that our approach can be applied to real life scenario by introducing a critical update inside a web application with 20 simulated concurrent users.
Bootstrapping Reflective Systems: The Case of Pharo.Science of Computer Programming, vol. 96, pp. 141-1552014DOIPDFHALJournal articleIF 1.90 · SJR Q2 Abstract
Bootstrapping is a technique commonly known by its usage in language definition by the introduction of a compiler written in the same language it compiles. This process is important to understand and modify the definition of a given language using the same language, taking benefit of the abstractions and expression power it provides. A bootstrap, then, supports the evolution of a language. However, the infrastructure of reflective systems like Smalltalk includes, in addition to a compiler, an environment with several self-references. A reflective system bootstrap should consider all its infrastructural components. In this paper, we propose a definition of bootstrap for object-oriented reflective systems, we describe the architecture and components it should contain and we analyze the challenges it has to overcome. Finally, we present a reference bootstrap process for a reflective system and Hazelnut, its implementation for bootstrapping the Pharo Smalltalk-inspired system.
Understanding Pharo's Global State to Move Programs Through Time and Space.International Workshop on Smalltalk Technologies2014HALWorkshop paper Understanding Pharoś global state to move programs through time and space.IWST - International Workshop on Smalltalk Technology, Co-located within the 22th International Smalltalk Conference - 20142014PDFHALWorkshop paper Abstract
Code mobility is a mechanism that allows the migration of running programs between different environments. Such migration includes amongst others the migration of application data and resources. Applicationś data is is usually composed by elements of different nature: from printers and files, to framework and domain objects. This application data will be transported along with the code of its program in space (when serialized and deployed in another environment) or time (when a new session is started in a different point of time). The main problem when moving around code resides, in our understanding, to global state. While unreferenced leaf objects are garbage collected, those referenced (transitively) by some global object will remain alive. In order to support code mobility in time and space, we need to understand how global application data is used. With this purpose, we study and classify Pharoś global state. This classification uncovers some common patterns and provides a first insight on how global state should be managed, specially in code mobility scenarios. As a minor contribution, we also discuss solutions to each of the found categories.
Virtual Smalltalk Images: Model and Applications.IWST - International Workshop on Smalltalk Technology, Co-located within the 21th International Smalltalk Conference - 20132013PDFHALWorkshop paper Abstract
Reflective architectures are a powerful solution for code browsing, debugging or in-language process handling. However, these reflective architectures show some limitations in edge cases of self-modification and self-monitoring. Modifying the modifier process or monitoring the monitor process in a reflective system alters the system itself, leading to the impossibility to perform some of those tasks properly. In this paper we analyze the problems of reflective architectures in the context of image based object-oriented languages and solve them by providing a first-class representation of an image: a virtualized image. We present Oz, our virtual image solution. In Oz, a virtual image is represented by an object space. Through an object space, an image can manipulate the internal structure and control the execution of other images. An Oz object space allows one to introspect and modify execution information such as processes, contexts, existing classes and objects. We show how Oz solves the edge cases of reflective architectures by adding a third participant, and thus, removing the self modification and self-observation constraints.
Semantics and Security Issues in JavaScript.RMod – INRIA Lille-Nord Europe2012Technical report Abstract
There is a plethora of research articles describing the deep semantics of JavaScript. Nevertheless, such articles are often difficult to grasp for readers not familiar with formal semantics. In this report, we propose a digest of the semantics of JavaScript centered around security concerns. This document proposes an overview of the JavaScript language and the misleading semantic points in its design. The first part of the document describes the main characteristics of the language itself. The second part presents how those characteristics can lead to problems. It finishes by showing some coding patterns to avoid certain traps and presents some ECMAScript 5 new features.
A Programming Environment Supporting a Prototype-Based Introduction to OOP.Proceedings of the International Workshop on Smalltalk Technologies, pp. 1–52011DOIWorkshop paper Extended results of Tornado: A Run-Fail-Grow approach for Dynamic Application Tayloring.RMod – INRIA Lille-Nord Europe2011PDFTechnical report Abstract
Producing a small deployment version of an application is a challenge because static abstractions such as packages cannot anticipate the use of their parts. As such, an application often occupies more memory than actually needed. To solve this problem we propose Tornado, a technique to dynamically tailor applications to only embed code (classes and methods) they use. Tornado uses a run-fail-grow approach to prepare an application for deployment. It launches minimal version of an application and installs a minimal set of statements that will start the user's application. This application is run and these statements are executed. When the application fails because there are classes or methods missing, the necessary code is installed. The application is executed until it reaches a stable point, allowing possibly human interaction for applications with UIs. Thus, Tornado creates minimal memory footprint versions of applications by tailoring the whole application's code, including run-time and third party libraries. We used Tornado to tailor two different applications. We succeeded to tailor a hello world application to occupy 1
No publications match your search.