Ruckus

Upcoming Course Dates (2 days):

May 22-23, 2025
June 16-17, 2025
July 12-13, 2025 (weekend!)

Course Hours:

9:30am-5:30pm US Central Time/Chicago

Cost:

$250

Registration:

Instructor: David Beazley

Other Courses | FAQ

This course is part of the Summer of Rust series.

Overview

If you were taking a programming languages course in college, a common project is to implement a small programming language. For this, you might implement some variant of Lisp or Scheme. Maybe you'd write it in Scheme itself--recreating the infamous metacircular evaluator project from the SICP book. Or, you'd write it in a "proper" language for making a programming language like Racket. Sure, you could do that. But, maybe it all just needs to be a little bit louder--like the cacaphonous ruckus of an electric guitar played through a rusty amplifier that's been left out in the garage a little too long. Wait, did you just say "rust?" Oh yeah, let's do that!

In this 2-day project course, your goal is to implement a small Lisp interpreter in Rust. On the surface, it doesn't seem too bad until you enter the 9th inner circle of recursion, borrowing, and mutability. From there, deeper enlightenment is probably the only way out of the mess you just created for yourself.

Target Audience

This course is for programmers who want to dive into a small project that gets right to the heart of some major difficulties associated with learning Rust--especially those surrounding data structures, ownership, the borrow checker, and the handling of mutability. You don't need to be a Rust expert, but the project will be much easier if you already know some of the basic material concerning data structures, functions, and project setup.

Instruction Format

The course starts with a very brief overview of what's involved in making a Lisp interpreter along with an example in a popular programming language like Python. From there, we'll jump into the problem of making it work in Rust. Although there will be certain similarities in coding approach, we'll quickly find that Rust presents a new set of challenges. Expect a significant amount of coding intermixed with group discussion. There are no powerpoint slides. This is not a passive course.

Note: This project is focused on creating the central runtime core of a tiny Lisp interpreter. It does not focus on larger problems such as parsing or even making a larger programming language. If you're interested in that topic, it is covered in the Crusty Interpreter and Write a Compiler courses.

Why?

Implementing a small Lisp interpreter is actually a really great small project for learning a new programming language. Here's why:

It gets you thinking about programming languages
The project is not too big and doesn't require any dependencies
You'll use a variety of common data structures such as lists and trees.
It involves a variety of tricky relationships between data.
There are problematic implementation concerns such as how to handle mutability.
It's cool to see it work when you're done.

A personal note: when I was first trying to learn Rust about 7 years ago, I attempted to implement a Lisp interpreter and found it to be significantly more difficult than I realized due to having a poor mental model of what was actually going on Rust. I now think this is a great exercise for getting to the bottom of some core concepts that will help your understanding of Rust if you've previously struggled with it.

A Word About Cost

Attending two full days of tutorials at a popular conference such as PyCon 2025 costs $600. This course is cheaper than that. I may be able to offer discounts for parity pricing, students, and job seekers--ask me when you hear back after registering.

About the Instructor

This course is taught by David Beazley. David is probably best known in the Python world as the author of Python Distilled (Addison Wesley) and the Python Cookbook, 3rd Edition (O'Reilly Media). You might be wondering what would qualify him to teach a Rust course, but David is also a former University Professor, having formerly taught Operating Systems, Compilers, and Networks at the University of Chicago. In 2023 and 2024, he taught Programming Languages with Shriram Krishnamurthi at Brown University. If you must know, he's also trying to get better at Rust programming.