Recent content in Home on Michael Homer
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…
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…
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,…
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…
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…
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…
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…
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…
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…
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…
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,…
Concatenative languages use implicit argument passing to provide a concise expression of programs comprising many composed transformation functions. However, they are sometimes regarded as “write-only” languages because understanding code requires mentally simulating the manipulations of the argument stack to identify where values are produced and consumed. All of this difficulty can…
Data engineering pipelines process large amounts of information, and ensuring that the quality and integrity of the data is maintained throughout is critical for technical, business, and social reasons. Conventional data quality assurance approaches require a large amount of fine-grained testing code, which is laborious, easy to get out of sync, and inscrutable to non-technical stakeholders. An…
Blocks-based programming is a common way to teach novices how to program. However, there are many block-based languages to choose from. This paper reviews Block-Based Programming Languages (BBPLs), takes a detailed look at a number of existing BBPLs including their features and comparing and contrasting these languages. Finally, through a number of research questions, this paper evaluates the…
This system started out as an experiment in making an obtuse programming paradigm more approachable. Sometimes regarded as “write-only languages”, stack-based concatenative languages rely on implicit argument passing and return values, with programs often just a bare sequence of function names, but they provide a very concise expression of pipelines. 
 A two-dimensional layout…
Programming on touch-screen devices is notoriously difficult,
with conventional programming affordances typically
unavailable or unhelpful.
Here we present a novel touch-screen programming environment
for a style of functional programming that more closely
matches typical touch-screen needs, where all editing
operations are driven by concrete data values and selected
by…
Functional Reactive Programming (FRP) is a powerful abstraction for building deterministic concurrent systems. However, some programmers prefer a more imperative approach for certain tasks, and that approach is required to implement some imperative algorithms. The Actor Model provides an abstraction for building concurrent systems in a more imperative way without as much of the chaos typical of…
Creating a program that performs even a simple task and shows
the result is unapproachable to most people, and even trained
programmers face a burden to create a new program. In this paper, we
introduce a prototype system and model for live visual dataflow
programming where intermediate steps are visible and all
components are tangible and manifest. Our system aims to allow a…
Dynamic languages like Erlang, Clojure, JavaScript, and E
adopted data-race freedom by design. To enforce data-race
freedom, these languages either deep copy objects during actor
(thread) communication or proxy back to their owning thread. We
present Dala, a simple programming model that ensures data-race
freedom while supporting efficient inter-thread communication.
Dala…
This paper is a partial reproduction of work by Soltani et al. which presented EvoCrash, a tool for replicating software failures in Java by reproducing stack traces.
EvoCrash uses a guided genetic algorithm to generate JUnit test cases capable of reproducing failures more reliably than existing coverage-based solutions.
In this paper, we present the findings of our reproduction of the…
Transient gradual type systems often depend on type-based cast insertion to
achieve good performance: casts are inserted whenever the static
checker detects that a dynamically-typed value may flow into a
statically-typed context.
Transient gradually typed programs are then often executed using
just-in-time compilation, and contemporary just-in-time compilers are
very good…
Hybrid and visual programming interfaces 
 I created Tiled Grace , the first dual-mode
