Refinement types are a powerful formalism with many applications in program verification, compiler optimization, etc.
We present our work-in-progress on MachineArithmetic, an implementation of refinement types in Smalltalk. Our current results are empirical, successfully running tests in the LiquidHaskell benchmark suite.

Live proof-by-induction

Powerlang bootstrapper was designed to bring alive Smalltalk systems from specifications stored in source code files.
Powerlang includes an evaluator that is able to execute initialization code of the Smalltalk being bootstrapped. Could we use that same evaluator for running that same Smalltalk on the Web?
We present our work in progress towards that goal, which involves transpiling the Smalltalk evaluator, written in Smalltalk, to JavaScript, generating a Smalltalk image compatible with that evaluator, and optimizing the evaluator and the Smalltalk code of the image.


PowerlangJS: A Quick Way to Get Your Smalltalk to the Web?

Any modern development environment needs to provide good support for Unicode text. Cuis Smalltalk presents a specific set of requirements, and offers a unique set of resources for implementing it. Additionally, Unicode has been around for long enough to allow for a critical view on existing implementations. This paper describes the motivations, choices and implementation strategies of the support for Unicode recently added to Cuis.

Unicode support in Cuis Smalltalk

We describe the design and implementation of a computer algebra system in Smalltalk-80. Here we focus on the categories of rings and modules. We discuss various types of rings and show how to solve linear systems over them, which allows us to construct their categories of finitely presented modules and other interesting objects. We illustrate different parts of the system with concrete examples of use.

Arrows: a Computer Algebra System in Smalltalk

Even though changing it is fairly easy, the Smalltalk syntax has remained essentially stable for many decades. The reason is that people are cautious about side effects that could mess up something provably good. This doesn't mean that there aren't variations one might propose, but that the real task is to identify a coherent, non-distorting, set of extensions that increase the expressiveness of the language in favor of new possibilities related to areas such as interoperability, formal reasoning and mathematics.

On Possible Extensions to the Smalltalk Syntax

Meta-compilation schemes help to automatically build Just-in-Time (JIT) compilers from interpreters by performing a meta-interpretation of the VM interpreter.
Generated JIT compilers face the well-known problem of phase ordering: selecting a good optimisation sequence to apply to the compiled programs.
Manual optimisation lists are hard to maintain and are *one-size-fits-all* solutions that assume that a single sequence is equally effective in all possible programs. 
Generating such a list automatically is still challenging nowadays.

In this paper, we explore the phase-ordering problem in the case of the meta-compilation of Pharo VM interpreter primitives.
We present three automatic strategies to find good-enough optimisation sequences: a search-based approach, a predictive approach based on code shape, and an automatically-found fixed list approach.
We compare them by measuring the relative compiled code size and their rate of convergence.
We evaluate this work over 17 of Pharo's language interpreter primitives.
On average, the Predictive strategy arrives at its optimal result before the rest with 21% fewer optimisations, the search strategy finds better results in complex cases.
The automatic approaches seem promising for primitive meta-interpretation. 

Ordering Optimisations in Meta-Compilation of Primitive Methods

Producing robust memory manager implementations is a challenging task. Defects in garbage collection algorithms produce subtle effects that are revealed later in program execution as memory corruptions. This problem is exacerbated by the fact that garbage collection algorithms deal with low-level aspects to be efficient. Finding, reproducing, and debugging such bugs is complex and time-consuming.
In this article, we propose to fuzz heaps by generating large sequences of random heap events. Randomly generated events exercise the garbage collection algorithm with the objective of generating VM crashes and finding bugs. Once a bug is found, we use a test case reduction algorithm that finds the smaller subset of events that reproduces the issue.
We implemented our approach on top of the VM simulator of the Pharo VM. We used it to test the ephemeron finalization mechanism in Pharo’s sequential stop-the-world generational scavenger. Our prototype found two bugs in Pharo’s ephemeron implementation. We show how such test cases were automatically reduced to trivial sequences that were easy to debug.

Testing Finalization Mechanisms with Heap Fuzzing

This paper describes a “software archaeology” project in which a new interpreter was created for the Score11 music representation, a popular 1980s music input language that was frequently used with the Music11 non-real-time software sound synthesis package. The new version runs within the Smalltalk-based Siren system, a library of software classes for music representation, algorithmic composition and live interactive performance. The project background is given, and the port of Score11 to the Siren environment is described and evaluated.

FAST 2022 Workshop Submissions