Friday, Oct 18: Workshops

Registration will be open at 8:00AM. Announcements and introductions will be at 8:30AM in the dining room.

Coffee, tea, soda, and water will be available throughout. Breaks with snacks provided will be at 10:30AM and 3:30PM.

Time English Room Wright Room Wedgewood Room Dining Room
9:00AM - 12:00PM Intro to Rust - Jake Goulding Building a Toy Programming Language in Rust - Elias Garcia Building a Plugin System with Rust+Wasm - Robert Masen Unconference - Jean Lange
12:00PM - 2:00PM Lunch on your own
2:00PM - 5:00PM Write a Blockchain Runtime with Substrate - Joshy Orndorff Building a Toy Programming Language in Rust - Elias Garcia Lindenmayer Systems: Modeling the Natural World - Daan von Berkel & Phil Fried Unconference - Jean Lange

Saturday, Oct 19: Talks

All Saturday activities will be in the Auditorium.

Registration will be open at 9:00AM. Announcements will be at 9:15AM.

Coffee, tea, soda, and water will be available throughout. Snack breaks will be at 10:30AM and 3:00PM.

Time Talk
9:30AM Unicode in Rust - Illustrated by Kanji - Jenny Manning
10:00AM Tips for Writing a Web Server and Beyond - Apoorv Kothari
10:30AM Break with snacks provided
11:00AM Are we *actually* IDE yet? A look on the Rust IDE Story - Igor Matuszewski
11:30AM Polonius: Either Borrower or Lender Be, but Responsibly - Niko Matsakis
12:00PM Lunch on your own
2:00PM Lightning Talks - Maybe you!
2:30PM Introducing Rust into a Legacy Embedded System - Steven Walter
3:00PM Break with Snacks Provided
3:30PM Type Theory for the Working Rustacean - Dan Pittman
4:00PM The Death and Rebirth of - Quiet Misdreavus
4:30PM Raffle drawings, closing announcements
5:00PM RBR 2019 is over! 😭❤️
Parity Substrate is a next-generation blockchain framework for innovation. With Substrate, it is easy to build your own decentralized application entirely in Rust. In this workshop, we will setup a Substrate development environment, build a blockchain by composing pre-written runtime modules, and then write our own custom runtime module. Attendees will learn fundamental decentralization and blockchain principles, gain hands-on experience with the Substrate framework, and learn concrete next steps to build their own blockchain projects.
Joshy Orndorff

Joshy Orndorff

Joshy Orndorff is a blockchain and decentralization enthusiast born and raised here in the rust belt. He began his career as a physicist, earning a BS and MS in the field. After the Snowden revelations, his career pivoted to computer science and freeing individuals from having to trust central authorities who are often not worthy of being trusted. is a beloved resource in the Rust community, but it was not long ago that such a resource did not exist. Join QuietMisdreavus as she tells the story of, from its humble beginnings as and a Rustacean's learning project; through to its heyday and decline as a single-maintainer project that became a trusted community resource; to its rebirth in the present day as an official Rust Project-maintained endeavor. Along the way, you can also get an insider's view into the service and take a peek at how it ticks.


QuietMisdreavus is the lead of the Rustdoc Team, and a maintainer of both the Rustdoc tool and Originally from Texas, she plans to attend the Recurse Center in New York this fall to focus on pushing her Rust projects to the next level. Her favorite programming languages are Rust and Visual Basic, and she's never far from her music collection.
Ever since appearing on the Rust 2017 roadmap, IDE support has been and continues to be a highly-requested feature that should boost productivity when working with Rust code. Despite the landscape shifting a lot during these last 3 years, including a proliferation of new tools and improved integration between tools, it feels like the Rust IDE story is not yet complete. This talk will explore the current status of the official Rust Language Server (RLS) and Rust Analyzer, which is a main focus of the official RLS 2.0 compiler working group.
Igor Matuszewski

Igor Matuszewski

