match is very convenient for deconstructing data and accessing values deep within a data structure, but it is not useful for making changes to that data structure. In this talk, I’ll present a DSL that looks like match, but allows you to perform immutable updates on the target value using pattern variables to specify where an update should occur. I’ll also talk about optics, which are the abstraction powering these immutable updates.

Ion Fusion is a customizable programming language that unifies the semantics of persistent data and the code that manipulates it. Oriented around the Amazon Ion data format--the backbone of Amazon’s retail systems and even consumer products--Fusion has been the brains of internal analytics, data processing, and workflow systems since 2013. This talk explores Ion Fusion’s unique design goals and constraints, its roots in Scheme and Racket, and its vision of sustainable software evolution.

The Emacs package "racket-mode" has continued to evolve its design and features. Among other things, it allows multiple local and remote back ends, has a redesigned "lossless" REPL, supports modern Emacs UI completion annotations, and enables lang-driven editing. Most recently the step debugger has gotten some attention.

Exact probabilistic inference is a requirement for many applications of probabilistic programming languages (PPLs), but implementing a PPL with high-performance inference is difficult. Roulette is a new discrete PPL that combines high-performance exact inference with expressive language features by leveraging the close connection between exact probabilistic inference and the symbolic evaluation strategy of Rosette. Building on this connection, Roulette generalizes and extends the Rosette solver-aided programming system to reason about probabilistic rather than symbolic quantities. In this talk, I’ll demonstrate how to use Roulette and discuss some of the ideas that make it work.

Dusa is a recently designed logic programming language featuring mutually exclusive choice as a primitive to enable computation of solutions that satisfy constraints. To explore further host integration, we introduce miniDusa, a Dusa-inspired hosted domain-specific language implemented using Racket and the syntax-spec metalanguage. This architecture lets us inherit tooling, extensibility, and interoperability features from Racket essentially “for free”.

Taking its name from the slow food movement, the slow internet movement seeks to recreate the less commercial and more user-centric internet of the early 90s. We will explore how Racket facilitated the development of two slow internet applications and one DSL. First is gopher21, a gopher server with full text search. Second is the graphical, multi-tabbed gopher and gemini client Molasses. And finally, #lang magic is an implementation of the Unix file command’s custom language for writing filetype determination queries. By the end of the talk we will have discussed fear of macros, html layout and rendering, custom canvas widgets and how Racket appears from the perspective of an experienced C programmer and low-level engineer.

Music and Lisp code might seem worlds apart, but through various processes it is possible to get aurally pleasing results from a LISP 1.5 → music compiler (written in Racket, of course). In this talk, I explain how this “musicalization” works and show ways that composers can make use of the concept.

Racket’s macros make creating small extensions to the language remarkably simple. But when you step up to creating DSLs with static semantics and compiler optimizations, you need new tools to integrate your DSL implementation with Racket’s expansion process. In this talk I’ll demonstrate 5 macro design patterns that sophisticated DSLs like match, syntax-parse, and Typed Racket use to validate syntax, communicate static information, and integrate with DrRacket. But as any good language-oriented programmer knows, a design pattern usually indicates a missing linguistic abstraction! And in fact, my syntax-spec metalanguage abstracts over all of these design patterns, generating implementations from a declarative specification of your DSL syntax. So I’ll also show how you can more easily achieve the same results with syntax-spec, design-pattern-free.

Imagine, for a moment, that a music score could somehow become a Racket module. Imagine if every notation on that music score was a syntax object. Imagine selecting areas of the score and running macro-like rewrites on the notations within that selection. Imagine a context system which allows a composer to summon important static information about any notation, such as the key, the tuning system, or the instrument. This is the vision of Tonart, an extensible language and library for composing music in Racket. This talk will highlight the ideas Tonart steals from Racket in its design, as well as the language features Tonart reuses from Racket in its implementation.

Please come with your big questions and discussion topics.