• RacketScript
• Graphics and diagramming
• Scribble howto/enhancements
• Making a #lang
• Web programming
• Typed Racket

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.

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 typed macros that prevent many common mistakes by Lean macro authors.

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.

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.

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.

The How to Design Programs (HtDP) curriculum, utilizing simple subsets of the Racket programming language, teaches the fundamentals of data-driven program design using the design recipe. 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 template 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 languages, Bingus, 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 complete. 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 insufficient.

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.

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.

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.

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.

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.

fmt 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.

Come learn about the amazing entries to this summer’s #lang party! Submissions include new languages, improved languages, language ideas, and Standard ML.

Please come with your big questions and discussion topics.