Saturday, 9:00AM PDT

Saturday, 10:00AM PDT

Saturday, 10:30AM PDT

Type Inference With Logical Types For Untyped Languages

Racket and Rhombus support flexible idioms that pose challenges for type systems. Typed Racket, the gradually typed counterpart of Racket, uses occurrence typing to type-check programs whose control flow depends on run-time type tests. To alleviate the burden of annotation, Typed Racket also supports local type inference. Problems arise, however, when a Typed Racket program imports a macro from a Racket module that expands to complex code containing lambda expressions. Programmers cannot add annotations to generated parameters. Moreover, local type inference is not designed to infer types for lambda parameters. Therefore, the type system usually conservatively rejects the code. As a result, programmers often have to rewrite macros in Typed Racket. My ongoing prototype type inference system addresses the problem by combining occurrence typing and algebraic subtyping. In this talk, I will demonstrate how the new type inference handles patterns commonly seen in Racket programs.

Saturday, 11:10AM PDT

Language-Oriented Low-Level Programming with Pille

Racket and Rhombus offer incredible expressive power, but the Racket VM can become a limiting factor for low-level performance and efficiency—and it necessitates a runtime system that precludes highly-constrained platforms like microcontrollers. Pille (pronounced like “peel”) is a new Rhombus-based language that aims to bring language-oriented programming to low-level and high-performance domains. In particular, Pille grafts Rhombus’s enforestation process onto a new core language with an LLVM-based compiler, bypassing the limitations of the Racket VM while retaining full Rhombus-based macros. This talk will provide an introduction to Pille, with a particular emphasis on how its high-level metaprogramming—not all of which derives from Rhombus—can address decidedely low-level problems.

Bio: Lucas Myers is a PhD student at Northwestern University (advised by Robby Findler), where his research focuses on adapting the ideas and technologies of extensible programming languages—especially Racket and Rhombus—to the domain of systems programming. Prior to starting his PhD, Lucas worked in the software industry on an eclectic mix of projects that spanned the hardware/software stack. He is broadly interested in finding PL solutions to systems problems, and see extensible languages as holding immense (and largely unrealized) potential in that pursuit.

Saturday, 11:50AM PDT

Saturday, 1:30PM PDT

Treason: Making Macros and IDE Services Work Together

Racket’s macros let us extend the language and create DSLs, but they also get in the way of providing good IDE services when the program is broken or incomplete. Treason is a prototype of a macro-extensible language that provides good IDE services even when such errors prevent complete macro expansion. Treason’s macro expander recovers from errors to continue expanding and collecting information used to drive IDE services. Our key contribution is spec-driven subexpression expansion: syntax-class annotations allow us to expand subexpressions even within a broken macro use.

Bio: Mike Delmonaco is a Software Engineer at Amazon Web Services with a hobby interest in Programming Languages and Racket. Outside of work, he enjoys rock climbing, video games, creating interactive math visualizations, writing music, programming language research, and teaching.

Saturday, 2:10PM PDT

Herbie: Improving Floating-point Accuracy

Floating-point math requires rounding, so it’s not perfectly accurate. But how inaccurate it is depends on how you do your computation: two ways of writing the same mathematical formula can have radically different accuracy. Herbie is a compiler that exploits this property to compile mathematical formulas to accurate floating-point expressions. The talk will introduce floating-point error, demonstrate Herbie, talk a bit about how it works, and reflect on ten years of writing Herbie in Racket.

Bio: Pavel is an Associate Professor at the University of Utah and a Herbie developer.

Saturday, 2:50PM PDT

Saturday, 3:30PM PDT

Effect Handlers in cio

Effect handlers — What are they? How do they work? We will discuss the design of cio, an (untyped) effect-handler library for Racket and Guile Scheme, and delve into the user interface considerations and implementation strategies of effect handlers broadly. Effect handlers, similar to delimited continuations, offer the expression of general non-local control flow through a minimal set of primitives, yet more closely resemble standard imperative constructions — but preserve pure reasoning principles by separating the invocation of a particular effect from its implementation. We discuss this, and further discuss some of the challenges and limitations of a library-level implementation of effect handlers.

Bio: JJ is a linguist by trade, living and working in Vancouver, British Columbia, by the Salish Sea. They are also a hobbyist programmer and a programming languages nerd: interested in language in its capability as an interface for expressing intent — between humans and other humans, and between humans and computers. They are a big fan of Rust, Lean 4, and (of course) Racket.

Saturday, 4:10PM PDT

BrandX: Commoditizing OOP with Interfaces, Generics, and Contracts

BrandX is a new Racket library primarily for OOP via interfaces and generic functions with proper contract support. This talk explains my motivations for a new library, mainly stemming from limitations in racket/class and racket/generic. It discusses the library design in terms of syntax, semantics, and ergonomics—how to improve on existing features and how to mitigate the loss of omitted features. It sketches some aspects of the implementation, including some under-appreciated macro tricks for modern Racket. Finally, it reports on experiences using the library so far.

Bio: Ryan is a developer of Racket who focuses on macros and Rackety library design.

Saturday, 6:00PM PDT

Gathering with drinks and snacks.

Sunday, 9:00AM PDT

Uke: Immutable Dataframes for Racket

Dataframes emerged from statistical programming languages in the 90s, and now many languages have them. Even Racket has several to choose from. Uke is an opinionated dataframe library that focuses on immutability and tries to be efficient about copying.

Bio: Sam is an engineer that works with machine data.

Sunday, 9:40AM PDT

A New Foreign-Function Interface: ffi2

Eli Barzilay’s FFI (ca. 2004) made C-based dynamic libraries accessible within Racket programs without new C code. This approach had precedents in Lisp and Scheme systems, including Chez Scheme, but Barzilay’s dynamic esthetic and pioneering use of Racket macros resulted in an especially convenient and composable interface that was a good fit to the underlying runtime system. Meanwhile, Andy Keep’s ftypes layer (ca. 2011) for Chez Scheme’s FFI similarly takes advantage of macros for expressiveness, and it also cleverly exploits Chez Scheme’s data-representation regime. Keep’s more static system offers good performance, compact representations of foreign pointers, and low-cost checking of pointer operations. The new `ffi2` layer in Racket brings these two lines of development together. It relies on small adjustments to Chez Scheme that reflect lessons learned from `unsafe/ffi`, and it introduces a static approach at the Racket level to better target Chez Scheme. As a result, the `ffi2` library offers the convenience and composability combined with good performance and low-cost foreign pointers.

Bio: Matthew is a Professor at the University of Utah and a developer of Racket who focuses mostly on macros, compilation, and the runtime system.

Sunday, 11:30AM PDT

Racket Town Hall