Two decades of smalltalk VM development: live VM development through simulation tools

  title={Two decades of smalltalk VM development: live VM development through simulation tools},
  author={Eliot Miranda and Cl{\'e}ment B{\'e}ra and Elisa Gonzalez Boix and Daniel H. H. Ingalls},
  journal={Proceedings of the 10th ACM SIGPLAN International Workshop on Virtual Machines and Intermediate Languages},
  • E. Miranda, Clément Béra, +1 author D. Ingalls
  • Published 4 November 2018
  • Computer Science
  • Proceedings of the 10th ACM SIGPLAN International Workshop on Virtual Machines and Intermediate Languages
OpenSmalltalk-VM is a virtual machine (VM) for languages in the Smalltalk family (e.g. Squeak, Pharo) which is itself written in a subset of Smalltalk that can easily be translated to C. Development is done in Smalltalk, an activity we call “Simulation”. The production VM is derived by translating the core VM code to C. As a result, two execution models coexist: simulation, where the Smalltalk code is executed on top of a Smalltalk VM, and production, where the same code is compiled to an… 

Figures and Tables from this paper

Two decades of live coding and debugging of virtual machines through simulation
The VM simulation infrastructure is detailed and the experiences developing and debugging VM features within it such as the garbage collector and the JIT compiler are reported.
Illicium A modular transpilation toolchain from Pharo to C
The Pharo programming language runs on the OpenSmalltalkVM. This Virtual Machine (VM) is mainly written in Slang, a subset of the Smalltalk language dedicated to VM development. Slang is transpiled
Let them fail: towards VM built-in behavior that falls back to the program
It is argued that the sphere of influence of programs on VMS is extensible with regard to built-in behavior, and to let built- in behavior fail and let programs decide whether to raise exceptions, try again, or simply do nothing at all.
GraalSqueak: toward a smalltalk-based tooling platform for polyglot programming
This paper presents GraalSqueak, a Squeak/Smalltalk virtual machine implementation for the GraalVM, and evaluates the performance of the language and the programming environment, and discusses how the system can be used as a tooling platform for polyglot programming.
The evolution of Smalltalk: from Smalltalk-72 through Squeak
  • D. Ingalls
  • Computer Science
    Proc. ACM Program. Lang.
  • 2020
The forces that brought each generation of Smalltalk into existence are described, the technical innovations that characterized it, and the growth in understanding of object-orientation and personal computing that emerged.
Polyglot programming provides software developers with a broader choice in terms of software libraries and frameworks available for building applications. Previous research and engineering activities
Framework-aware debugging with stack tailoring
This paper introduces Sarto, a call-stack instrumentation layer that allows developers to tailor the stack to make debugging framework-aware, and proposes a set of six stack operations that combined hide irrelevant information, introduce missing information, and relate dispersed debugging sources to the debugger.
Cross-ISA testing of the Pharo VM: lessons learned while porting to ARMv8
This paper extended the pre-existing simulation environment with a testing infrastructure and a methodology that allow us to have fine-grained control of testing scenarios, making tests small, fast, reproducible, and cross-ISA.


How to Build a High-Performance VM for Squeak/Smalltalk in Your Spare Time: An Experience Report of Using the RPython Toolchain
The benefits and drawbacks of RSqueak/VM are discussed as a research vehicle for developing and evaluating Smalltalk language extensions without having to learn the deep secrets of VM development.
The Cog Smalltalk Virtual Machine writing a JIT in a high-level dynamic language
Cog adds a just-in-time compiler for x86 to the existing interpreter. At this stage in its evolution Cog produces a VM that runs language-intensive (rather than library intensive) benchmarks from the
PyPy's approach to virtual machine construction
The PyPy project seeks to prove both on a research and a practical level the feasibility of constructing a virtual machine (VM) for a dynamic language in a dynamic language - in this case, Python.
Sista: Saving Optimized Code in Snapshots for Fast Start-Up
Sista (Speculative Inlining SmallTalk Architecture) is proposed to persist optimized code in a platform-independent representation as part of a snapshot to reach peak performance almost immediately after start-up when using a snapshot where optimized code was persisted.
One VM to rule them all
This work describes a new approach to virtual machine (VM) construction that amortizes much of the effort in initial construction by allowing new languages to be implemented with modest additional effort, and suggests that high performance is attainable while preserving a modular and layered architecture.
A bytecode set for adaptive optimizations
A new bytecode set is implemented, which includes additional bytecodes that allow the Just-in-time compiler to generate less generic, and hence simpler and faster code sequences for frequently executed primitives.
Fast, Flexible, Polyglot Instrumentation Support for Debuggers and other Tools
Experience with Truffle Instrumentation validates the notion that addressing developer tools support as a forethought can change expectations about the availability of practical, efficient tools for high-performance languages.
Efficient implementation of the smalltalk-80 system
The most significant optimization techniques developed over the course of the Smalltalk-80 programming system are discussed, many of which are applicable to other languages.
Bootstrapping reflective systems: The case of Pharo
A definition of bootstrap for object-oriented reflective systems is proposed, the architecture and components it should contain and the challenges it has to overcome are described, and a reference bootstrap process for a reflective system is presented.
A partial read barrier for efficient support of live object-oriented programming
Spur, a new object representation and memory manager for Smalltalk-like languages, uses direct pointers but still provides a fast become operation in large heaps, thanks to forwarding objects that when read conceptually answer another object and a partial read barrier that avoids the cost of explicitly checking for forwarding objects on the vast majority of object accesses.