Part of the compiler contributors and dev tools team, working on the developer tooling and IDEs since 2017. A happy Rustacean, always happy to help other people be more productive and to share knowledge and excitement about Rust (and obviously its tooling!).
Haven't done any Rust? No problem! In this workshop, you'll learn the basics of Rust and what makes it special so that you'll have context for the rest of the conference.
Jake Goulding

Jake Goulding

Jake Goulding started his career writing performance-minded C code before pivoting to web applications in Ruby on Rails. He is a member of the Rust Infrastructure Team, maintainer of the Rust Playground, and manages several Rust crates in the areas of error handling, parsing, XML, hashing, and assembly intrinsics. He is a participant in the effort to port Rust to the AVR architecture and creator of The Rust FFI Omnibus. He may be best known for being the #1 contributor on the Rust tag on Stack Overflow.
Discuss the what to do, what not to do, and the “we’re still not sure if this is a good idea” parts of using Rust in an existing code base that is both resource-constrained and littered with history. Specific topics will include building Rust projects inside the bitbake build system, as well as balancing different deployment methods against code size constraints.
Steven Walter

Steven Walter

Professionally, Steven Walter is a senior firmware engineer at Lexmark International, helping to create the code that drives high-end laser printers and copiers. He has worked on the firmware build team, network and security teams, and several years on the kernel team. Outside of work, he is an avid private pilot and retro-computing enthusiast, with particular interest in the Commodore 64.
Lightning talks are 5 minutes long, on any topic, by anyone. Come by registration anytime on Saturday to propose a lightning talk. Proposing is not a commitment to talk, but a variety of ideas will help us think of more and choose a set that sound really interesting. Also stop by to vote for which talk ideas you are excited to hear. We’ll put together the official schedule after the break on Saturday morning and hear the talks after lunch.
Maybe You?!

Maybe You?!

Lightning talk speakers come from all over the world to present for 5 minutes on a topic of their choosing!

Nature has beautiful forms: from the crescent waves on the ocean to the beautiful wings of certain butterflies; from the stripes and spots of animals to the branching and weaving of plants and trees.

All these patterns seem intricate and complex. Often they can be modeled in a simple and effective way. Sometimes this model lets you learn something about nature.

In this workshop, we will explore Lindenmayer systems, or L-systems. These systems allow you to model various natural forms such as plants, trees and certain algae. Furthermore, it offers a playground for certain type of fractals. We will not only play with L-systems, we will also learn techniques for expressing and rendering them. It is these techniques that will transit from the pleasant playground of the workshop into the toolbelt of the participant.

So come and learn how to model your favourite forms of nature.

Daan van Berkel

Daan van Berkel

Phil and Daan met each other at the very first Rust Belt Rust conference. Seeking each other’s company to discuss a wide variety of topics, ranging from art, philosophy, software systems, politics and the best way to prepare a burger. Enjoying the dynamic and sharing their love for Rust and the Rust Belt Rust conference, Phil and Daan sought a topic to explore at this Rust Belt Rust installment. They found it in the marvelous subject of Lindenmayer systems.

Phil Fried

In this workshop, you will implement Ferrisp, a MAL inspired Lisp, and learn Rust's basic syntax, programming patterns, and toolchain features in the process. From lexing, to abstract syntax trees, and function calling, you will also learn what details go into constructing a naive but functioning programming language. This workshop is “ambitiously introductory”, and is thus aimed at anyone with a general background programming but not necessarily Rust nor computer science fundamentals. The workshop format will consist modules where requirements are outlined for each new feature to be implemented for Ferrisp, along with live coding and discussing our way through solution details.
Elias Garcia

Elias Garcia

Rust 2018 brought with it “non-lexical lifetimes” (NLL), a big overhaul of how the borrow checker worked that allowed it to accept a lot more programs. And yet, we’re still not accepting the full range of programs that was envisioned by the original NLL RFC – this is both for performance reasons and because the formulation didn’t turn out to be as flexible as originally thought.