block-based/textual hybrid programming system, and continue to explore further
interfaces for programming beyond the conventional lines-of-text editor. I
have a particular focus on multiple-representation programming systems,
and approaches to support non-programmers and novices.
My work…
Cellular automata are simulations of cells interacting with each other
based on simple rules. Despite the simplicity, they can exhibit complex
behaviour, and have a number of applications in fields such as medicine,
biology, mathematics, and more. As a result, people from a variety of
different backgrounds and skill-sets may find cellular automata useful
to their work or…
domejs is a minimal proxying shortcut DOM library. It provides a single function, called $ or dome , that wraps up the repetitive parts of writing DOM code while still looking essentially like standard DOM API usage. 
 The $ function has two uses: creating new elements ( new $('li.important') ), and retrieving existing elements to manipulate together ( $('input[type=text].search').value = ''…
Package management is instrumental for programming languages and
operating systems, and yet it is neglected by both areas as an
implementation detail. For this reason, it lacks the same kind of
conceptual organization: we lack terminology to classify them or to
reason about their design trade-offs. In this paper, we share our
experience in both OS and language-specific package…
One form of type checking used in gradually typed language is
 transient type checking : whenever an object “flows” through code
with a type annotation, the object is dynamically checked to ensure
it has the methods required by the annotation. Just-in-time
compilation and optimisation in virtual machines can eliminate much
of the overhead of run-time transient type…
Since LISP, dynamic languages have supported dynamically-checked type
annotations. Even in dynamic languages, these annotations are typically
static: tests are restricted to checking low-level features of objects and
values, such as primitive types or membership of an explicit
programmer-defined class. 
 We propose much more dynamic types for dynamic languages —…
With the increasing need to teach programming to novices using
collaborative methods like pair programming, it is important to
understand how different input devices can help support collaborative
learning. In this paper we present Multi-Device Grace, the first
application to explore block-based programming in a cross-device
environment consisting of digital tabletops, mobile…
Transient gradual typing imposes run-time type tests that typically
cause a linear slowdown. This performance impact discourages the use of
type annotations because adding types to a program makes the program
slower. A virtual machine can employ standard just-in-time optimizations
to reduce the overhead of transient checks to near zero. These
optimizations can give…
GoboLinux is a Linux distribution with an alternative filesystem hierarchy, where “the filesystem is the package manager”. My work with GoboLinux has primarily been in package management, including the design of its use-flags system, the Freshen automatic-update tool, and various work on the Scripts and Compile tools along with recipe maintenance and web tooling.
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 .
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…
Kihi is a concatenative, compositional, functional programming language with a minimal core of only six operations. 
 Kihi can be tried online and
 in PLT Redex . Both include a variety of sample
programs and the ability to visualise the execution stepwise. 
 Every function in Kihi takes zero or more inputs and produces zero or more
outputs, and functions automatically compose…
Function composition is a very natural operation, but most
language paradigms provide poor support for it. Without linguistic
support programmers must work around or manually implement what
would be simple compositions. The Kihi language uses only
composition, makes all state visible, and reduces to just six core
operations. Kihi programs are easily stepped by textual…
The Information and Communications Technology (ICT) industry in New Zealand is growing rapidly. The traditional university courses are preparing an insufficient number of graduates to sustain the growth. Many of the traditional graduate students lack key soft skills that are important in team based software development. This paper reports on the development of a conversion Master of Software…
Programme and Artifact Evaluation Committees I have been or am a member of: 
 
 Onward! Papers 2026 
 Review committee of The Art, Science, and Engineering of Programming for 2026 
 LIVE 2026 
 PLOS 2026 
 LIVE 2025 
 MPLR 2024 
 Onward! Papers 2024 
 Onward! Essays 2024 
 PX 2024 
 PAINT 2023 
 PLOS 2023 
 PX 2023 
 MPLR 2022 
 PLOS 2021…
Journals I have undertaken reviews for in this PBRF cycle: 
 
 Journal of Computer Languages (2025) 
 SoftwareX (2022) 
 Journal of Computer Languages (2022) 
 Journal of Computer Languages (2019) 
 
 Grant and other reviews 
 
 Invited referee for Netherlands Resarch Office (NWO) Vidi programme grant (2022) 




 My Honours report was completed in 2010, titled Lively JavaScript , and
supervised by James Noble. 
 Abstract 
 
 In this project we evaluate the use of JavaScript as a general-purpose
programming language, using the Lively framework. We implemented several
applications within the Lively system to seek insights into both the language
and the programming…
Slide deck 
 All of the various tools, links, and data mentioned in the talk are below. 
 A video of the talk is available on YouTube . A WebM-format video is available from your local Linux Australia mirror: AU / NZ 
 Minigrace 
 
 Source code (in Grace) 
 
 To bootstrap this code, run tools/tarball-bootstrap -a to download, build, and install one of the tarballs from…
Block-based programming environments are typically designed for desktop machines or mobile devices. Desktops and mobiles are generally designed for single users to interact with, which makes it hard for multiple users to collaborate effectively. In this paper we explore the possibilities of digital multi-touch tabletops to foster collaborative programming in a block-based paradigm. We note both…
IEEE 802.11 wireless backhaul networks (WBNs) have emerged as a practical solution for bridging access points and backbone networks with low cost and ease of installation. However, the IEEE 802.11 protocol operates in the unlicensed spectrum and experiences unregulated interference, making it difficult to guarantee quality of service (QoS). With newer and farther reaching applications being…
Wireless mesh networks (WMNs) have many attractive characteristics, such
as auto-configuration, self-management, and self-healing. With newer and
farther reaching applications being developed in built environments, such as
smart grids and intelligent transportation systems, users expect high quality
of service and thus fairness is an important issue to be addressed.…
Tiled Grace is a block-based programming system backed
by a conventional textual language that allows switching back and
forth between block-based and textual editing of the same code at
any time. We discuss the design choices of Tiled Grace in light of
existing research and a user experiment conducted with it. We also
examine the sorts of task preferred in each mode by users…
We adapt SOMns, a Truffle-based interpreter for Newspeak,
to the Grace programming language. We highlight differences
between the semantics of these languages and offer
preliminary results showing that adaption is possible while
retaining performance. The similarities between the languages
promote the potential for adaption and code sharing
between implementations. Through…
This article is an apologia for the design of inheritance in the Grace
educational programming language: it explains how the design of Grace’s
inheritance draws from inheritance mechanisms in predecessor languages, and
defends that design as the best of the available alternatives. For simplicity,
Grace objects are generated from object constructors, like those of Emerald,
Lua,…
When is one object equal to another object? While object
 identity is fundamental to object-oriented systems, object
 equality , although tightly intertwined with identity, is harder
to pin down. The distinction between identity and equality
is reflected in object-oriented languages, almost all of which
provide two variants of “equality”, while some provide many
more.…
Which comes first: the object or the class? Language designers enjoy the conceptual simplicity of object-based languages (such as Emerald or Self) while many programmers prefer the pragmatic utility of classical inheritance (such as Simula and Java). Programmers in object-based languages have a tendency to build libraries to support traditional inheritance, and language implementations are often…
The gradual guarantee lets us understand gradual typing: a system
is gradually typed if removing a type annotation cannot change the
semantics of a correct program. We extend the gradual guarantee
beyond types: privacy annotations or inheritance restrictions, for
example, may be gradual if changing them does not change the
semantics of a correct program.
The aspiration of gradual typing — that typed and untyped code can coexist
happily, with errors reported at runtime when the types are found to be wrong —
has led many languages, including our own, to adopt the paradigm. The practice
is different; even the term itself has been refined short of this aspiration,
and languages abdicate their responsibilities as soon as they become…
Method names with multiple separate parts are a feature of many
dynamic languages derived from Smalltalk. Generalising the syntax
of method names to allow parts to be repeated, optional, or
alternatives, means a single definition can respond to a whole family
of method requests. We show how generalising method names can support
flexible APIs for domain-specific
languages,…