Home | Location | Schedule | Speakers

Our Program

A huge thank you to everyone who submitted a proposal during our Call for Papers! The responses were top notch.

8:30–9:45am Registration
9:45–10:00am Welcome & Announcements
10:00–10:30am Keynote Aaron Turon and Niko Matsakis
Video | Slides
10:45–11:15am Who Owns This Stream of Data? Alexis Beingessner
Video | Slides
11:30–12:00pm Learning Systems Programming with Rust Matt Cox
12:00–1:30pm Lunch
1:30–2:00pm Rust in Production Jonathan Reem and Paige Peterson
Video A | Video B | Slides A | Slides B
2:15–2:45pm Graphite-Rust Xavier Lange
3:00–3:30pm Navigating the Open Seas Carol (Nichols || Goulding)
Video | Notes
3:30–4:00pm Stretch Your Legs!
4:00–4:30pm Writing High Performance Async IO Apps Carl Lerche
Video | Slides
4:45–5:15pm Using Rust from C... or Any Language Yehuda Katz
Video | Slides
5:30–6:00pm Making Tools for Rust Nick Cameron
Video | Slides

Program Details

Listed in order of time slot.

Who Owns This Stream of Data?
Groking Iterators and Ownership

by Alex Beingessner

Rust exposes a lot of ways to traverse a collection: iter, iter_mut, into_iter, and drain to name a few! This isn't a case of over-engineering: each of these kinds of iterator necessarily falls out of Rust caring about ownership, and encoding it in the type system. However even all these iterators still aren't enough to capture all the subtleties of ownership and traversal!

This talk surveys the advantages, weaknesses, and motivation of the current iterator APIs, as well as hypothetical future iterator APIs that could complete our iteration story such as Cursor and MutexIterator.

Learning Systems Programming with Rust

by Matt Cox

Many new Rustaceans dive in with experience almost exclusively in a higher level, GC'd language. To them, terminology from systems programming can be overwhelming and cryptic...but it doesn't have to be! With side-by-side Rust, Ruby, and Python examples, we can dive into the world of pointers, heaps, and stacks that will let you reason better about your programs, no matter what language you are using!

Rust in Production

by Paige Peterson and Jonathan Reem

Rust is new, but it's not that new! We'll hear from two folks using Rust in Production, with their teams and companies behind them. They'll tell us about some of the struggles, the triumphs, and how they made the decisions that led them where they are.

A Fast Time Series Database Implementation

by Xavier Lange

Time series databases are the backbone of metrics gathering in large computer systems. The most popular service is a difficult to understand and suboptimal implementation done in Python. Rust's strong typing, safe data reuse, standardized build tool, and easy integration with performance tools have made it possible to build a high performance replacement.

This talk will cover the rearchitecture of the popular graphite metric system redone entirely in Rust and currently used in production. This is not a line-for-line rewrite but it is compatible with the wire protocol and disk format.

Navigating the Open Seas

by Carol (Nichols || Goulding)

A new language being born is a fairly rare occurrence—a new language being born with the reasoning behind all the decisions documented in the open is even more so. Learn techniques to help you explore the treasures in git, GitHub, Discourse, and IRC. Take a half hour tour through some defining moments in Rust development history—for instance, the core language used to have a garbage collector!

Become a better Rust user and contributor by using these open artifacts. After all, programming is not about knowing all the answers but knowing how to find the answers.

Writing High Performance Async IO Applications with Rust

by Carl Lerche

The talk covers how to use MIO (a lightweight non-blocking IO event loop in Rust) to write fast IO applications with Rust. It will introduce MIO's network & timeout APIs and show how to use them to create a network server. The talk will then discuss some strategies for using MIO in a multithreaded environment.

Using Rust from C... or Any Language

by Yehuda Katz

One of the best things about Rust is how easy it is to integrate Rust with applications or libraries written in C. But while Rust provides all of the tools you need to get the job done, getting started with the FFI APIs can be tricky. To make matters worse, this kind of Rust programming is full of unsafe code.

In this talk, I will cover the basics of using Rust from C (and vice versa), based on over a year of writing production Rust code that makes heavy use of FFI bindings.

Making Tools for Rust:
An Introduction to the Compiler
and How It Can Help You

by Nick Cameron

The compiler knows a lot about your programs. That knowledge can let you build sophisticated tools for analysing and mutating code.

I'll give a basic overview of the architecture of the compiler and the phases of compilation. I'll cover some of the APIs you can use to get at the results of program analysis. I'll show how tools for cross-referencing, refactoring, and reformatting work with the compiler, and I'll work through a simple tool in detail. By the end of the talk, you should know what the compuler does and be able to start writing your own tools based on the compiler's analyses.