Polonius is a “reframing” of Rust’s borrow checker. It works quite differently than the original system. Rather than tracking how long each reference is used (its “lifetime”), it tracks where each reference may have come from (its “origin”) – and it does so in a very fine-grained way. As a result, Polonius is able to accept all the programs that the NLL RFC envisioned, and a few more! We also believe it can be made more performant (though that has yet to be fully proven out).

This talk will explain how Polonius works in a simple and example-driven style. It will help you to gain a deeper understanding of how Rust’s borrow checker works internally.

Nicholas Matsakis

Nicholas Matsakis

Nicholas Matsakis is a Principal Researcher at Mozilla Research and a member of the Rust core, compiler, and language design teams. He has been working on Rust since 2011 and did much of the initial work on its type system and other core features.
I will be presenting Fin, a non-trivial web server. In the process of creating Fin, I have had to think about and solve many common challenges one would face when writing a web application or even a general Rust program. A few of the topics include database testing, hardening SQL queries, auth, module isolation, error handling, logging, and more.
Apoorv Kothari

Apoorv Kothari

Apoorv is a software engineer who is interested in building resilient and highly scalable solutions. I have worked with a multitude of tools and languages, but I prefer to work with strongly typed and statically complied languages. To this end my languages of choice are Rust and Scala for building scalable backends.

Rust really hits a sweet spot with respect to programming languages on account of a) its usefulness when working at a low level, coupled with b) its style of type system. Because of a), Rust can be — and is — used in places which tend to safety-critical: cyber-physical systems, autonomous vehicle infrastructure, robotics, etc. When building systems for these safety-critical environments, one also often formally proves properties about their software. That’s where b) comes in.

Rust’s type system is borne from the same ilk as those used in proof assistants like Agda, Coq, or Lean. Because of this, we can use Rust’s type system in similar ways we’d use a proof assistant to produce safer and more correct programs. This is envisioned by reducing the language of these disparate systems into the lingua franca of type theory.

This talk will explore using (and abusing) Rust’s type system to mimic the proofs one writes about their Rust programs while also enumerating how this mimicry is derived from common ground in the worlds of types or categories.

dan pittman

dan pittman

I’m a curious exister, a dad and a husband who currently programs computers for a living for Auxon in Portland, OR.
The unconference is a unstructured place with tables, chairs, power outlets, sticky notes, fellow Rustaceans - and whatever you bring to it. It's another place to be during workshop day when you need to continue that fascinating conversation you've been having, work on some code with someone you just met, play a board game, or just sit down for a second.
Jean Lange

Jean Lange

Jean Lange is really super into: smiling, learning about humans, enjoying the present moment. She likes colors, the daily crossword, and coding in Ruby in Pittsburgh. She teaches at Academy Pittsburgh and LFG Board Game Night, but usually on different subjects.

Have you ever wondered why you can’t look up a character in a string by its index?

    let hello = String::from("world");
    println!("{}", hello[0]);
                   ^^^^^^^^ `std::string::String` cannot be indexed by `{integer}`

Or why the length of a String can be wildly different from the number of characters in the string?

    let rust = String::from("錆");
    println!("{}", rust.len()); => 3
    println!("{}", rust.chars().count()); => 1

In this talk we’ll dive into unicode by looking at how Kanji is represented in Rust. You’ll learn about things like the Han unification, the origins of CJK languages from Oracle bone script, and why Rust handles Strings differently than we expect.

Rust and Wasm are a perfect pair, especially now that projects like Wasmer exist. Let’s leverage this relationship to build a plugin system using Rust that is compiled to Wasm. In this session, we will cover how you can compile your Rust programs to WebAssembly, how to run that WebAssembly code in another Rust program, and finally how to use procedural macros to streamline this process.
Robert Masen

Robert Masen

Robert is a software developer currently living in Minneapolis. When not writing code, he is either taking pictures of his dog, knitting, or woodworking.