We have 16 talks this year, split into two tracks. The precise schedule can be found on the schedule page.

Our Program

Aaron Ashley Niko

Opening Keynote

By Aaron Turon , Ashley Williams , Niko Matsakis

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


Catherine

Closing Keynote

By Catherine West

When you’re just starting out in Rust, you start by building small programs. As we all know though, medium and large projects can have very different, unique kinds of problems that smaller projects never encounter. As our projects grow in size, we need to be increasingly concerned about code organization, separation of concerns, implementation hiding, and other techniques to manage growing complexity.

Most languages have tools and patterns to deal with this, and Rust is no exception. However, the patterns that we learned from other languages, especially in mainstream OO languages, are often unhelpful when applied to Rust, and this can lead to a roadblock when trying to transition to building moderate or large Rust programs.

This talk will cover a case study of a moderate sized game engine written in Rust and Lua, and show strategies for implementing things in Rust where common implementations in other mainstream languages are a poor fit. I’ll also discuss some examples of problems unique to Rust that ended up with very nice —but sometimes not obvious— solutions.

Along the way, I’d also like to discuss working with Rust in game development generally, and what it’s like getting Rust to run on mainstream game consoles.


Isis Chelsea

Integrating Rust into Tor: Successes and Challenges

By Isis Lovecruft , Chelsea Komlo

In 2016, The Tor Project's network team decided to experiment with writing existing and new functionality in Rust. Since then, this experiment has turned into a team initiative, with multiple team members adding infrastructure and new functionality with the goal of integrating Rust components directly into the core Tor code base. By 2019, we will have several features tha will be only supported in Rust.

With this effort has come many challenges and questions, some which have remained unresolved. In this talk, we propose walking through this timeline, and sharing what we have learned, what was good, and what was challenging about integrating Rust into a 10+ year old security-critical C codebase. We will also offer ideas about what could make this easier going forward, and what we are excited and hoping to see in future Rust versions. Overall, we at The Tor Project are big fans of Rust. We are looking forward to sharing what we have learned and accomplished over the last two years.


Ryanplauche

Space, The Rusty Frontier

By Ryan Plauche

Space. It is often thought of as the final frontier for humans. Why not also for Rust?

In the fall of 2017 we began using Rust on an upcoming CubeSat mission. Writing safe, performant software is a high priority for us, one shared by the aerospace industry. Our software framework was originally written in C but we wanted to explore other options which could give us more confidence in our code and allow us to leverage newer technologies. For us Rust fits the bill with its emphasis on safety, growing community, and high level software patterns.

This presentation will cover the finer points of why we settled on Rust, how we integrated Rust into our existing C environment, how Rust has affected our developer productivity, pictures of the (first?) spacecraft running Rust in low Earth orbit and thoughts on the future of Rust in Space.


Sunjay

Writing Crates for Complete Beginners - A Tour of Turtle

By Sunjay Varma

Turtle is a Rust graphics crate for creating animated drawings. It is designed to be used to teach programming to complete beginners using Rust. In this talk, you'll learn the inner workings of turtle. We'll show you how we managed to create a library that is both full of features and very easy to learn. We'll go deep into how turtle works and tell you the key aspects of creating a crate that is accessible for anyone of any skill level. You'll leave with new ideas for your own crates and a good understanding of what went into making turtle so beginner friendly.


Jamesmunns

Getting Something for Nothing

By James Munns

This talk explores how to use the Rust Type System and Borrow Checker to write safe abstractions of hardware, even when using direct control of memory mapped peripherals with unsafe blocks. Because these techniques move all (or most) of the checking to compile time, these techniques are perfect for systems where high performance or resource constraints are a requirement.

This talk will explain and explore how these techniques are used on Microcontroller systems as a critical part of the embedded-hal ecosystem.


Douglascampos

How to (not) introduce Rust at your workplace - a tale

By Douglas Campos

So I've tried to introduce Rust at my $DAYJOB, and failed miserably.

Failure can be a great catalyst for reflection, and indeed, there was a lot of valuable lessons to be learned!

At this brief talk, I'll not only share the pitfalls to avoid, but the insights I've gained while trying to make Rust work for us (and maybe for you?).


Katharina

Embedding Rust in C/C++

By Katharina

We all know that using C/C++ code in Rust is not too complicated. extern "C", bindgen and build.rs scripts make this pretty easy. But let’s challenge ourselves: what about the other way around? There are huge C and C++ projects that could use some corrosion.

In this talk I will not just show simple examples of how to use Rust modules inside larger C/C++ applications, the common pitfalls you will encounter, and to deal with them.


Paulmason

Benchmarking and Optimization of Rust Libraries

By Paul Mason

As we develop the Rust eco-system we have a goal that "Rust should provide easy access to high quality crates". This means libraries must be both ergonomic and perform well. Rust provides various frameworks to help benchmark libraries however achieving performance past a certain point requires knowledge of some deep language constructs.

This talk explores a journey towards benchmarking various library functions consistently and fairly and consequently exploring strategies for optimizing performance.


Sarahmeyer

Rust and the Web Platform: A Rookie’s Guide

By Sarah Meyer

Coming Soon!


Misdreavus

The Dark Secrets Lurking Inside cargo doc

By Quiet Misdreavus

Every Rustacean reads the standard library docs (or some other library docs) sooner or later. Many Rustaceans have run cargo doc to generate some documentation for their own library or their dependencies. But how many have looked at the tool behind cargo doc? In this talk, I'll divulge some hidden secrets of rustdoc, the tool used by cargo doc to generate documentation.


Shaquille

Reddit & Rust

By Shaquille Johnson

Reddit recently rewrote its markdown parser from C into Rust. We did this because maintaining this security-critical component in memory-unsafe C was too difficult - at one point we had a feature in security review for a year, and that's not acceptable.

This talk describes my experience with Rust, walking through the many libraries that we tried, which ones we decided to go forward with, which ones we didn’t, and how we coordinated our internal team with upstream crate authors.


Quodlibetor

The Opposite of Spaghetti Code: Building for Understanding

By Brandon W Maister

Every moderately sized project is both a library and a consumer. Rust has an almost dizzying array of features that can be used to add structure and hide information.

In this talk we'll discuss using types, traits, modules and crates as the tools of encapsulation. To show how they work together to effectively superseed similar information-hiding tools in procedural and OO languages we'll grow a simple type into a collection of language objects. We'll discuss the thought processes that go into deciding to add a layer of abstraction, and how to use each layer to maximum effect.


Lambdafairy

My Little Procedural Macro

By Chris Wong

What if Handlebars was a macro?

Three years, 376 commits, and countless breaking changes later, I may have an answer to that.

Maud is a macro for writing HTML web pages. It's like format!(), but for markup instead of text. This design lets it catch typos at compile-time, as well as run blazingly fast.

This talk will cover lessons I learned while working on Maud, including: tips on designing a macro's syntax, some common pitfalls with the procedural macro system, and dealing with Nightly Rust. There will also be a pony.


Fluffyemily

Project Mentat: an evolving data store in Rust

By Emily Toop

Coming Soon!


Siddontang

Using Raft in Rust

By Siddon Tang

The Raft consensus algorithm has been widely adopted in many companies to build a consistent distributed services that are highly available. This topic is about how we implemented Raft in rust to support TiKV, an open-Source distributed transactional Key-Value store. In this topic, I will first give a brief introduction about Raft, and then talk about our Raft implementation in Rust, and in the end, I will show you how to use Raft in Rust to build a simple distributed Key-Value database.