Onward! 2026 – Preliminary Table of Contents

Escaping the DAG Dogma: Toward Modular Reactive Architectures
Rivka Altshuler and David H. Lorenz
(Open University of Israel, Israel)
Functional Reactive Programming (FRP) provides an architectural abstraction for expressing data dependencies: developers declare relationships among data, while the underlying system propagates changes. A prevailing dogma within FRP holds that these relationships must form a Directed Acyclic Graph (DAG) to ensure deterministic execution. This restriction creates a tension between the software architect, who must preserve global consistency, and the software developer, who adds dependencies locally and may thereby introduce a cycle globally. Consequently, existing languages either prohibit cycles by constraining developers to DAGs or permit cycles but require manual state management or centralized coordination, sacrificing either the managed change propagation promised by FRP or the modular encapsulation promised by Object-Oriented Programming (OOP).
This work challenges the premise that cycles are inherently incompatible with deterministic reactive execution. We present a semantic model that reconciles deterministic reactive execution with modular software evolution through constructive assignment: each assignment adds a value stream to a variable rather than replacing its existing definition. The variable's value is obtained by merging converging data streams, allowing feedback cycles to denote valid reactive definitions. We realize the model through a decentralized change-propagation algorithm and implement it in rivarjs, a library built on RxJS. A case study using a clinical drug-administration prototype illustrates that both DAG-preserving and DAG-breaking extensions can be accommodated without modifying existing domain logic, suggesting that escaping the DAG dogma can reconcile the architect's demand for global consistency with the developer's need for modular freedom.

Article Search Article: onward26papers-p2-p (type: Full Paper) doi:10.1145/3840586.3843206

Glassbox Debugging: Code as Interface for No-Code
Niv Benaloul and David H. Lorenz
(Open University of Israel, Israel; Technion, Israel)
No-code platforms and source-level debugging are fundamentally at odds over the role of code in software development. This tension arises because no-code platforms abstract away from code to prioritize simplicity and ease of use, while source-level debugging depends on visibility into the code that actually executes. Even when no-code platforms do generate code explicitly, they often conceal it from developers, treating it as a blackbox. This creates a debugging barrier: users can observe behavior in the visual interface, but cannot trace that behavior to the code that produced it.
To overcome this barrier, this paper introduces a glassbox approach to no-code debugging. In this approach, the generated code behind visual components is exposed as a read-only, synchronized debugging view. The visual program remains the source-of-truth, while the generated code becomes an explanatory interface for inspecting behavior and synchronizing control. The approach further supports cross-target and cross-session debugging, making generated artifacts, runtime behavior, breakpoints, logs, and execution snapshots comparable across target languages and debugging sessions.
By adding source-level inspection and synchronized control without requiring users to edit generated code, glassbox debugging may extend no-code platforms toward fuller development environments, while preserving their accessibility for citizen developers and transitional users. We instantiate this approach in Glancer, a prototype glassbox debugger for Blockly. Because Blockly can generate multiple target languages from the same visual program, Glancer provides a concrete setting for exposing behavioral divergences that single-target blackbox debuggers may hide.

Article Search Article: onward26papers-p4-p (type: Full Paper) doi:10.1145/3840586.3843207

Normalization by Origin, Not by Shape
Marco Servetto and Colin S. Gordon
(Victoria University of Wellington, New Zealand; Drexel University, USA)
Memoization is about avoiding recomputation, by caching results and retrieving them when previously-seen inputs are provided again in the future. In the literature, many different ways have been proposed to efficiently (and correctly) check if such input has indeed already been seen.
Prior work largely focuses on structural equality of the keys. In many commonly-used approaches, like Python’s @cache avoiding (or accepting) observable semantic changes is the responsibility of the programmer.
Here we propose a new approach, where cache keys are considered equal if they are created in the same way. We implement our approach on top of Fearless, a language with reference and object capabilities allowing to control side effects and enforcing determinism of localized code expressions. Our technique guarantees language-enforced unobservable caching: removing the caching annotations does not change the observable program semantic.

Article Search Article: onward26papers-p5-p (type: Full Paper) doi:10.1145/3840586.3843208

