The Stanford Software Research Lunch is a weekly event on Thursday where students and researchers present their latest work to peers. Talks are open to anybody, but regular attendees are expected to give a presentation on their work.  Members of the Computer Forum are especially welcome.

Mailing list: software-research-lunch@lists.stanford.edu (subscribe via mailman)

Calendar: ical

Format: The lunch is held every week during fall, winter and spring quarter. The first week of every quarter is an organizational lunch where people can sign up to give a talk. If you'd like to give a talk, please contact Rupanshu Soi.

Past quarters: Spring 2026, Winter 2026, Fall 2025, Spring 2025, Winter 2025, Fall 2024, Spring 2024, Winter 2024, Fall 2023, Spring 2023, Winter 2023, Fall 2022, Winter 2021, Fall 2020, Winter 2020, Fall 2019, Spring 2019, Winter 2019, Fall 2018, Spring 2018, Winter 2018, Fall 2017, Spring 2017, Winter 2017, Fall 2016.

Ordering Food: For suggestions for those ordering food for the lunch, see here.

10/1: Relight: Simple User-Level Checkpointing and Fast-Forward Replay for Distributed Task-Based Systems

Time: Thursday, October 1, 2026, 12 noon - 1pm
Location: CoDa E401

Speaker: Elliott Slaughter

Abstract: Checkpointing, or periodic saving of program state to storage, is the de facto standard technique used to mitigate risks of nondeterministic bugs, hardware faults, and job wall-time limits in long-running programs. Traditional approaches require users to manually manage the migration of data to and from storage when capturing checkpoints and when resuming execution. However, for task-based programs, where the user has already factored the computation into tasks and the program data into collections, sufficient information is available to automatically capture and resume from checkpoints with minimal code changes. We present Relight, the first framework for automatic, distributed checkpointing of task-based programs that provides an efficient fast-forward replay for full job recovery. On a set of already-optimized benchmarks, we demonstrate that Relight delivers checkpointing performance and scalability comparable to the original, unmodified codes when running on up to 512 nodes of the Piz Daint supercomputer.

Food:

10/8: A Design Space Exploration of Async/Await

Time: Thursday, October 8, 2026, 12 noon - 1pm
Location: CoDa E401

Speaker: Gavin Gray

Abstract: Many modern programming languages include some form of asynchronous programming. In particular, a growing number now have what we call straight-line asychrony: attempts to provide asychronous functions that look similar to synchronous functions, thereby enabling asychrony 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 asychrony. We dissect several existing languages, and show how no two of them agree as a whole on designs decisions which 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.

Food:

10/15: Beyond Imperative Programming for Networked Applications

Time: Thursday, October 15, 2026, 12 noon - 1pm
Location: CoDa E401

Speaker: Nirav Atre

Abstract: As network line-rates rapidly outpace single-core CPU performance, building the next generation of networked applications requires “cycle efficient” software: implementations that deliver higher application functionality per CPU cycle spent. In this talk, I will describe how our quest for cycle efficiency led us to rethink the classical imperative programming model that pervades networked systems today, and how alternate abstractions can unlock better performance in three diverse contexts: (a) scheduling and load-balancing for network functions; (b) one-to-many communication in multi-tenant datacenters ; and (c) distributed systems applications in the cloud.

Food:

10/22: Helion DSL and the Future of Building Compilers with Agents

Time: Thursday, October 22, 2026, 12 noon - 1pm
Location: CoDa E401

Speaker: Jason Ansel

Abstract: Helion is a very high-level, Python-embedded kernel DSL that delivers state-of-the-art performance with an order of magnitude less code than low-level kernel languages. By exposing implementation choices in the language and pairing them with an integrated autotuner, Helion lets developers express the computation while the system searches for an efficient implementation. This talk introduces Helion's programming model and its new Pallas and CuTe DSL backends, bringing TPU support and performance competitive with the state of the art on NVIDIA Blackwell.

We'll then explore automated agentic loops for building compiler optimizations that improve many kernels at once. These loops pair agents with autotuning to search more efficiently in both time and tokens, supported by automated correctness testing and adversarial review. We’ll argue that with more powerful models and enough tokens, all systems will eventually reach hardware roofline performance, making maintainability, development velocity, and stability the key differentiators.

Food:

11/5: Cold-Patching for Faster Edit-Compile-Run Cycles / Parallel and Accelerated Dependent Partitioning

Time: Thursday, November 5, 2026, 12 noon - 1pm
Location: CoDa E401

Speaker: Matthew Sotoudeh and Rohan Chanani

Abstract: This week is a double feature with two practice talks.

Cold-Patching for Faster Edit-Compile-Run Cycles (Matthew Sotoudeh): (Practice talk for ACM SIGOPS ATC 2026, will be timing aimed for 18 minutes including questions at the end.) Programmers rely on fast edit-compile-run cycles when debugging code, exploring unfamiliar codebases, and trying out new ideas. Fiddle is a new tool for cold-patching small changes onto large compiled software systems. When repeatedly editing a small number of compilation units, Fiddle is faster than linkers, uses less memory, and does not require saving intermediate compilation artifacts. Fiddle is simpler and more reliable than hot-patching because it does not need to deal with global state migration or non-quiescent functions. Fiddle is designed for developers repeatedly fiddling with a handful of functions in a large codebase; it cannot patch changes to the types of global non-static objects, it cannot patch binaries compiled with LTO, and its speed relies on repeatedly editing the same set of compilation units. We end by describing a suite of tools enabled by the Fiddle cold-patching primitive that make it easier to rapidly prototype modifications to compiled system software.

Parallel and Accelerated Dependent Partitioning (Rohan Chanani): Dependent partitioning is a flexible framework for compactly describing and efficiently computing partitions of distributed data structures that contain indirections and inter-connected references. These data structures are commonly found in scientific applications, which operate over meshes, graphs, and sparse tensors. However, existing implementations of dependent partitioning process the individual elements of their input data sequentially on CPUs. This limitation makes dependent partitioning an expensive component of application initialization and hinders its use in dynamic or on-line contexts. In this work, we present parallel algorithms for computing dependent partitions and show that these algorithms perform well on accelerators like GPUs. Across a series of microbenchmarks and existing applications that use dependent partitioning, we show that our work achieves speedups of 9.4–9,807× for computing dependent partitions. We then show that our algorithms enable dynamic and on-line partitioning during steady-state execution.

Food:

11/12: Agents, effects, and how to protect yourself against them

Time: Thursday, November 12, 2026, 12 noon - 1pm
Location: CoDa E401

Speaker: Konstantinos Kallas

Abstract: Effectful scripts---i.e., scripts that perform actions that change the world around them, such as modifying files in the file system or configuring a cloud deployment---are ubiquitous in computing. In addition to being ubiquitous, these scripts are very powerful since their effects are often irreversible or costly, and therefore getting them right is critical. Unfortunately, the state of the art in checking the correctness of effectful scripts lags far behind that of other programming domains, leading to the frequent occurence of high-impact bugs, such as accidentally deleting important user data. To make matters worse, these scripts are increasingly being implemented by agents in response to user prompts, where it is even harder to determine whether they are doing the right thing, since user intent is ambiguously hidden behind a natural-language prompt, and agents have been shown to hallucinate and to be vulnerable to prompt injections and other attacks.

In this talk, I will discuss three systems that we are developing to address this exact problem: how can we know whether an effectful script is doing what we want it to do, and how can we protect ourselves when it is not? First, I will talk about Sash, the first system for semantic analysis of shell scripts that can identify critical bugs, such as accidentally deleting the user's home directory. Second, I will talk about try, a lightweight and easy-to-use system that allows transparently reverting a command's effects on the file system. Third, I will talk about Caruca, a system that can automatically infer partial specifications of arbitrary black-box commands. Together, these systems can improve users' confidence that the scripts they (or their agents) implement behave as intended.

Food:

11/19: TBD (Yihong Zhang)

Time: Thursday, November 19, 2026, 12 noon - 1pm
Location: CoDa E401

Speaker: Yihong Zhang

Food:

12/3: TBD (Qiantan Hong)

Time: Thursday, December 3, 2026, 12 noon - 1pm
Location: CoDa E401

Speaker: Qiantan Hong

Food:

12/10: TBD (Hanna Lachnitt)

Time: Thursday, December 10, 2026, 12 noon - 1pm
Location: CoDa E401

Speaker: Hanna Lachnitt

Food: