Rust Belt Rust Conference


View videos of all recorded talks

Day 1: Workshops (8 Tracks)

Welcome & Announcements

Introduction to the Community

When we come together and meet it is a time to share ideas and knowledge. All of us brings their stories from their respective backgrounds.

Let's take half an hour and open the floor. Encourage people to introduce themselves to their community here, at our conference and as part of the ecosystem. People are encouraged to introduce themselves, at their option, and talk about their work they're doing in the community. We ask people limit themselves to just a couple sentences.

This allows all conference participants to not only feel like they are welcomes guests among a diverse group, but also participants in our discussion. Conference are most valuable for creating connections, and many of us have come here looking for answers or new knowledge. Saying hello is the first step in that conversation.

Speaker: Andrew Hobden (@andrewhobden)

A recent CS graduate, I am seeking to find and help encourage meaningful work within our lives. My interests are primarily in distributed systems and networking, but I'm always eager to try new things.

Rust and Other Languages Track (full day)

Rust Side Story: If Lets vs the ARCs

Dive into the whimsical world of Rust Side Story, a tragic love story set in the dark world of modern programming languages. Witness as our two star-crossed lovers, Jake Goulding (a Rustacean) and Chris Luu (a Swift), discover that their differences are only syntax-deep, but their sames go down to their LLVM-based bones. Revel in the musical masterpiece that brought us such wonderful songs as "When You're In Rust", "I Feel Swifty", and more that I haven't even thought up yet! Explore subjects like memory management, conditional binding, REPLs and other such interesting topics. Break out your trusty laptop for some code-alongs as we tackle sample projects to compare and contrast doing these the Rusty way and the Swifty way. "Code in Rust and it's almost like praying."

Speaker: Christopher Luu (@nuudles)

Christopher Luu is a *gasp* Swift developer who has dabbled in the dark arts of Rustaceanography. After serving as CTO for a few years at a Brooklyn-based digital agency that focused on mobile apps, he has now joined the pirate's life of freelancing while embracing the chance to play around in this crazy new age of programming languages.

Hey! There’s OCaml In My Rust!

OCaml is a language that has seen what few languages have seen-- a resurgence. Several recent tools and language compilers have been built using OCaml, and Rust’s original compiler rustboot can be counted among these many excellent projects. Did you know that OCaml and ML’s influence on Rust reaches beyond that first compiler? Absolutely! The influence of OCaml and ML can be seen in Rust’s language features, syntax, and more. This talk will take a brief look at OCaml and Rust’s history. We’ll also investigate how OCaml and ML has and continues to influence Rust’s development by comparing and contrasting code samples, looking at past design discussions, and more.

Speaker: Kel Cecil (@praisechaos)

Kel Cecil is a polyglot software engineer at in Morgantown, WV that writes Java and Go during the day and whatever he pleases in the evening. If you happen to catch him when he’s not programming, he’ll be playing video games, tinkering with arcade hardware, or fussing over his apple trees. He infrequently blogs at and frequently tweets @praisechaos.

Hire me for the JS, keep me for the Rust

Browsers speak JavaScript. So you need to use it for your next web page project. But what if JavaScript is not the right tool for the job? What if Rust fits your use case much better?

We can use Rust in places you wouldn't expect it to be used. And one of these is in the frontend of your web application. In this talk I will show you how to do that and what's possible.

A not-all-too-serious look beyond the tellerrand, on Rust and how it can help to take a look at other things from time to time.

Speaker: Jan-Erik Rediger (@badboy_)

Jan-Erik is a student of Computer Science, living in Aachen, Germany. When he's not studying, he's either travelling the world or helps with some open source projects like Redis, learns new programming languages or coaches at the OpenTechSchool and organizes conferences and meetups.

...And In The Darkness Bind Them: Fluent Rust Bindings for C APIs

One of Rust's biggest advantages is the ease with which authors can use preexisting C libraries in their Rust projects. Unfortunately, doing so forces the author to use the unsafe keyword and introduces the potential for memory safety-related errors. Happily, we can still get the best of both worlds by isolating this unsafety behind idiomatic, high-level Rust APIs!

