Room: CIT 368
Saturday, 9:00AM EDTDoors Open
NB Breakfast won’t be served! Please eat before coming to the event.
Saturday, 9:30AM EDTBen L. Titzer (CMU)
The final tier is Shed: Inside the Wizard Engine’s fast in-place interpreter for WebAssembly
is a compact, well-specified bytecode format that offers a portable compilation target with near-native execution speed. The bytecode format was specifically designed to be fast to parse, validate, and compile, positioning itself as a portable alternative to native code. It was pointedly not designed to be interpreted
directly. Instead, most engines have focused on optimized JIT compilation for maximum performance. Yet compilation time and memory consumption critically impact application startup, leading many Wasm engines to now employ two compilers. But interpreters start up even faster. A typical interpreter being infeasible, some engines resort to compiling Wasm not to machine code, but to a more compact, but easy to interpret format. This still takes time and wastes memory. Instead, we introduce a new design for an in-place interpreter for WebAssembly, where no rewrite and no separate format is necessary. Our measurements show that in-place interpretation of Wasm code is space-efficient and fast, achieving performance on-par with interpreting a custom-designed internal format. This fills a hole in the execution tier space for Wasm, allowing for even faster startup and lower memory footprint than previous engine configurations.
Bio: Ben L. Titzer is a Principal Researcher at Carnegie Mellon University. A former member of the V8 team at Google, he co-founded the WebAssembly project, led the team that built the implementation in V8, and led the initial design of V8’s TurboFan optimizing compiler. Prior to that he was a researcher at Sun Labs and contributed to the Maxine Java-in-Java VM. He is the designer and main implementer of the Virgil programming language.
Saturday, 10:30AM EDTCoffee
Saturday, 11:00AM EDTSebastian Ullrich (KIT)
Metaprograms and Proofs: Macros in Lean 4
A core feature of the Lean 4 programming language
and theorem prover is
an expressive macro system, taking heavy inspiration from Racket. In
this talk, we give an overview of macros in Lean and discuss the ideas
we took from Racket as well as the problems we decided to solve in a
different way. In particular, we talk about recent work on
that prevent many common mistakes by Lean macro authors.
Bio: Sebastian is a PhD student at Karlsruhe Institute of Technology,
Germany, and a Lean core developer. He enjoys both working on the
user-facing frontend of the system as well as on the code generation
backend to make users and binaries go fast.
Saturday, 11:30AM EDTBen Greenman (Brown)
Shallow and Optional Types
Typed Racket (TR) is powerful—but sometimes too powerful. In addition to a
type checker and type-driven optimizer, it includes a contract layer that
dynamically monitors interactions with untyped code. The contracts make TR one
of the strongest and most flexible type systems in the world, but also one
of the slowest when there are many boundaries to untyped.
Shallow TR and Optional TR are two alternatives that have (finally!) arrived
with the Racket 8.7 release. Shallow TR enforces types with local assertions
rather than compositional contracts, keeping a bit of soundness at low cost.
Optional TR enforces types with nothing at all. This talk will explain Shallow
and Optional in depth and show how they can interact with untyped code,
standard TR, and each another.
Bio: Ben is currently a postdoc at Brown University studying human factors for type
systems and logics. Next Fall, he will be an assistant professor at the
University of Utah. Reach out if you would like to live on a mountain for N
years studying programming languages.
Saturday, 12:00PM EDTJack Firth
Resyntax: A Macro-Powered Refactoring Tool
Resyntax is a tool that wields the power of Racket’s macro expander to analyze Racket code and suggest improvements. It uses a domain-specific language to specify refactoring rules in terms of syntax-parse macros. Rules explain why they’re improvements, allowing Resyntax to teach users how to make their code more straightforward, more readable, and more efficient. This talk covers how Resyntax works, why it’s different from tools like code formatters and linters, and what it means for the future of Racket’s static analysis ecosystem.
Bio: Jack Firth (they/them or she/her) is a software engineer at Google working on continuous integration systems, Java libraries, and static analysis tools. Special interests include asynchronous programming, large-scale distributed computing, martial arts, pretty diagrams, and dyeing their hair pink.
Saturday, 12:30PM EDTLunch
Lunch will not be served! There are many options on Thayer Street, right off campus. Attendees will be given more information on-site about their lunch options. You are also welcome to bring your own lunch. Microwaves and hot water dispensers will be made available if needed.
Saturday, 2:00PM EDTMarco Morazán (Seton Hall)
What Can Beginners Learn from Video Games?
Beginners need to learn important Computer Science concepts revolving around problem solving, program design, modularity, documentation, testing, efficiency, running time, and program refinement. This presents unique challenges given students that are enthusiastic but have little experience quickly lose interest. Instructors must capture their imagination to channel their enthusiasm into learning the important lessons. An effective medium to do so is the development of video games. This talk outlines a design-based curriculum for beginners that is based on video game development.
Bio: Dr. Marco T. Morazán joined Seton Hall in 1999. He did his undergraduate studies at Rutgers University and his graduate work at the City University of New York. At Seton Hall he teaches at all levels of the Computer Science curriculum including his signature courses: Introduction to Program Design I and II, Organization of Programming Languages, and Automata Theory and Computability. His main research foci are the implementation of programming languages and Computer Science Education. As the graduate school advisor, he takes special pride in making sure that his students are prepared to continue studies outside of Seton Hall. Dr. Morazán is a strong proponent of undergraduate research opportunities and routinely has students collaborate with him on projects. Along with his undergraduate research students, he is responsible for an optimal lambda lifting algorithm and an effective mechanism for closure memoization. In Computer Science education, he is especially proud of the effectiveness of the Computer Science curriculum, based on the development of video games, he has developed for beginners.
Saturday, 2:30PM EDTHazel Levine (Indiana)
Design Recipe Guided Synthesis with Bingus
The How to Design Programs
utilizing simple subsets of the Racket programming language, teaches
the fundamentals of data-driven program design using the
This approach teaches recursion by structural decomposition of
the input data, enough to express many algorithms on simple recursive
data structures. Furthermore, this approach is deeply mechanical,
having students write a
depending on the input type of the
function that when filled in produces structurally-recursive programs.
We present a work-in-progress program synthesizer for the HtDP Student
, that utilizes the design recipe as its primary means
of generating programs. By parsing the signature (specification in a
comment) of a function, the first step of the design recipe, Bingus
makes guesses depending on the signatures of the function inputs,
utilizing the check-expects (unit tests) to determine when synthesis is
We demonstrate usage of Bingus as a program synthesis tool integrated
into DrRacket, and discuss ways that we plan to extend this tool for
pedagogic purposes, such as providing better feedback to students from
an auto-grader, or determining when student-provided unit tests are
Saturday, 3:00PM EDTCoffee
Saturday, 3:30PM EDTLeif Andersen (Northeastern)
VISr: Visual and Interactive Syntax
While macros continue to take us to the frontiers of what is possible with embedded Domain Specific Languages, they are still limited to textual programming languages. Visual and Interactive Syntax realized (VISr) introduces the world to hybrid textual and visual programming languages. Programmers are no longer forced to choose between readable code and runnable code. VISr gives programmers the power of Language Oriented Programming...now with pictures. This talk teaches programmers how to use VISr for ClojureScript. It also introduces Frankenstein: an early prototype of VISr for Racket.
Bio: Leif Andersen is a postdoctoral Researcher studying programming languages in the University of Massachusetts Boston. She studies topics in Programming Languages and Human Computer Interaction. Specifically, she works on domain-specific languages for creating hybrid textual-visual programs.
Saturday, 4:00PM EDTTim Nelson (Brown)
Forge: Building a Pedagogic Solver Tool in Racket
Brown’s Logic for Systems course teaches modeling and reasoning about
systems via constraint solving. The specific solver we use must fit
our teaching needs; we require accessible syntax, the right level of
automation, the ability to visualize output, and much else. This short
talk will show how our tools have evolved, how building our own atop
Racket has been worthwhile, and why it matters.
Saturday, 4:20PM EDTKuang-Chen Lu (Brown)
Stacker: A runnable notional machine for an HtDP-like language
It is difficult to teach the semantics of a conventional programming language to people with only programs and program outputs. There are so many entities behind the scene: the mapping from variables to values, the identities of mutable (and shareable) data structures, the continuation (either represented as evaluation contexts or call stacks), etc. Notional machines, ways to present some aspects of running programs, can facilitate the teaching process by depicting some of these entities and their interaction with the runned programs.
This talk presents a notional machine, the Stacker, and how it is being used at Brown’s programming languages course. The Stacker is implemented as a Racket
#lang. It is similar to the Stepper but supports mutation and depicts the trace of programs in terms of environments, heaps, and call stacks rather than in terms of substitution.
Saturday, 4:40PM EDTSiddhartha Prasad (Brown)
Examplar: Making Hay from Wheat
Novice programmers often begin coding with a poor understanding of the task at hand and end up solving the wrong problem. To combat this, students are often asked to explain the problem
in their own words. What words can students meaningfully use, how can we provide them automated feedback, and how can we make this feedback maximally useful? This talk presents concrete solutions to all these problems.
Room: CIT 368
Saturday, 9:00AM EDTDoors Open
NB Breakfast won’t be served! Please eat before coming to the event.
Sunday, 9:30AM EDTCameron Moy (Northeastern)
Contracts for protocols
Racketeers often use contracts to express the obligations that their libraries
impose on, or promise to, clients. While Racket’s contract system can handle
many specifications, it cannot naturally express protocols. For example,
a specification may constrain the permitted call sequence of functions,
or the context in which functions may be applied. This talk will present
several extensions to Racket’s contract system that attempt to fill this gap.
Bio: Cameron is a Ph.D. student studying programming languages at Northeastern University.
He spends most of his time thinking about how to make Racket’s contract system better
Sunday, 10:00AM EDTSorawee Porncharoenwase (Washington)
fmt: A Racket code formatter
is a code formatter for Racket. Its applications range from teaching beginners the Racket coding conventions to allowing frictionless collaborative projects. As Racket allows user-defined macros and has a relatively non-traditional code style, fmt faces unique challenges: it must be extensible yet expressive enough to capture the style. This talk will cover the design of fmt, how it overcomes these challenges, and how to use our code formatting DSL to extend fmt.
Sunday, 10:30AM EDTBen Greenman
Summary of the Summer of
#lang (Fun + Games III)
Come learn about the amazing entries
to this summer’s
Submissions include new languages, improved languages, language ideas, and
Bio: Ben is a postdoc at Brown University and a co-organizer of the lang party with
Sunday, 11:00AM EDTCoffee
Sunday, 12:00PM EDTRacket Management
Racket Town Hall
Please come with your big questions and discussion topics.
The registration form is here
. A ticket costs $25 and gives you admission to all the talks and coffee breaks and the company of your fellow Racketeers.
Optional Conference Dinner
On Saturday evening you are welcome to join us for the conference dinner at Kebob and Curry
, a nearby Indian restaurant. Dinner is optional, and is not included in the base price of $25. If you want to join the dinner, it costs $35 on top of the ticket price. When registering, you can indicate whether you wish to come to dinner, so you will end up paying either $25 or $60. The restaurant is at 261 Theyer Street
, very close to campus.
If you intend to come, please register at your earliest convenience!
Stay wherever you want! There are plenty of hotels in the area.
That said, we have reserved blocks at two local hotels. The booking links below may still work even if all rooms in the block have been booked and the discount has expired. You may be guided to a generic booking form unconnected to RacketCon. In no particular order: