Our Program

Closing Keynote

By Julia Evans

Do you ever think “Ok, I'm definitely not a beginner at programming anymore, but how do I get WAY BETTER?” I have. It turns out that there are a lot of amazing things you can learn about programming by learning a little bit of Rust and systems programming, and I'm going to talk about some of my favorites.


Opening Keynote

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

Training: Intermediate Rust

Move up a level in Rust knowledge. This tutorial introduces the second key piece of Rust, its trait system. It 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. It also covers how to write threaded programs in Rust, and shows how threaded programming in Rust builds on the trait system to guarantee data-race freedom.

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


Opening Keynote

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

Training: Advanced Rust

Start taking full advantage of the power of lifetimes. This tutorial will cover named lifetime parameters on functions and structs and show how you can write more advanced patterns of borrowing in Rust.

Prior experience with Rust is expected, and this training is not appropriate for pairing with the morning Beginner Rust training.


Integrating Some Rust in VLC Media Player

By Geoffroy Couprie

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?


Back to the Futures

By Alex Crichton

One of the core building blocks of any library is the I/O abstraction it works with, but unfortunately they isn't always composable to plug libraries together. The concept of futures is tried and true in frameworks like Scala's Finagle, and provides an ergonomic solution to composing multiple I/O libraries together. This talk will explore the implementation of a cross-platform futures library in Rust backed by the full power of mio and leveraging many aspects of Rust to make futures programming even easier.


The /r/playrust Classifier: Real World Rust Data Science

By Suchin Gururangan

Modern machine learning systems require scalable, real-time processing to analyze massive datasets. Rust is an attractive tool to help drive low-cost, high performance data science. But what's it like to use Rust to solve machine learning problems in practice?

To evaluate Rust as a foundation for machine learning services, we built a classification system, entirely in Rust, that detects /r/playrust posts mistakenly published on the Rust subreddit. We'll present Rust's strengths and weaknesses at each step of the process, inspiring discussion on its role in the future of data science pipelines.

This is a two-speaker talk, also delivered by Colin O'Brien.


RFC: In Order to Form a More Perfect `union`

By Josh Triplett

Users of Rust for systems programming rely heavily on its exceptional support for FFI. Many systems APIs involve unions, and macros and transmute produced unmaintainable solutions. 16 months, 3 RFCs, and a half-dozen possible syntaxes later, RFC1444 added union to the Rust language, ready for implementation.

This talk will present unions as a case study of the Rust RFC process, show the kinds of iterative refinements that take place, review corner cases and interactions that arise when attempting to extend Rust, and discuss the next steps forward for union implementation.


The Illustrated Adventure Survival Guide for New Rustaceans

By Liz Baillie

Programming is an adventure, often more harrowing than it has to be. If you're more used to higher-level languages like Ruby or JavaScript, learning Rust can feel like an impossible journey that leaves you wishing for a well-written and heavily illustrated field guide.

Good news! I have already gone down this road and am now prepared to share my adventure with you. Luckily, I was able to capture much of the flora and fauna of Rustlandia with my primitive pictorial devices (paper and pen).


A Modern Editor Built in Rust

By Raph Levien

This talk will present XIeditor, a new project to build a high-performance text editor primarily in Rust. In addition to a deep dive into technical details, the talk will touch on aspects of building polished GUI apps and running a community-focused open source project.


Using Generics Effectively

By Without Boats

Traits and type parameters are the core mechanism for abstraction in Rust. Other languages also have features like these, but few leverage them nearly as much as Rust does. This talk will describe the many powerful uses for Rust's generics system, how generics can be used as a replacement for tools like inheritance and duck typing, and how to leverage this system to write good, clean code.


The /r/playrust Classifier: Real World Rust Data Science

By Colin O'Brien

Modern machine learning systems require scalable, real-time processing to analyze massive datasets. Rust is an attractive tool to help drive low-cost, high performance data science. But what's it like to use Rust to solve machine learning problems in practice?

To evaluate Rust as a foundation for machine learning services, we built a classification system, entirely in Rust, that detects /r/playrust posts mistakenly published on the Rust subreddit. We'll present Rust's strengths and weaknesses at each step of the process, inspiring discussion on its role in the future of data science pipelines.

This is a two-speaker talk, also delivered by Suchin Gururangan.


Training: Rust for Beginners

By Steve Klabnik

Learn everything you need to get started writing Rust programs. The tutorial puts a focus on Ownership and Borrowing, which are the key techniques that Rust uses to achieve both safety and low-level performance.

This class assumes no prior knowledge of Rust, though programming experience in some other language would be helpful.