This talk will introduce the fundamentals of how to write low-level bindings to C APIs, then build on that knowledge to demonstrate techniques for creating high-level Rust APIs that shield the programmer from unsafety. We'll cover everything from representing C types in Rust and managing cross-language memory allocation, to enforcing invariants using types and restricting unsafety with lifetimes. Since these techniques are not restricted to C bindings, attendees will also become familiar with idiomatic API design practices for writing better Rust code in general.

Speaker: Joshua Matthews (@lastontheboat)

Josh is a platform developer at Mozilla. He spends a lot of time looking for ways to make open source projects more accessible to newcomers, and tries to put them into practice for the web rendering engine written in Rust called Servo. His barbershop quartet (the Bearded Baritones) are going to make it big any day now.

Code Retreat (full day)

Intro to Testing and Code Retreat

Code Retreat is an intensive practice event, focusing on the fundamentals of software development and design. Practicing the basic principles of modular and object-oriented design, developers can improve their ability to write code that minimizes the cost of change over time. Testing and TDD are an essential part of the Code Retreat practices-- first we'll learn the basics of testing in Rust. Then we will implement Conway's Game of Life in pairs with a variety of constraints to explore good software design in Rust.

Speaker: Amber Conville (@crebma)

Amber Conville is a developer at Test Double, and has been a software developer for 8 years. She loves code in lots of languages, tdd, craftsmanship, and the software community, and can be found speaking at or helping out with user groups, conferences, and nerd gatherings whenever possible.

Bare metal (full day)

Programming ARM microcontrollers in Rust

Let's explore the bottom of the software stack. There are no threads, processes or files here. But you got Rust on your side. Join me (bring your laptop!) and we'll I/O with the real world.

Microcontrollers will be provided, and because of that, attendance of this workshop is limited! Please make sure to choose this workshop when purchasing a ticket if you would like to attend!

Speaker: Jorge Aparicio (@japaricious)

Jorge has been a Rustacean for over two years. When he's not hacking on some Rust project or writing some guide for the Rust community, he's usually in the kitchen making pickles or trying a new dish. He sometimes spends his entire weekends automating stuff that would otherwise take him a few minutes to do -- only to later realize that, apparently, it was not worth his time.

Testing and Debugging (full day)

How to find bugs while sleeping, an introduction to Fuzz testing with Rust

This talk is an introduction to fuzz testing Rust code. Fuzz testing is a software testing technique used to find security and stability issues by providing pseudo-random data as input to the software. This talk will be focused on using Rust with American fuzzy lop (AFL), a popular open-source fuzz testing tool.

The talk will begin with a very brief summary of what fuzz testing is and how it relates to other forms of software testing. Then, we'll introduce AFL and describe (from a high level) how it works and some of its main features. After that, we'll demonstrate how to use AFL with Rust and some best practices. To conclude, we'll see some examples of how it has made Servo, the Rust compiler, and various other Rust libraries more robust and secure.

Speaker: Corey Farwell (@frewsxcv)

Corey Farwell is a software developer from New York City. He is the maintainer for the Rust AFL bindings and also frequent contributor to Servo, the Rust compiler, and various other Rust projects. Outside of Rust, Corey mostly programs in Python and JavaScript doing full-stack web development.

Property-Based Testing with QuickCheck

In the old days, one would have to manually write tests and execute them. Modern testing involves manually writing tests, but the computer executes them. What if we could hop up another layer of automation and have the computer write our tests for us? With property-based testing, that dream is a reality. By defining properties of input and output, we can have the computer itself create and execute hundreds - or thousands, or millions - of tests, and perhaps find edge cases which would never have been found with traditional unit testing.

QuickCheck is a popular tool for performing property-based testing. Originally developed for Haskell, there are now ports for many languages, including Rust. In this talk, I will go over the benefits and drawbacks of property-based testing, how it can be used to quickly find failure modes of functions, and how to incorporate QuickCheck into your projects and testing strategy.

Speaker: Bill Laboon (@BillLaboon)

Bill Laboon lasted fifteen years in the software development industry, working as a developer, quality analyst, tech lead, and manager, before fleeing back to academia. Currently a Visiting Lecturer in the Computer Science department of the University of Pittsburgh, his courses focus on inculcating an understanding and love of modern software development practices. He is the author of book, A Friendly Introduction to Software Testing. He has also successfully written a shell script while under small arms fire.

