Ruckus
Upcoming Course Dates (4 days):
- March 23-26, 2026 (online)
Course Hours:
- 9:30am-5:30pm US Central Time/Chicago
Cost:
- $1200 (Corporate)
- $600 (Individual)
Registration:
Instructor: David Beazley
Overview
A common project in a college Programming Languages course is to implement the core of a small programming language that has the same semantic features as found in most real-world programming languages. This typically involves:
- Evaluation of Mathematical expressions
- Scoped mutable variables
- Higher order functions
- Mutable data structures
- Error handling
- Memory management (garbage collection)
- Types
- Objects
- Syntax translation (macros)
To implement a language with these features, a gentle college professor might have students use a programming language that's well-suited for the task such as 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 I just say "rusty?" Oh yeah, that's what we're doing!
In this 4-day project course, our goal is to implement the core of a small programming language using Rust. Starting out, it doesn't seem too bad, but we'll enter the 9th inner circle of recursion, borrowing, and mutability hell soon enough. To make matters worse, we'll start to doubt our prior knowledge of nice "beginner-friendly" languages like Python. Finding a way out of this mess seems possible, but it might require a beginner's mind and a deeper sort of englightenment.
How This Relates to Learning Rust
If you set out to learn Rust, it's easy to focus on surface-level issues like syntax, built-in datatypes, functions, structures, and other features you already think you "know" from other programming languages. However, as you dig deeper, you realize that Rust is rather different than what you're used to. You curse under your breath as the borrow checker looks at your modified code and says "no" for the hundredth time.
This course tackles Rust by stepping back and thinking about it from the standpoint of a "programming languages" project. If Rust is really so different, how would you go about finding out how? Suffice to say, building a programming language will cut right to the heart of the matter.
What to Expect
First and foremost, the goal of this project is to get better at Rust programming. The course starts with some nuts-and-bolts of programming with structs, enums, and pattern matching. However, the real meat of this course is found in some of the challenges that arise in implementing more advanced features like mutable data structures and higher-order functions--a challenge that involves a complex mix of ownership, object relationships, and mutability.
The second half of the course expands further into some advanced Rust topics includings macros, working with unsafe code, and integrating Rust with foreign libraries.
Ironically, the course does *NOT* cover the well-trodden topic of writing a parser. Understanding Rust has very little to do with knowing its surface syntax or spending a day fiddling around with string processing. As such, we're not going to bother ourselves with that. That's not to say that string processing isn't important--it's just that we'd rather spend our time on things that are much crazier.
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've already done a bit of Rust programming or worked through an introductory tutorial first.
Why?
Implementing a small 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
- It involves some common data structures such as lists and trees.
- It involves a variety of tricky relationships between data.
- The knowledge you learn is generally applicable to all programming languages.
- 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 small 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. I think the Ruckus project is a highly focused way to explore some core concepts that will help your understanding of Rust if you've previously struggled with it.
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. Many of the ideas in this course are inspired by the Brown University course.