OCT. 12-13 2023


Book Your Ticket

Schedule Day 1

Day 2

Thursday, October 12th

Times are local, CEST

9:00 - 10:00

Doors open & Breakfast

10:00 - 10:30

When the details matter

In the 8 years since Rust went 1.0, it has spread from a curiosity to a foundational technology used everywhere from kernels to spacecraft to cloud data centers. What is it that has made Rust successful, and what are the next big challenges for us to overcome? As Rust (and its community) grows, how do we stay true to our mission of empowering people to build everyone to build reliable and efficient software?

10:45 - 11:15

async fn from Editor to Executable

An async fn that you write goes through different compiler stages, from Editor -> AST -> HIR -> MIR -> Executable. This process is complex and changing all the time. My contribution to this was removing the GenFuture type, which used to be an implementation detail of async Rust. I will give a deep dive into what this was, why it had to go, and the struggles from a contributor perspective in making it go away. A journey through different workarounds that existed temporarily, and are still existing today.

Apart from this, I will also highlight some very common problems that developers may run into when developing async Rust. Why the difference between async fn and fn -> impl Future matters a lot. Why the mem::size_of of Futures is currently a great concern, how to work around that, as well as an outlook on the Future (pun intended) when the compiler will improve and make manual workarounds unnecessary.

11:30 - 12:00

Designing for Ownership

Sometimes it’s nice to channel our inner Monica Geller and keep everything neat in our codebase. It’s zen coding when you do some spring cleaning, and it’s good for your team when things are clear and expressive. So you brush up on your tests (or maybe you don’t) and start with some recreational refactoring in Rust.

But suddenly, all your textbook refactoring techniques fail! You move code around, extract methods or change coupling, and the borrow checker tells you that everything you want to access has already been used somewhere else. Sorry, Mario, but the Princess is in another castle!

In this talk, we will see how we can refactor with ownership in mind. We will learn more about the differences as well as commonalities of pointer types, we will look at how references work when being used in a struct, and we will evaluate what techniques work best. Throughout, we will critically assess whether these changes are worthwhile or if cheating our way around with shortcuts is a better approach.

12:00 - 13:30


13:30 - 14:00

alt.ctrl games w/ Rust

What if I told you there is a magical place where you can play videogames not just with a mouse+keyboard or gamepad but with, well, anything? Welcome to the alt.ctrl scene where anything can be used to control a videogame!

And what if I told you there is a magical programming language that supports you and your alt.ctrl game from hardware to GUI? Well, you're at a Rust conference so maybe you've guessed it.

In this talk we'll take a look at the many shapes of alt.ctrl games and how Rust is the perfect fit for creating them.

14:15 - 14:45

Lessons Learned from Teaching Rust

Rust is a language that’s usually described as hard to learn, so let’s shine some light on how people do learn it! I’ve been maintaining Rust learning materials for about 5 years, and through shepherding hundreds of community contributions, I’ve gleaned some interesting things about how people approach learning this language, which parts they find difficult, and what we as teachers (be it through learning materials, documentation or otherwise) can do better. Join me in this journey through a less-talked about facet of the project!

Photo of Liv
15:00 - 15:30

Publishing High-Quality Crates

Cargo makes it easy to publish a crate, but there’s a lot of work to be done between cargo new and cargo publish. This talk will cover the many ways to take a crate from good to great.

15:30 - 16:00

Snack Break

16:00 - 16:30

Reinforcement learning as a testing methodology

Apply machine learning to help foresee, find and fix heisenbugs. More realistic than Fuzz testing, more comprehensive than property based testing, reinforcement learning can find more bugs than you thought possible.

16:45 - 17:15

Rust, but Verify - Compile-Time Authorization

Authorization is the number one security risk in the OWASP Top 10. But does it have to be? In this talk we’ll explore application security, unstable rust, and typestates to address one of the most prevalent vulnerability classes in modern software.

17:30 - 18:00

Panel: Inside Rust

We talk to people that are actively involved with building Rust about their work. What are the inner workings of the project? What's coming in the 2024 edition? Luca Palmieri will talk about those and other questions with our panelists.