War Stories from Debugging Rust

Developing a cross-platform language and standard library that runs in dozens of environments inevitably leads to some incredibly difficult bugs to find and fix. This talk will do a deep dive into a few of these situations to highlight some amusing bugs with annoyingly simple fixes that have historically been found in the standard library and compiler. Along the way you might learn some new techniques on how to debug Rust code, discover some disturbingly creepy corners of the standard library, or just enjoy how days of someone's life can culminate in less than 10 characters of changes!

Speaker: Alex Crichton (@alex_crichton)

Alex is a member of the Rust Core team, leader of the Rust Tooling team, member of the Rust Libs team, and primary maintainer of Cargo working at Mozilla full-time on Rust since late 2013. He's worked on many modules in the standard library like the old green runtime, the newer native runtime, channels, I/O, OS bindings, and the facade libcore refactoring. Over the years he's encountered quite a wide variety of problems spanning from spurious core dumps, mysterious linker errors, and LLVM miscompiles and can't wait to share them with others!

How I learned to stop fixing bugs (over and over again)

A short design phase, a development phase with a focus on the quantity of implemented features, and a missing testing phase are major software engineering reasons for software failures after deployment. The automation, aerospace and automotive industries have tackled this through minimizing the number of features, the heavy use of modeling in the extended design phase, code reviews, and static analysis. But both of these extremes of software engineering processes have one thing in common: When a bug is fixed, the most that is learned from it is a regression test that prevents this one specific bug from occurring again. Similar bugs in completely unrelated pieces of code or even distinct projects will keep reappearing. Over years of experiencing with recurring bugs, software engineers develop best practices, static analysis tools, or even completely new languages. But this process is slow and will rarely benefit the projects in which the bugs originally were found. This talk presents a new part of the software engineering process where developers stop finding and fixing recurring bugs and instead outsource this to the compiler. Instead, when a bug is found, it is analyzed for various factors and depending on the result of that analysis, a new static analysis is added to the project that finds this kind of bug. When running the new static analysis, the bug and potentially other similar ones are flagged and can then be fixed either automatically or with developer intervention.

Speaker: Oliver Schneider

Oliver Schneider, born 1988 in the Black Forest, started "programming" in 3rd grade. He lived in Pennsylvania from 2003-2005, obtained his High School Diploma from Conestoga High School and went back to Karlsruhe, Germany to begin his Computer Science studies at KIT. He finished his University Diploma in 2013 and is currently writing his PhD on the topic of static analyses and practical use of software modeling.

Operating Systems (full day)

Introduction to operating systems

Have you ever wondered how operating systems work? In this session, Steve and Ashley will teach you how. No previous experience is required. We'll be working with intermezzOS, a learning kernel for the x86_64 platform, written in Rust (and some assembly code!) What we'll cover:

  • Some basics of hardware and how it works
  • basic assembly language programming
  • "boot to kmain", all of the setup stuff needed before you can even write your kernel
  • printing to the screen
  • keyboard input and interrupts
  • Maybe more!

Speaker: Steve Klabnik (@steveklabnik)

Steve Klabnik is a Rust core team member, prolific open source contributor, and author of “The Rust Programming Language”, “Rails 4 in Action”, and “Designing Hypermedia APIs”. He lives in Brooklyn, and spends far too much time on GitHub.

Speaker: Ashley Williams (@ag_dubs)

Ashley is a developer community and content manager for npm Inc. as well as an engineer, educator, and organizer of Node Together and part of the Node.js board of directors.

Introduction to Rust (half day, morning)

Fearless systems programming for the modern developer

Ben Striegel leads an active, hands-on introduction to Rust, a new systems programming language from Mozilla that emphasizes guaranteed memory safety (no segfaults!), fearless concurrency (no data races!), and lightning-fast, zero-overhead execution (no garbage collector!). Ben explains Rust's novel characteristics and demonstrates how you can put them to work in your own projects.

Speaker: Ben Striegel (@bstrie)

Ben Striegel is one of the earliest members of the Rust community, having stumbled across the language in 2011, and has been an active contributor to the project ever since. Today, Ben is a member of Rust’s official community outreach team and focuses on teaching and mentoring newcomers and interfacing with other open source communities.

Intermediate Rust (half day, morning)

Traits and Threads

