Deterministic Core, Non-Deterministic Shell - Outdata

The Myth of Deterministic Software

How I've come to terms with LLM non-determinism in software and abandoned the comforting lies we've been telling ourselves about traditional software.

The Topos of Programming | Yon

A topos-oriented programming language. Native via MLIR and LLVM, with a content-addressed heap on the Leech lattice.

Jev · September 17, 2026

A next-gen programming model

What I Found Interesting in Claude Code's Source

A breakdown of the most interesting engineering patterns in Claude Code's leaked source code: composable system prompts, runtime instruction injection, context compression, forking, prompt caching architecture, and more.

The mythical matched modules | Proceedings of the 24th ACM SIGPLAN conference companion on Object oriented programming systems languages and applications

Certified compilers are complex software systems. Like other large systems, they demand modular, extensible designs. While there has been progress in extensible metatheory mechanization, scaling extensibility and reuse to meet the demands of full ...

Resugaring | Proceedings of the 35th ACM SIGPLAN Conference on Programming Language Design and Implementation

Syntactic sugar plays a crucial role in engineering programming languages. It offers convenient syntax and higher-level of abstractions, as witnessed by its pervasive use in both general-purpose and domain-specific contexts. Unfortunately, the ...

Generic deriving of generic traversals | Proceedings of the ACM on Programming Languages

Functional programmers have an established tradition of using traversals as a design pattern to work with recursive data structures. The technique is so prolific that a whole host of libraries have been designed to help in the task of automatically ...

Tree Borrows | Proceedings of the ACM on Programming Languages

The Rust programming language is well known for its ownership-based type system, which offers strong guarantees like memory safety and data race freedom. However, Rust also provides unsafe escape hatches, for which safety is not guaranteed automatically ...

Compiling Models to Megakernels

Fine-grained synchronization, deep pipelines, and zero kernel launch overheads, automatically.

esoteric.codes

esolangs, esoplatforms, esosystems, and all that break from the norms of computing

Compile to Architecture - The Phoenix Architecture

For a long time we’ve treated frameworks as the target of software development. But if systems are meant to be regenerated and replaced safely, the real compilation target has to be the architecture itself.

SlopCodeBench: Benchmarking How Coding Agents Degrade Over Long-Horizon Iterative Tasks

Software development is iterative, yet agentic coding benchmarks hide design issues through their single-shot setup. Recent iterative benchmarks attempt to remedy this but heavily constrain an agent's design decision space, making it impossible to faithfully measure how their decisions shape future extensions. We introduce SlopCodeBench, a benchmark of 36 problems and 196 checkpoints where agents repeatedly extend their own solutions. Unlike prior iterative benchmarks, our evolving specifications demand architectural decisions but leave internal structure to the agent. We measure two forms of degradation: structural erosion (concentrated complexity) and verbosity (redundant code). Evaluating 15 coding agents across open and closed models, we find that no agent fully solves any problem end-to-end, and the best agent passes 14.8% of checkpoints. Quality degrades across checkpoints, with structural erosion rising in 77% of trajectories and verbosity in 75.5%. Compared to 473 open-source Python repositories, agent code is 2.3x more verbose and 2.0x more eroded, and the human repositories degrade less often and by smaller margins across their git histories. Explicit quality guidance reduces initial verbosity and erosion by up to a third, without affecting degradation rates. SlopCodeBench provides the first measurement of code degradation under iterative extension, revealing that agents pass checkpoints while producing code that erodes and bloats with each turn.

A Design Space Exploration of Async/Await

Many modern programming languages include some form of asynchronous programming. In particular, a growing number now have what we call straight-line asynchrony: attempts to provide asynchronous functions that look similar to synchronous functions, thereby enabling asynchrony without introducing complex control. These languages often share construct names like "async" and "await," which suggests that they have deep semantic similarities. Yet, a close examination reveals that these languages are quite different along several dimensions, often subtly. These differences have real semantic consequences: similar-looking programs can exhibit divergent behavior, confusing developers and language designers alike. This paper therefore presents a design space exploration of straight-line asynchrony. We dissect several existing languages, and show how no two of them agree as a whole on design decisions that affect the presence and ordering of execution. We articulate a design space with nine dimensions covering the full lifecycle of an asynchronous computation, covering questions such as: What precise guarantees does a language give upon calling an asynchronous function? What happens at the end of a task's life? How can a task handle being cancelled? We explore these questions through concrete examples, informal design discussion, and a formal semantics. Our ultimate goal is to help programmers, language designers, and language theorists all better understand the emerging landscape of straight-line asynchrony.

Kaitai Struct: declarative binary format parsing language

Kaitai Struct is a formal language for binary format specification that can be compiled into parser code