Bootstrapping Reflective Systems: The Case of Pharo

International audienceBootstrapping 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

Virtualisation pour Specialisation et Extension d'Environnements d'Execution

An application runtime is the set of software elements that represent an application during its execution. Application runtimes should be adaptable todifferent contexts. Advances in computing technology both in hardware and software indeed demand it. For example, on one hand we can think aboutextending 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 resourcescenarios 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.Un environnement d’exécution est l’ensemble des éléments logiciels qui représentent une application pendant son exécution. Les environnements d’exécution doivent être adaptables à différents contextes. Les progrès des technologies de l’information, tant au niveau logiciel qu’au niveau matériel, rendent ces adaptations nécessaires. Par exemple, nous pouvons envisager d’étendre un language de programmation pour améliorer la productivité des developpeurs. Aussi, nous pouvons envisager de réduire la consommation memoire des applications de manière transparente afin de les adapter à certaines contraintes d’exécution e.g., des réseaux lents ou de la mémoire limités.Nous proposons Espell, une infrastructure pour la virtualisation d’environnement d’execution de langages orienté-objets haut-niveau. Espell fournit une infrastructure généraliste pour le contrôle et la manipulation d’environnements d’exécution pour différentes situations. Une représentation de ’premier-ordre’ de l’environnement d’exécution orienté objet fournit une interface haut-niveau qui permet la manipulation de ces environnements. Un hyperviseur est client de cette représentation de ’premier-ordre’ et le manipule soit directement, soit en y exécutant des expressions arbitraires. Nous montrons au travers de notre prototype que cet infrastructure supporte le bootstrapping (i.e., l’amorçage ou initialisation circulaire) des languages et le tailoring (i.e., la construction sur-mesure ou ’taille’) d’environnement d’exécution. En utilisant l’amorçage nous initialisons un language orienté-objet haut-niveau qui est auto-décrit. Un langage amorcé profite des ses propres abstractions se montrant donc plus simple à étendre. La taille d’environnements d’exécution est une technique qui génère une application spécialisé en extrayant seulement le code utilisé pendant l’exécution d’un programme. Une application taillée inclut seulement les classes et méthodes qu’elle nécessite, et évite que des librairies et desframeworks externes surchargent inutilement la base de code

Activity Report 2012. Project-Team RMOD. Analyses and Languages Constructs for Object-Oriented Application Evolution

Activity Report 2012 Project-Team RMOD Analyses and Languages Constructs for Object-Oriented Application Evolutio

Benzo: Reflective Glue for Low-level Programming

International audienceThe goal of high-level low-level programming is to bring the abstraction capabilities of high-level languages to the system programming domain, such as virtual machines (VMs) and language runtimes. However, existing solutions are bound to compilation time and expose limited possibilities to be changed at runtime and from language-side. They do not fit well with fully reflective languages and environments. We propose Benzo1, a lightweight framework for high- level low-level programming that allows developers to generate and execute at runtime low-level code (assembly). It promotes the implementation, and dynamic modification, of system components with high-level language tools outperforming existing dynamic solutions. Since Benzo is a general framework we choose three applications that cover an important range of the spectrum of system programming for validating the infrastructure: a For- eign Function Interface (FFI), primitives instrumentation and a just-in-time bytecode compiler (JIT). With Benzo we show that these typical VM-level components are feasible as reflective language-side implementations. Due to its unique combination of high-level reflection and low-level programming, Benzo shows better performance for these three applications than the comparable high-level implementations

Project-Team RMoD (Analyses and Language Constructs for Object-Oriented Application Evolution) 2011 Activity Report

This is the yearly report of the RMOD team (http://rmod.lille.inria.fr/). A good way to understand what we are doing

Bootstrapping a Smalltalk

International audienceSmalltalk is a reflective system. It means that it is defined in itself in a causally connected way. Traditionally, Smalltalk systems evolved by modifying and cloning what is called an image (a chunk of memory containing all the objects at a given point in time). During the evolution of the system, objects representing it are modified. However, such an image modification and cloning poses several problems: (1) There is no operational machine-executable algorithm that allows one to build a system from scratch. A system object may be modified but it may be difficult to reproduce its exact state before the changes. Therefore it is difficult to get a reproducible process. (2) As a consequence, certain classes may not have been initialized since years. (3) Finally, since the system acts as a living system, it is not simple to evolve the kernel for introducing new abstractions without performing some kind of brain surgery on oneself. There is a need to have a step by step process to build Smalltalk kernels from scratch. In this paper, after an analysis of past and current practices to mutate or generate kernels, we describe a kernel bootstrap process step-by-step. First the illusion of the existence of a kernel is created via stubs objects. Second the classes and meta-classes hierarchy are generated. Code is compiled and finally information needed by the virtual machine and execution are generated and installed

Bridging the Gap between Machine and Language using First-Class Building Blocks

High-performance virtual machines (VMs) are increasingly reused for programming languages for which they were not initially designed. Unfortunately, VMs are usually tailored to specific languages, offer only a very limited interface to running applications, and are closed to extensions. As a consequence, extensions required to support new languages often entail the construction of custom VMs, thus impacting reuse, compatibility and performance. Short of building a custom VM, the language designer has to choose between the expressiveness and the performance of the language. In this dissertation we argue that the best way to open the VM is to eliminate it. We present Pinocchio, a natively compiled Smalltalk, in which we identify and reify three basic building blocks for object-oriented languages. First we define a protocol for message passing similar to calling conventions, independent of the actual message lookup mechanism. The lookup is provided by a self-supporting runtime library written in Smalltalk and compiled to native code. Since it unifies the meta- and base-level we obtain a metaobject protocol (MOP). Then we decouple the language-level manipulation of state from the machine-level implementation by extending the structural reflective model of the language with object layouts, layout scopes and slots. Finally we reify behavior using AST nodes and first-class interpreters separate from the low-level language implementation. We describe the implementations of all three first-class building blocks. For each of the blocks we provide a series of examples illustrating how they enable typical extensions to the runtime, and we provide benchmarks validating the practicality of the approaches

Pharo's Vision: Goals, Processes, and Development Effort

This document presents the goals, processes, architectural vision and current and future development efforts in Pharo core. It will serve as a working document to structure the effort for the next versions of Pharo core. By Pharo core, we mean the essential parts of the system, such as the compiler, basic libraries, and key infrastructure such as canvas, events, etc. We hope that this document will also bring good energy to achieve some of the goals described in the roadmap. It document should be read as a proposal and explanation of some of our effort. Now by no means what we describe here is carved into stone. We are really interested in constructive criticism, comments and suggestions. In addition, people who want to participate to the definition of this document are welcome. Finally, we are convinced that the best core is nothing if it has no cool libraries; so we encourage people to build libraries and we will support them. We hope that this document will put a good light on what we want to achieve and share with the community. We also hope that it will make clear what the system we want and that we can build it together