This interactive tutorial will cover two of the most interesting bits of Rust: its trait system and its threading model.

Part one shows how the trait system is the foundation for generic programming in Rust, allowing you to write one piece of code that can be reused in many contexts. While its easy to get started with traits in Rust, there is near endless depth to the system and the powerful things you can do with it. We'll cover how to use traits to trade off between static and dynamic dispatch, and how to glue together upstream libraries using new traits that you define.

Part two covers the basics of concurrent programming in Rust: threads, channels, locks, and sharing. Concurrency is one of the places where Rust's ownership model most shines, and the tutorial is chock full of examples connecting these dots. It also ties in with traits, which play a key role in ensuring data-race freedom in Rust -- one of the key values Rusts delivers for concurrent code.

The tutorial assumes basic understanding of ownership and borrowing; if you have been writing Rust for a while, or taken a basic Rust tutorial, you should do fine.

Speaker: Aaron Turon

Aaron Turon is Research Engineering Manager for the Rust team at Mozilla. He received his PhD from Northeastern University, where he studied programming language design, program verification, and low-level concurrency. His dissertation received the SIGPLAN John C. Reynolds Doctoral Dissertation Award in 2014. After his PhD studies, he continued his research in concurrency verification and programming techniques as a postdoc at MPI-SWS. He's been at Mozilla for the two years since then, happily being part of the worldwide Rust community from his corner in San Francisco.

Code Design (half day, morning)

Creating Better Interfaces in Rust

Rust has a powerful type system, but do you know how to create good interfaces with those types? Rust's ownership model can make it challenging to translate how a program works in your mental model to syntax that satisfies the Rust compiler. We do not need to contort our interfaces in order to satisfy the compiler. I will introduce some strategies for working with the DST/slice pattern using the Into trait and Cow enum. I will also show how lifetimes can be leveraged to create safer interfaces for resource access.

Speaker: Herman J. Radtke III (@hermanradtke)

I am a sociologist turned full stack engineer turned VP of Engineering at | HauteLook in downtown Los Angeles. At one point, I designed and built most of the hypermedia API that drives the | HauteLook website and mobile applications. I write PHP during the day at work and am a Rustacean at night. I spent a past life writing a lot of C and used that knowledge to help maintain the pecl/memcache and pecl/gearman extensions. I find myself with a renewed interest in systems programming, especially async IO. I also organize the Rust Log Angeles Meetup.

Outside of technology, I enjoy homebrewing, hiking, camping and reading.

Async (half day, afternoon)

The State of Asynchronous Input and Output

Rust's standard library provides various ways to interact with the outside world, but as of now these methods are all synchronous. A program based on them typically needs a separate thread for each active connection, and threads come at a cost -- not only in terms of the computational resources they consume but also in terms of the cognitive overhead they introduce. Often connection handlers need access to some sort of shared mutable state; if they are all on separate threads then synchronizing that state can quickly become a complicated and error-prone business.

The promise of asynchronous I/O is that, by allowing a single thread to handle multiple connections at a time, it can provide a foundation for more-efficient and easier-to-reason-about programs. The problem we have today is that there is no consensus about the best way to do asynchronous I/O in Rust. The purpose of this talk is to survey the progress that has been made so far. We will explore the emerging ecosystem of asynchronous libraries that have been published on, comparing the diverse high-level abstractions that have been proposed. How well do these abstractions compose with each other? How well do they encapsulate the different low-level primitives offered by the underlying operating systems -- primitives which sometimes need to be accessed but are are often hilariously incompatible between platforms? Is there a one-size-fits all solution? Will Rust's rumored upcoming "async/await" feature solve all of our problems? I don't have all the answers, but I hope to convince you that these are questions worth asking.

Speaker: David Renshaw (@dwrensha)

David is author of the Rust implementation of Cap'n Proto, a fast data interchange format and distributed object-capability system. He resides in Pittsburgh and works on Sandstorm, a platform for personal web apps that depends on Cap'n Proto to orchestrate fine-grained container sandboxes.

Asynchronous IO in Rust

This is a workshop about tokio, an emerging standard for asynchronous IO in Rust. The session will start from learning futures, which are the basis for tokio. We'll learn how futures work and how to use combinators on them. Then we'll write a simple protocol using tokio. And finally, I'll explain how futures work internally and how to implement the Future trait for your own thing.

Speaker: Paul Colomiets (@PaulColomiets)

I have coded in python for 10 years. I'm now coding mostly in Rust. I'm obsessive about asynchronous code and microservice-based architecture. For my day job, I'm building containerization and orchestration systems for

Databases (half day, afternoon)

Building a distributed database in 3 hours with Rust

Convergent replicated data types (CRDTs) are a new strategy for representing eventually consistent data. This talk will introduce CRDTs and show how to build a simple distributed database from scratch using Rust. You will learn how to build custom data structures with Rust as well as how to use Mio for networking, Lmdb for persistence, and protobufs for serialization.

Speaker: Carl Lerche

Carl is a freelance software engineer and has been writing code since the days of GW-Basic (weren't line numbers fun). He is a former member of the Ruby on Rails Core Team. Currently, he is the author of Mio and contributes to many other OSS projects. When he isn't coding, he enjoys spending countless hours hand planing pieces of wood.

Machine learning (half day, afternoon)

Fly me to the moon: to boldly go where no code has gone before

47 years ago man landed on the moon for the first time. Today is your chance to recreate that historic event. Writing code is soooo 1969, so you will teach a computer to write the control code for the moon lander.

In this workshop you will learn the essentials of genetic programming, the trade-offs and pitfalls of this under appreciated machine learning strategy. You will exercise your newly learned skills on the problem of landing a spacecraft on the moon.

So hop into your command seat and fly me to the moon.

Speaker: Rico Huijbers (@rix0rrr)

Rico and Daan are partners in science. They share a love of code, games and all things fun by exploring strange new worlds, seeking out new languages and new programming paradigms, to boldly go where no code has gone before.

Day 2: Single Track

Main Gathering

Core Team Keynote

Aaron and Niko will deliver an update on the state of all things Rust. You don't want to miss it!

Speaker: Aaron Turon

Aaron Turon is Research Engineering Manager for the Rust team at Mozilla. He received his PhD from Northeastern University, where he studied programming language design, program verification, and low-level concurrency. His dissertation received the SIGPLAN John C. Reynolds Doctoral Dissertation Award in 2014. After his PhD studies, he continued his research in concurrency verification and programming techniques as a postdoc at MPI-SWS. He's been at Mozilla for the two years since then, happily being part of the worldwide Rust community from his corner in San Francisco.

Speaker: Niko Matsakis

Nicholas Matsakis is a senior researcher at Mozilla research and a member of the Rust core team. He has been working on Rust for four years and did much of the initial work on its type system and other core features.

Hello and Welcome - Documentation in the Rust Ecosystem

Documentation is important. It lowers the barrier for newcomers to use and understand libraries. It helps train and prepare new contributors. It opens up avenues of contribution that go beyond writing code. It makes open source more open, and makes libraries better by its existence.

Rust has all the makings of a great ecosystem of well-documented libraries: a high-quality and ever-improving documentation generator ships with the compiler, and the language team leads by example with a strong focus on documentation. Yet the quality and availability of documentation for Rust crates remains spotty, with many crates providing incomplete documentation, or relying on the types they expose to describe their use and function. This talk takes an in-depth look at the state of documentation in the Rust ecosystem today—including how many crates provide easily-located documentation, and how complete that documentation is—and then describes ideas for improvement, including improvements to Rust's documentation-related tools and ideas for crate maintainers to both write better docs themselves and to encourage contributions from others via documentation-focused mentorship.

Speaker: Andrew Brinker (@AndrewBrinker)

Andrew Brinker is a systems engineer at MITRE. In his free time he tinkers on Ruse (a work-in-progress embedded Scheme for Rust), contributes to Rust crates and the Rust website, and blogs about type theory and Rust. He has a Bachelor of Science in Computer Science from California State University San Bernardino, where he graduated in 2015 as Outstanding Undergraduate for the College of Natural Sciences. While at CSUSB he volunteered roughly 1,000 hours as a tutor, co-created a free library of over 200 Computer Science, Computer Engineering, Mathematics, Physics, and Chemistry textbooks, and taught front and back end web development as a teaching and curriculum assistant.

intermezzOS: a teaching operating system

Speaker: Ashley Williams (@ag_dubs)

Ashley is a developer community and content manager for npm Inc. as well as an engineer, educator, and organizer of Node Together and part of the Node.js board of directors.

Building Little Languages with Rust

Languages are an underrated tool for solving engineering problems, in part because creating them has been difficult. Rust's unique combination of features make it an excellent language for writing compilers ranging from the Rust compiler itself to small domain specific languages. This talk will describe the implementation of a compiler for a query language for protocol buffers and how much easier it is to write one in Rust compared to C.

Speaker: Arcady Goldmints-Orlov

Integrating some Rust in VLC media player

VLC media player has a nice goal for users: handle almost any file or protocol you throw at it. Unfortunately, this results in a lot of parser vulnerabilities, because most of the parsing code is handwritten in C. By leveraging Rust and the nom parser combinators library, could we replace some security critical parts of VLC?

Speaker: Geoffroy Couprie (@gcouprie)

Geoffroy handles security and quality assurance at Clever Cloud, develops in Rust and researches on parser security at VideoLAN. He thinks a lot about cryptography, protocol design and data management.

Unix systems programming made safe and fun!

Systems programming often seems scary. To start with, you need to know C. Debugging obscure pointer issues is hard, and nobody will tell you if you're passing the wrong type of flag to a function. I've been doing a bunch of systems programming in Rust recently, and I've found it a lot easier, more accessible, and more fun.

Speaker: Kamal Marhubi (@kamalmarhubi)

Kamal Marhubi loves programming, systems, and ringing bells.

Lightning Talks

Lightning talks will be 5 minutes long. Slides are optional! Signups will be at the conference, first come first served. If you haven't done or seen lightning talks before, check out this lightning talk of Steve Klabnik's about lightning talks! This is an awesome, low-pressure opportunity to give speaking a try. Some ideas of what to talk about: share a project you've been working on, share your experiences with the community, share an "a-ha!" moment you've had learning Rust, show how to use your favorite crate, share what your local Rust community is up to!

Speaker: YOU!!!

You are an awesome attendee of Rust Belt Rust. There's no qualifications or experience necessary to do a lightning talk!

Rayon: Data Parallelism in Rust

Rayon is a convenient library for adding parallelism into Rust programs. Rayon allows you to easily convert for loops using iterators to run in parallel, as well as recursive functions. Under the covers, Rayon uses work-stealing to dynamically balance your parallel processing, allowing it to scale gracefully to different numbers or processors and a diverse range of workloads. Best of all, thanks to Rust's ownership and borrowing sytem, using Rayon is guaranteed not to add data races to your programs. This talk will summarize how you can use Rayon in your own programs, as well as lifting the covers to show how Rayon itself is implemented.

Speaker: Nicholas Matsakis (@nikomatsakis)

Nicholas Matsakis is a senior researcher at Mozilla research and a member of the Rust core team. He has been working on Rust for four years and did much of the initial work on its type system and other core features.

Category theory meets efficient data structures, thanks Rust!

This talk is about a new distributed version control system written in Rust, based on category theory to define conflicts properly, but nevertheless as fast as even the fastest competitors. Its main distinctive feature is to implement the naive intuition of how distributed version control system should work: a branch in a repository is just an (unordered) set of patches. This makes it really easy to use, which we believe has the potential to help beginners collaborate with others, and get non-programmers use version control for their work. Our tool can also simplifying the workflows of big projects, especially since it handles big codebases faster than others. Moreover, the solid theory means it is easy to understand and predict what it does, which makes it easy to script and reuse in other projects.

While previous systems based on this idea failed to compete in speed with the more widely-used tools out there, we invented a new data structure to efficiently handle asynchronous parallel contributions to a repository. We believe our construction of this datastructure can be reused in other contexts, especially since Rust is really well-suited to parallel computing. This talk will explain the architecture of the software, and what made Rust the best tool for writing it. We'll also talk about a few open problems, both about the theory and the implementation.

Speaker: Pierre-Étienne Meunier (@pijul_org)

Pierre-Étienne Meunier is a computer science researcher at Aalto University, Finland, working on asynchronous computing models. Most of the time, his work involves DNA self-assembly, but also sometimes other real-world asynchronous models such as distributed version control.

See the PDF schedule for times and locations!