Friday, October 28th
Room: CIT 368
Friday, 2:00PM EDT
All of us
Racket Hackathon/Open Space
This is your chance to raise you hand and suggest a topic that you want to dig in to. We will have a brief discussion to establish topics of interest and then divide into groups to try to make some progress. Got a question? Are you stuck with some Racket feature/package? Are you burning to learn more about something? This is your chance to dig in and get your hands dirty!
Here is a non-exhaustive list of topics that the community identified as worthy of discussion:
  • RacketScript
  • Graphics and diagramming
  • Scribble howto/enhancements
  • Making a #lang
  • Web programming
  • Typed Racket
This is just a list of possible topics; there are no promises that any of these topics will definitely be discussed. What actually gets discussed depends on who shows up and what they want to work on.
Racket pros and even some of the core developers will be on hand for the hackathon. This is your chance to take direct action on an issue of interest, so make something of it! You don’t have to be an expert; you just need to be interested and willing to learn. (If you are an expert, considering lending a helping hand to those in the community who are trying to upgrade their Racket lives.)
Saturday, October 29th
Room: CIT 368
Saturday, 9:00AM EDT
Doors Open
NB Breakfast won’t be served! Please eat before coming to the event.
Saturday, 9:30AM EDT
Ben L. Titzer (CMU)
The final tier is Shed: Inside the Wizard Engine’s fast in-place interpreter for WebAssembly
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 EDT
Saturday, 11:00AM EDT
Sebastian 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 typed macros 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 EDT
Ben 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 EDT
Jack 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 EDT
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 EDT
Marco 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 EDT
Hazel Levine (Indiana)
Design Recipe Guided Synthesis with Bingus
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.
Saturday, 3:00PM EDT
Saturday, 3:30PM EDT
Leif 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 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 EDT
Tim 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 EDT
Kuang-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 EDT
Siddhartha 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.
Sunday, October 30th
Room: CIT 368
Saturday, 9:00AM EDT
Doors Open
NB Breakfast won’t be served! Please eat before coming to the event.
Sunday, 9:30AM EDT
Cameron 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 for developers.
Sunday, 10:00AM EDT
Sorawee Porncharoenwase (Washington)
fmt: A Racket code formatter
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.
Sunday, 10:30AM EDT
Ben Greenman
Summary of the Summer of #lang (Fun + Games III)
Come learn about the amazing entries to this summer’s #lang party! Submissions include new languages, improved languages, language ideas, and Standard ML.
Bio: Ben is a postdoc at Brown University and a co-organizer of the lang party with Stephen DeGabrielle.
Sunday, 11:00AM EDT
Sunday, 11:30AM EDT
Sam Tobin-Hochstadt (Indiana)
The State of Racket
Sunday, 12:00PM EDT
Racket 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!
COVID-19 Policy
RacketCon 2022 will be governed by the COVID-19 policy in place at the conference venue (Brown University). Please familiarize yourself with it before coming. Because the pandemic is not static, the policy may change. Take one last look at Brown’s COVID-19 policy shortly before coming to campus. Once you’re on campus, you are expected to comply with the policy.
Friendly Policy
The proceedings of RacketCon are expected to take place under the Racket Friendly Environment Policy.
Getting There
The Brown Computer Science Department has put together a great page with instructions for how to reach the department by plane, train, or car. Once you’re at the right building, RacketCon signs will guide you to the RacketCon place.
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:
Previous RacketCons