Croquetify: Transforming Single-User Functional Reactive Programs into Multi-user Applications
Yoshiki Ohshima, Aran Lunzer, and David A. Smith
(Shizuoka University, USA; Independent Software Engineer, USA; axona.net, USA)
Building robust real-time collaborative applications --- "multi-user apps" --- is hard. State transitions that are trivial in the single-user case become surprisingly complex once concurrent participants are involved, often requiring custom interaction protocols and tailor-made speculative execution and reconciliation mechanisms. Errors are harder to reproduce, and the application must still respond within milliseconds. AI coding agents do not yet handle these demands reliably.
In this paper, we present a novel way to develop multi-user apps. We employ a combination of a Functional Reactive Programming language called Renkon, which is a general-purpose language for application development with rich meta-programming features, and a network application framework called Croquet. We devised a program transformation that allows the same Renkon program to run as a single-user app or to use Croquet to run as a multi-user app without writing application-specific server-side code. This is done without losing Renkon's live programming capability.
To demonstrate how well this approach works for a practical application, we applied it to a real-time interactive programming environment called Renkon-pad. We show that not only can we transform a single-user programming environment into a multi-user one, but also that the multi-user environment can be used to develop a multi-user app in a live programming manner. This experiment supports the idea that the transformation is applicable to general and complex programs, with the programmers' intent in the original program preserved.

Article Search Article: onward26papers-p7-p (type: Full Paper) doi:10.1145/3840586.3843209

Assignment Has Never Existed: Programs Have Always Been Difference Equations
Aamod Sane
(FLAME University, India)
The assignment statement x = x + 1 is a difference equation with its time index removed. Program verification research has shown that restoring the index simplifies reasoning, but only specification languages have incorporated this idea.
We present , a programming language that uses difference equations with a time index, x’ = x + 1, instead of assignments. This has four benefits: source order is not significant for equations, which simplifies reasoning; imperative style thinking and efficient mutation are retained, while reasoning remains simple; loop transition relations may be read off the body with frame conditions supplied by the notation, reducing proof bookkeeping; and the same notation supports reasoning from introductory trace tables to two-state relational Hoare proofs.
Further, applies difference equations to arbitrary data types: arrays, sets, dictionaries, and pointer structures, making it a general-purpose language rather than a numerical-methods formalism.
Examples spanning sorting, graph algorithms, and low-level pointer manipulation show where can make updates order-independent to simplify reasoning, and where sequencing or convergence arguments remain necessary.

Article Search Article: onward26papers-p11-p (type: Full Paper) doi:10.1145/3840586.3843210

Relational Agenda Programming: A Uniform Execution Model for Embedded Reasoning Systems
Andrew Chen
(Minnesota State University Moorhead, USA)
Most programming systems draw a hard boundary between the reasoning layer and the control layer, requiring a validation step at every interface and forcing programmers to maintain two models of their system simultaneously. We present Relational Agenda Programming (RAP), a uniform execution model in which reasoning, control flow, and I/O all flow through the same relational machinery with no privileged escape hatches. The key architectural choice is a virtual machine that executes goals via an explicit work queue, coupled with a pending-query agenda that is itself a first-class relational term. Queries receive the current agenda as input, reason over it using unification – the same machinery used for domain reasoning – and return a ChangeSet specifying atomic agenda modifications. ChangeSets are valid by construction: the no-ops and cons-ops constructors are relations that fail on invalid operations, so invalid ChangeSets cannot be expressed. We present a C++20 implementation with zero dependencies, embeddable via FFI from any language that supports C++ linkage. We validate the model through two small case studies and one larger, detailed example: embedded security policy verification demonstrating the Probe meta-evaluation primitive, reflective agenda reasoning demonstrating a query that inspects and modifies pending work through the same relational machinery used for domain reasoning, and a sustained adversarial reasoning task in which a hostile actor mutates shared state while the system maintains and repairs its relational belief state through continued reasoning over many rounds.

Article Search Article: onward26papers-p14-p (type: Full Paper) doi:10.1145/3840586.3843211

The Developer as Curator: A Canvas for Coding Agent Context
Lukas Böhme, Tom Beckmann, Michael Perscheid, and Robert Hirschfeld
(Hasso Plattner Institute - University of Potsdam, Germany; Kyoto University of Advanced Science, Japan; SAP SE, Potsdam, Germany)
The quality of AI-generated code depends on the context that coding agents automatically receive as input. Today's coding agents do not expose that context to the developer. When retrieval fails, the developer cannot distinguish whether a wrong output stems from flawed reasoning or from incorrect or missing input. We describe how coding agents retrieve context internally and derive three failure modes: wrong context, missing context and stale context. Existing mechanisms for managing context (compaction, session reset, and sub-agent delegation) are automated responses to token limits that give developers no way to correct these failures. We present Monet, a canvas-based development tool that positions the developer as curator of the context the agent receives. Monet is guided by two design goals: context observability, letting developers see every piece of gathered context and its current state, and context curation, letting developers add, remove, and refresh context through direct manipulation. On Monet's canvas, each piece of context is a node that developers can remove, add, or refresh to correct the agent's input before re-prompting. Case studies show that each mechanism catches retrieval errors that autonomous agents cannot self-correct. Monet opens a new design space for human-AI collaboration in agent-assisted programming, shifting the developer's role from prompt author to context curator.

Article Search Article: onward26papers-p18-p (type: Full Paper) doi:10.1145/3840586.3843212

The Choose-Your-Own-Adventure Calculus
Tomas Petricek, Jan Liam Verter, and Mikolas Fromm
(Charles University, Czech Republic; Imperial College London, UK)
In many programming systems, the user can interactively construct a program by repeatedly triggering a completion mechanism and choosing one of the offered options. This is the case with code editors for object-oriented languages (choosing a member), data exploration environments (choosing a transformation), but also with theorem provers (choosing a tactic) and structure editors (choosing a grammar~rule).
We capture the essence of this interaction pattern through a small formal model called the choose-your-own-adventure calculus. The model serves three roles. First, it reveals subtle differences between instances of the interaction pattern. Second, it enables transfer of interaction techniques across different domains by describing them abstractly in terms of the calculus. Examples include mixed-initiative interaction, AI assistants and programming by demonstration. Third, it lets us characterise desirable properties of a programming system, including correctness, completeness and uniqueness.
More generally, the paper shows that programming language theory can be used to study not just languages, but also rich interactive programming systems. We argue that such systems deserve at least as much attention as languages.

Article Search Article: onward26papers-p20-p (type: Full Paper) doi:10.1145/3840586.3843213

Proxies All the Way Down: Bootstrapping a Userland Speculative Optimizer for the OpenSmalltalk VM
Christoph Thiede, Marius Dörbandt, Eliot Miranda, Marcel Taeumel, and Robert Hirschfeld
(Hasso Plattner Institute - University of Potsdam, Germany)
Self-supporting dynamic-language systems aim to lift core components otherwise implemented in the virtual machine up into userland to enable the expression and development of those core components at the same level and with the same tools as applications. Yet, bootstrapping components that are critical for userland stability poses a chicken-and-egg problem: bugs in such core components can destroy the running system. The OpenSmalltalk VM is implemented in Smalltalk as a nested simulation, and transpiled to C. The new speculative optimizer Scorch increases performance and is architected as a userland component to ease development.
However, debugging Scorch into existence has proven impractical as faulty optimizations crash the system and make iterative development very challenging. We present OOPsie: an approach that allows components such as Scorch to live in userland during both development and production without alteration. It is a meta-architecture that decouples development from execution, meaning that only a simulation might be damaged. We employ proxies for critical paths, replacing inter-userland interfaces with proxy-based host-to-simulation interfaces. Using OOPsie, we revived the development of Scorch, identifying and fixing multiple defects, and extended the OpenSmalltalk simulator with improved debugging capabilities by reusing existing userland tools across system boundaries. Our experience demonstrates that the OOPsie architecture is effective in bootstrapping userland system capabilities by isolating bug effects to the simulation, supporting uninterrupted live-programming workflows even before a new component can sustain itself.

Article Search Article: onward26papers-p21-p (type: Full Paper) doi:10.1145/3840586.3843214

Essays

Programs Should Be Comics, Their Execution — Animation
Maciej Bronisław Godek
(Gdynia Maritime University, Poland)
The year is 2026. A growing number of software developers delegate their thinking to machines controlled by big corporations, which secretly pursue their own hidden agendas. Worst of all, the developers have less and less of an idea how the systems that they develop work.
How can we bring back fun and engagement to the software development process?
Embark on a fascinating journey through over 150 colorful panels of this avant-garde visual essay to find out!

Article Search Article: onward26essays-p6-p (type: Full Paper) doi:10.1145/3840586.3843743

Agents as Software: A Programming Languages Agenda for Agent Reliability
Shraddha Barke and Adithya Murali
(Microsoft Research, Redmond, USA; University of Wisconsin-Madison, USA)
AI agents increasingly resemble software systems: they call tools, remember facts, follow policies, delegate work, and take actions with real consequences. Yet the "program" of an agent is scattered across prompts, tools, memories, workflows, and execution traces, making its behavior difficult to inspect through ordinary testing and debugging alone. This essay argues that a programming-systems perspective offers a natural lens for making agents reliable. We recast agents as programmable artifacts whose behavior can be specified over traces and state, checked before deployment, monitored during execution, and improved from observed failures. The goal is not to make probabilistic agents behave like deterministic programs, but to give them enough structure that their behavior can be reasoned about, controlled, and repaired.

Article Search Article: onward26essays-p17-p (type: Full Paper) doi:10.1145/3840586.3843744

