Times are Pacific.

Keynote. Canon Professor Emeritus at Stanford; led the design of RenderMan at Pixar; co-founded Tableau; 2019 Turing Award. No abstract is published.

RenderMan's shading language and Tableau's visual query language are both notations built for one domain, which is the thing Racket exists to make cheap. The same argument, from the other side, opened Clojure/conj's source inspector talk with Bret Victor.

PhD candidate at Indiana. The problem: a Typed Racket program imports a macro from untyped Racket, the macro expands to a lambda, and nobody can annotate the generated parameters. Local inference does not infer lambda parameters, so the checker rejects the code. His prototype combines occurrence typing with algebraic subtyping.

Occurrence typing is the part to have in mind: the type of a variable narrows after a test on it.

#lang typed/racket
(: describe (-> (U String Integer) String))
(define (describe v)
  (if (string? v)
      (string-append "s:" v)          ; v is a String here
      (number->string (add1 v))))     ; and an Integer here
(describe "a")   ;=> "s:a"
(describe 41)    ;=> "42"

The comparison rows are from memory, not checked.

PhD student at Northwestern, advised by Robby Findler. Pille grafts Rhombus's enforestation, the step that turns a flat token stream with infix operators into a tree, onto a new core language with an LLVM-based compiler. The macros stay; the Racket VM goes, and with it the runtime that rules out microcontrollers.

This is the same move as jank, presented at Clojure/conj two days earlier: keep the language's metaprogramming, replace the host with LLVM. jank keeps Clojure's runtime semantics and reaches for C++ interop. Pille gives up the runtime to reach the bottom of the stack.

Software engineer at AWS. Macros get in the way of IDE services when the program is broken or half-typed, because expansion stops at the first error. Treason's expander recovers and keeps collecting. The stated contribution is spec-driven subexpression expansion: syntax-class annotations say which parts of a macro use are expressions, so they can be expanded even when the macro use around them is broken.

Clojure's answer to the same problem is to not expand at all: clj-kondo and clojure-lsp analyse source statically and need a hint for every unfamiliar macro. Treason takes the opposite bet. He spoke last year on a match-like DSL for deep immutable updates.

Associate Professor at Utah. Two ways of writing the same formula can differ enormously in accuracy; Herbie searches for the accurate one. Ten years of writing it in Racket.

The standard example, run here. Both functions compute √(x+1) − √x:

#lang racket
(define (naive x) (- (sqrt (+ x 1)) (sqrt x)))
(define (rewritten x) (/ 1 (+ (sqrt (+ x 1)) (sqrt x))))
(for ([x '(1e0 1e8 1e16)])
  (printf "~a  naive ~a  rewritten ~a\n" x (naive x) (rewritten x)))

1.0  naive 0.41421356237309515  rewritten 0.4142135623730951
100000000.0  naive 5.000000055588316e-5  rewritten 4.9999999874999996e-5
1e+16  naive 0.0  rewritten 5e-9

At 10^16 the naive form returns zero. The subtraction cancels every significant digit; the rewritten form has no subtraction. Herbie finds that rewrite without being told.

cio is an untyped effect-handler library for Racket and for Guile. An effect handler separates asking for something from deciding what the answer is, and the handler may resume the asker.

The primitive underneath, in Guile, with no library. The program asks; the handler answers twice:

(define tag (make-prompt-tag "ask"))
(define (ask question) (abort-to-prompt tag question))
(define (program) (+ 1 (ask 'how-many)))

(call-with-prompt tag program
  (lambda (k question) (list question (k 41) (k 99))))
;;=> (how-many 42 100)

k is the rest of program from the point it asked. Calling it twice is what exceptions cannot do.

The comparison rows are from memory. That the library targets Guile as well as Racket is the reason to watch this one from a Guile project.

Racket developer, macros and library design. A new library for OOP through interfaces and generic functions with proper contract support, motivated by limits in racket/class and racket/generic.

The neighbours are CLOS generic functions and Clojure protocols. Chris Nuernberger's Clojure/conj talk the day before proposed a replacement protocol implementation for Clojure on similar grounds: the built-in one has limits that only show at scale.

An opinionated dataframe library: immutable, and careful about copying. Racket already has several dataframes.

The Clojure counterpart is tech.ml.dataset, which is columnar and functional-by-default over typed buffers. The question to carry in: what does "efficient about copying" mean without persistent data structures underneath?

Racket's FFI (Eli Barzilay, about 2004) is dynamic and convenient. Chez Scheme's ftypes (Andy Keep, about 2011) is static and fast, with compact foreign pointers and cheap checks. ffi2 brings the two together, with small changes to Chez Scheme.

This table is the week's theme in one place: three Lisp communities shipped or showed a new way to call native code within five days.

Sam Tobin-Hochstadt, then questions to Racket management. No abstract.