RustFest 2017 Talks

Async I/O has forever been a hot topic of discussion in Rust, but over the past year we’ve seen some significant advances in this domain with the futures crate an the Tokio project. We’ll start off by taking a look at where we are today with the async I/O ecosystem in Rust, highlighting a number of the features we’ve added in both the libraries and the language over the past year. We’ll then take a deep dive into Tokio itself, seeing how it capitalizes on some of Rust’s greatest strengths by going Back to Futures and gets our DeLorean up to 88mph.

A whirlwind tour through a (macro_rules 1.0!) macro that interprets everyone’s favorite Turing tarpit, Brainfuck, completely at compile time. I’ll highlight various components such as number encoding, arithmetic, input/output and explain how they work.

This is not a macro tutorial. I’ll cover a few techniques that you might possibly be able to use in real code, such as how to set up a recursive macro with an accumulator, but I’ll be breezing through them to get to the fun stuff, like memory zippers and “Zermelo numbers” (a term I may have invented).

Rust’s type system provides tools to ensure safe memory management, and safe concurrent access to data. What if we used those same tools to encode and enforce other API constraints?

We can leverage affine types (non-Clone structs) to enforce that a user performs a series of operations in a certain order; or we can use structs as tokens representing the user’s ability to perform certain actions. And everything’s checked at compile time.

We’ll see how these techniques let us encode complex API constraints, and make them self-documenting by preventing disallowed behaviour at compile time.

Introducing a working prototype for a minimal actor-oriented system runtime to handle millions of actors and passed messages, across processor cores and even machines. It is written in and used from Rust. Using an additional code-generating build script, type-safe remote message sending and handling is magically desugared from plain Rust function calls and definitions, including dynamic dispatch with traits. This makes it possible to write complex, extensible distributed systems in idiomatic Rust.

Rust is a systems programming language that runs blazingly fast. But what’s its place for writing applications that don’t particularly need to delve into systems programming, and only need to be “not too slow”? Can it be appealing to programmers who would rather not have to deal with memory management and don’t care about the performance cost?

Can Rust’s type safety and the guarantees it brings allow a high-level programmer to be more confident, empowering them to more easily build and maintain complex applications? Or is Rust’s complexity too much of a barrier for that?

SHAR is the 3d multiplayer action game. I am going to talk about its internal implementation details and about problems and challenges met during development.

I’ll give a quick overview of all components SHAR is using - GUI, animations, FXses, networking, data serialization, modding.

I’ll show some code and will describe why decisions were made and to what consequences they led to.

Is Rust doomed to stagnate under the yoke of stability guarantees? Is change an inevitable force that will invalidate all your existing code? Is there a reasonable medium between these extremes? We explore these questions, under the guise of a modern day fable.

Felix “Scrooge” Klock remembers the early days when Rust development was fast and loose, an untamed beast. As a result, today he fears changes to the language definition.

Gather round as this “Scrooge” is visited by a series of spirits (manifesting themselves as Rust crates), including:

• The Ghost of Rust Epochs Past (code circa the 1.0 release),
• The Ghost of Rust Epochs Present (code today), and
• The Ghost of Rust Epochs Yet To Come (code as envisaged by the host of RFC’s as we head into the 2017 impl Period).

Many times you must reuse code
And your generics aren’t commode
Can you deal in the macro dark arts
Recompose code of similar parts
Or would the compiler explode?

Rejoice! Follow now our ways
Unlock the compiler’s high praise
Listen here to this initiation
Each eldritch arcane incantation
Summons help ‘gainst the terrors we face.

IDE support is one of Rust’s most requested features. From the 2017 State of Rust Survey: roughly 30% of Rust users are looking forward to IDE support more than any other feature in 2017 and for 22% of non-users, lack of IDE support is their main reason for not using Rust. In this talk, I’ll cover what it took to support Cargo workspaces in the RLS and I’ll explain how the RLS leverages existing tooling, including Cargo and the compiler. I’ll demonstrate the current state of Rust programming with an IDE, and how you can benefit from using an IDE with your Rust projects.

Fast, efficient, safe: pick three.

Embedded systems are highly concurrent; they must respond to several different external stimuli within tight time constraints while maintaining a low power consumption. At the core of these systems we usually find microcontrollers, low end Systems on a Chip (SoCs) with just about enough resources to fulfill their tasks: tens of MHz of CPU frequency and a few KBs of RAM are usual.

In this talk we’ll explore how to do efficient multitasking on these systems using zero cost, memory safe abstractions.

Ever wanted to make a game in Rust but didn’t know where to start? Then ggez is the framework just for you!

It bundles graphics and audio crates together with a simple API so can get started straight away.

In this talk I want to walk you through the making of a game with ggez from empty boilerplate to publishing a playable game.

This talk will take on a rather diverse set of topics, each outlined in limerick form. For each topic, a short explanation, also in rhymes (though not limerick meter), will follow where applicable. Slides will vary between code examples, rustdoc screenshots and memes.

For example:

With unimplemented!() confess
to your users the method is less
than done–you can now
add a message of how
to deal with the unfinished mess.

To delve a bit more into what’s new
PR 42155 brought to you
the way to get your message through
for things that you still intend to do.

A real-time stream processing and distributed computation system written completely in Rust designed to out-storm storm and is heavily influenced by the Twitter Heron paper. Antimony addresses all the architectural and efficiency issues of storm just like Heron does however implemented in a much safer language and is not bound to be backward compatible with storm. we will explore the implementation of a cross-platform high performance / lightweight stream processing and distributed computation system in Rust backed by the full power of Tokio.rs

In this talk, I’ll share my experience evaluating Rust as a basis for building Internet of Things (IoT) applications down to the bare metal.

In principle, Rust’s combination of memory safety and low runtime overhead makes it an ideal candidate for building IoT applications which currently are almost the exclusive domain of C and C++. As part of my master’s studies, we ported Tock, an embedded operating system written in Rust, to a Bluetooth Low Energy SoC processor.

In the end, we found that Rust is usable for building IoT applications with similar power consumption as production C implementations.

Do you need to perform a certain task in Rust? Why not pick a mature C library that already does what you want, and write a wrapping library around it?

Writing a wrapping library is sometimes not as easy as one could think, and you will probably make mistakes that will make you lose time or even make your wrapper unsound.

This talk will show you the most common safety problems you may not have thought of, such as leak safety, but will also give you advices on what not to do when designing the API of your library.

Test-Driven Development is a systematic method to develop robust and self-documented software by incremental steps. To TDD in Rust, there will be 2 great obstacles. First, testing infrastructure will be harder to build as Rust lacks reflection, introspection, and casting. Furthermore it is known for its compiler strictness, making incremental development harder. This talk is aimed at applying the TDD method successfully. We will see the methodology by the book, some pitfalls, and how to avoid them with some Rust patterns and strategies that will help you ship at all time with great confidence.