The Spreadsheet Was the Constitution: On Constitutional Materials in the Software Age
Abutalib Namazov
(Massachusetts Institute of Technology, USA)
A resident-run purchasing cooperative I helped run kept its weekly orders in a shared spreadsheet. We discovered, in the middle of a bad argument, that the spreadsheet had also been our constitution.
Software picks up constitutional weight long before the by-laws catch up. It is where the rules live, and the first place anyone looks when a decision has to be defended. But a spreadsheet was not built to carry that weight. Older governing documents had to earn properties we now take for granted: legibility, versioning, the ability to tell a draft from the real thing and to reconstruct ten years on what had been decided and why.
Wikipedia stumbled into one version of the problem; the DAO crashed into another. Smaller institutions live a quieter version of it every week, and mostly do not notice until something goes wrong. What is missing is answerability: the sense that some edits are acts the institution may one day have to account for.

Article Search Article: onward26essays-p32-p (type: Full Paper) doi:10.1145/3840586.3843745

The Conversation We’re Not Having about AI in Peer Review
Emerson Murphy-Hill and Christian Bird
(Microsoft, USA)
Whether we like it or not, AI is already part of peer review. Our community has barely begun to discuss how reviewers use it or what norms should govern that use. We have independently developed AI-assisted reviewing workflows and discovered that our practices converged on similar boundaries. In this essay, we describe those workflows in detail, report what changed as a result of using AI, and reflect on what the experience revealed about our own longstanding reviewing habits. We close with an initial set of guidelines as a starting point for the community to develop explicit, shared norms for AI use in reviewing.

Article Search Article: onward26essays-p33-p (type: Full Paper) doi:10.1145/3840586.3843746

(This Is Not a Paper about) Mutation Driven Development
Alex Groce
(Northern Arizona University, USA)
Test driven development (TDD) is a controversial and interesting approach to software development; while many think of “better tests” as a primary purpose of TDD, in practice the goal is as much to use tests to encourage continued progress in coding. That goal however rests on the notion that TDD ensures tests are good enough to let you implement small new features and refactor code without undue fear of mistakes. Unfortunately, TDD is not “self-enforcing” and standard TDD practice makes it easy to accidentally skip steps. By integrating a phase of focused mutation testing into TDD, however, developers applying TDD can be sure they are actually writing code that is supported by the scaffolding of tests, and so code in justified confidence. The incremental nature of TDD test and production code creation ensures that at no point will “fixing up” the mutants be likely to overwhelm the developer, and so the final result will be tests with excellent code coverage and mutation score, without a painful effort to “patch up” an inadequate testing effort, and a TDD approach that includes automated checks that the letter and spirit of TDD are truly being respected, with the benefits of TDD presumably following in due course.
This essay uses the idea of MDD (Mutation Driven Development) as a point of departure from which to explore weaknesses in the motivation, dissemination, and evaluation of software engineering research, as a result of well-intentioned quality gatekeeping (and less laudable barriers between “lanes” of software engineering research styles).

Article Search Article: onward26essays-p38-p (type: Full Paper) doi:10.1145/3840586.3843747

Towards Critical Abstraction for Software
Alice Mira Chung, Devamardeep Hayatpur, Philip J. Guo, and Tomas Petricek
(University of California at San Diego, USA; Charles University, Czech Republic)
Abstraction in computer science is typically understood as the process of generalization that removes non-essential details and captures key shared characteristics across multiple instances. This is a limited view of abstraction when contrasted with fields like art, architecture, media theory, or philosophy, where abstraction has been repeatedly re-examined and re-imagined, providing space for self-reflection and critical discourse. To show that abstraction can play a similarly critical role in computer science, we examine three pairs of related software artifacts where one part of each pair uses abstraction in a conventional way, while the other invites critical reflection. We demonstrate how different modes of abstraction express critical ideas about computing, in the form of software artifacts. Taken together, we argue that pluralistic approaches to abstraction can make computing a more self-reflective field aware of the methodological and sociopolitical issues it faces.

Article Search Article: onward26essays-p74-p (type: Full Paper) doi:10.1145/3840586.3843748

Objects and Classes Will Do: The Power of Uniformity and Generality
Ole Lehrmann Madsen and Birger Møller-Pedersen
(Aarhus University, Denmark; University of Oslo, Norway)
Objects and classes were introduced by SIMULA some sixty years ago. Since then, many new language mechanisms have been devised including static members, namespaces, modules, companion objects, interfaces, mixins, traits, protocols, constructors, factories, iterators, etc. The implications are that many languages have become complex entities with many rules, special cases, and exceptions to the rules, often due to lack of uniformity and generality.
In this paper, we show that objects and classes as originating from SIMULA and generalized in Beta may subsume the above-mentioned language mechanisms. This is possible since these object- and class-mechanisms are sufficiently general and uniform. It includes deep nesting with no restrictions, as well as support for singular objects.

Article Search Article: onward26essays-p94-p (type: Full Paper) doi:10.1145/3840586.3843749

Onward! 2026 – Preliminary Table of Contents

Frontmatter

Papers

Essays