Home on Michael Homer

Grace

Tue, 11 Sep 2018 14:54:10 +1200

Grace is an object-oriented programming language intended for use in education. It uses gradual structural typing and a pure OO approach.

I built three implementations of Grace, and worked on the design of some language features using the language.

Minigrace is a self-hosted Grace compiler that generates C to run as native code and JavaScript to run in the browser. The design goal of Minigrace was to behave correctly on correct input

Tiled Grace

Tue, 11 Sep 2018 15:10:37 +1200

Tiled Grace is a drag-and-drop combined visual and textual editor for Grace using the Minigrace compiler as a backend. The visual editor is similar to Scratch, but the user can switch to editable textual code by pressing a button, and switch back at will later on.

Tiled Grace can be used online and its source code is available.

Fast & Easy ASTs for Flexible Embedded Interpreters

Fri, 22 Aug 2025 00:00:00 +0000

Self-hosted software language systems need to bootstrap core components such as data structure libraries, parsers, type checkers, or even compilers. Bytecode interpreters can load byte code files, while image-based systems can load in images of entire systems — Emacs, for example, does both. Bootstrapping is more of a problem, however, for traditional AST-based systems, especially when they must be portable across multiple host systems and languages.

In this short paper, we demonstrate how abstract syntax trees can quickly and easily be incorporated into the source code of an embedded interpreter. Our key insight is that a carefully engineered format enables textually identical ASTs to be valid across a wide spectrum of contemporary programming languages. This means languages can be self-hosted with very little bootstrapping infrastructure: only the host interpreter or compiler and a minimal default library, while the rest of the system is imported as ASTs.

Exploring the Design Space for Runtime Enforcement of Dynamic Capabilities

Wed, 18 Sep 2024 00:00:00 +0000

Dala is an ``as simple as possible’’ concurrent object-oriented language designed to avoid data races. Dala objects come in three safe flavours: immutable, isolated, and local, plus a fourth unsafe flavour. The objects are organised into an hierarchy so that e.g. immutable objects can be accessed from anywhere but never mutated, while thread local objects can be mutated but cannot be accessed outside their containing thread.

Dala’s flavours are intended to be enforced at runtime: unfortunately it is not clear when and how best to undertake that enforcement.

JDala - A Simple Capability System for Java

Sun, 07 Sep 2025 00:00:00 +0000

Dala is a novel capability-based programming model that ensures data-race freedom while also supporting efficient inter-thread communication. While Dala has been designed to inform the design of future programming languages, the question arises whether existing languages can be retrofitted with Dala capabilities. We report such a design called JDala. In JDala, Dala capabilities are added to Java using annotations and interpreted using bytecode instrumentation. With some examples we demonstrate that by adding three simple annotations to the language, we can avoid concurrency bugs like deadlocks and unexpected program behaviour resulting from shallow immutability of Java standard library APIs.

Syntest-ACR: Automated Crash Reproduction for JavaScript

Sun, 07 Sep 2025 00:00:00 +0000

Automated Crash Reproduction (ACR) is an area of software testing research that aims to reproduce software crashes to improve developers’ ability to debug programs. There has been little progress in applying ACR techniques to JavaScript, as the highly dynamic nature of JavaScript poses challenges for program analysis and synthesis. We present SynTest-ACR, the first tool for ACR in JavaScript, applying artificial intelligence techniques to evolve suitable reproduction cases. We have evaluated SynTest-ACR against the CrashJS dataset consisting of 453 crashes. As a baseline, we ported the state-of-the-art search-guiding fitness function from EvoCrash for Java, finding that it performs much worse when applied to JavaScript programs, and through comprehensively designing and evaluating alternative fitness functions more suitable for JS ACR we obtain an 18.9% increase in reproduction rate over this baseline for Syntest-ACR.

Reclaiming the Unexplored in Hybrid Visual Programming

Wed, 18 Sep 2024 00:00:00 +0000

Programming languages have been trapped in a world of linear textual representations fundamentally unchanged for half a century. Even systems pushing beyond these forms — visual languages, projectional language workbenches, and end-user programming tools — largely ape the strictures of stream-of-bytes compilers and confine themselves to the popular paradigms of conventional textual systems. Instead of recreating what succeeded in textual paradigms, new programming systems should also be exploring what did not—the confounding, confusing, convoluted approaches that fell by the wayside—with the sorts of direct manipulation, spatial connection, and change over time that textual languages could never match; and they should use their control of presentation to let the user choose the right representation for a piece of code in the moment—and change it. We argue that these two points unlock new frontiers for programming systems, and present preliminary explorations to highlight how multiple-representation environments can lower the pressure on more speculative visual paradigms, to encourage more investigation of this underexamined space.

Dafny vs. Dala: Experience with Mechanising Language Design

Thu, 01 Aug 2024 00:00:00 +0000

Dala is a design for a concurrent dynamic object-oriented language. A key goal of Dala’s design is to avoid data races, by ensuring threads do not share mutable state. In this paper we discuss our experience using the program verification tool Dafny to validate Dala’s design. We explain how we modelled salient features of Dala in Dafny, and how Dafny did (or did not) assist our confidence in Dala’s design.

Designing Collaborative ScratchJr for Multi-touch Tabletops

Wed, 19 Jun 2024 00:00:00 +0000

Teaching fundamental aspects of computer science at pre-university levels has been a relevant topic for several years. Visual programming environments based on block-based languages, such as Scratch, have gained prominence due to their ability to simplify entry into the complex field of programming. This work focuses on ScratchJr, a user-friendly environment specifically designed for early childhood and primary education.

Collaborative learning is one of the most effective and widely used methodologies in classrooms. With this in mind, our research centers on designing a collaborative interface that enables group work among multiple students within a shared workspace. This workspace will be deployed on a multitouch table, leveraging the advantages provided by such devices. These advantages include enhanced collaboration and the need for hands-on experiences for young learners.

CrashJS: A NodeJS Benchmark for Automated Crash Reproduction

Thu, 15 Feb 2024 00:00:00 +0000

Software bugs often lead to software crashes, which cost US companies upwards of $2.08 trillion annually. Automated Crash Reproduction (ACR) aims to generate unit tests that successfully reproduce a crash. The goal of ACR is to aid developers with debugging, providing them with another tool to locate where a bug is in a program. The main approach ACR currently takes is to replicate a stack trace from an error thrown within a program. Currently, ACR has been developed for C, Java, and Python, but there are no tools targeting JavaScript programs. To aid the development of JavaScript ACR tools, we propose CrashJS: a benchmark dataset of 453 Node.js crashes from several sources. CrashJS includes a mix of real-world and synthesised tests, multiple projects, and different levels of complexity for both crashes and target programs.

In-line Compositional Visual Programming

Mon, 11 Mar 2024 00:00:00 +0000

Concatenative programming inherently expresses composition of sub-tasks of a pipeline, but one uncommonly seen model of this paradigm includes all data values inline within the program. A visual environment for editing and evaluating programs in this model would inherently display state in place, and allow for easy tracing of data flow through the program by watching the values literally move as evaluation steps took place. We propose a visual approach for programming in this style, with function calls and data values interleaved on a single “track”, with specific concrete arguments always adjacent when a function term is evaluated and various affordances for editing, evaluating, and debugging. We then show how extensions to this model to multiple tracks can ease programming in the model and even make available some more inscrutable programming-language features, such as concurrency and effect systems, in a more accessible way.

Branching Compositional Data Transformations in jq, Visually

Sat, 30 Sep 2023 00:00:00 +0000

jq is a widely-used command-line tool for filtering and transforming JSON data, in the vein of sed and awk, including a bespoke programming language for writing the filters. The paradigm of that language is unusual: while its appearance is somewhere between a shell pipeline and JavaScript, the language is pure-functional and essentially concatenative, the pipelines branch and interleave data invisibly, implicit output flattening obscures all these effects, and most users are unaware of any of its semantics, leading to confusion when encountering any of these latent elements and difficulty in constructing appropriate non-trivial filters, all the while common debugging techniques are also obstructed by the paradigm. These confusions can be eliminated by visually demonstrating the recursively forking nature of evaluation on actual data, and allowing manipulations of the program or data to be reflected live, but no such tool exists for jq or any similar approaches. We present a visualisation of jq’s execution model that makes the branching nature manifest, illustrating its effects on concrete values provided by the user, and editing affordances that allow manipulating the program with reference to real data.

Multiple-Representation Visual Compositional Dataflow Programming

Mon, 13 Mar 2023 00:00:00 +0000

Many tasks that end users want to accomplish with a computer program are fundamentally data-flow transformations, and both visual and textual programming systems have been created to fill this need, but these are often inflexible, unapproachable, or cumbersome, satisfying a niche at one stage of the process but limited at others. An approach that suits one part of the program, or one time in its development, may be confounding at another, but the user is stuck with both the constructive and obstructive aspects of a tool’s chosen paradigm throughout. Much of this difficulty can be removed by enabling the cohabitation of multiple editing paradigms in a single program for the user to choose how to tackle the current point in the process - and change their mind. We present a new data-flow programming environment where the same program, or parts of the same program, can be viewed and edited as linear text, a node-and-wire graph representation, or a two-dimensional grid layout, and the correspondence between these representations is made clear through a continuous visual identity for each part of the program.

Interleaved 2D Notation for Concatenative Programming