List of videos

Rust's behavioural abstraction mechanism, the Trait, is a powerful tool for improving the ergonomics of the crates you use every day. In this talk, we'll explore some exciting applications of Traits in library code that cause your application's code to stay clean and concise. I'll start with a beginner's introduction to Traits, comparing and contrasting with similar ideas from other languages to get you up to speed. Then we'll look at a few examples from the standard library and common ways to incorporate trait bounds into generics/type parameters to clean up your code. Finally, we'll dive deeply into the "extractor pattern" used in the modern Rust web frameworks. At first glance, the extractor pattern can look like magic. However, we Rust users often shy away from things that are too magical because we care about retaining control. But this pattern should be easily understandable once we've peeled back the layers and seen how far Traits can be pushed in this way.

Every so often, something so fundamentally brilliant comes along that it challenges mainstream ideas about the right way to do things. The Rust language's adoption and its generated excitement align with this pattern. Yet, many complain about how challenging it is to wrap their heads around the concepts that make the language and its tooling so robust. At Tauri, we have discovered that offering engineers low-friction pathways encourages experimentation, knowledge acquisition, and rapid mastery. In this keynote, Tauri's co-founder Daniel Thompson will present key takeaways for enabling positive growth of the Rust community via empowerment and developer experience.

Async in Rust is similar to some languages, but due to not having any built in runtimes or memory management, the people that proposed the initial APIs had to work around some interesting problems. Let’s pretend we didn’t have these solutions already. Let’s build our own async features and runtimes from the ground up. And given the outcomes, can we find any interesting insights on how async may change in the future?

In 2020 I started to be a bit more serious about learning Rust. After having read a few books and having done some coding challenges, I decided to start live-streaming my attempts to solve Advent of Code challenges using Rust. Fast forward to 2022 I completed 50 challenges and learned a lot about how to use Rust to solve specific programming challenges. In this talk, I’ll be sharing some common tips and tricks that I discovered while live-coding also thanks to the beautiful Rust community that gave me tons of suggestions! Some topics I’ll be covering in this talk: parsing input, data structures, error handling, iterators, performance, allocating and manipulating 2d matrices, etc.

You'll come away from this talk with many tips for expanding Rust adoption in your workplace. We'll discuss some ideas that AWS is experimenting with to improve teams' ability to bring developers – including those who lack Rust expertise – up to speed with their projects. More generally, the talk covers how to build a sustainable team, even after the enthusiasm from the initial developers has faded.

Sometimes you need to run a program on a CPU it just wasn’t designed to run on. Perhaps you want to run an x86 application on your brand new ARM Mac. Or maybe you’re feeling nostalgic for playing some old console games on an emulator. Let’s take a deep dive into binary translation, the technology that makes this possible! In this talk, we’ll explore this topic by building a simple RISC-V emulator and then making it go faster by using binary translation.

At fly.io, we run apps close to your users by taking containers and upgrading them to full-fledged virtual machines running on our hardware worldwide in 26 cities and counting. When requests come into our platform, we route them to the nearest instance of your app via our global Anycast network. This is driven by `fly-proxy`, our internal Rust-based proxy built on top of Tokio, Hyper and Tower. `fly-proxy` is an exciting piece of our stack. It has to build a global picture of all instances running on our platform and route requests (including raw TCP and WebSockets) to the nearest instance. It does other things, too: load balancing across our global network, TLS termination, rate limiting, and metrics tracking! It even handles the lifecycle of some eBPF we run (which I may or may not talk about). As you’ve already realised, I’ll be talking about `fly-proxy`, how it works and Rust's role in building it.

Rust is the most loved and most wanted programming language today, and the community has nearly quadrupled in the last two years to 2.2 million. With over 85,000 packages built by thousands of contributors across the world, Rust is the definition of open and inclusive. We are going to talk about one project that is leveraging Rust to enhance supply chain security for open source projects just like the ones that make Rust Rust. Pyrisia will address one of the security challenges we all face: using secure packages in our development. Join us for an informative and interactive session on Rust, Pyrsia, and how their communities are working together to secure the software supply chain.

With the exponential growth of data and devices, and the move to the cloud, there is a need to store, analyse, and query data in a multitude of different ways from a host of other clients and devices - whilst at the same time ensuring that only the correct user has access to the appropriate data. In this session, Tobie examines the growing need for SurrealDB, a multi-model database capable of handling many concurrent connections and providing secure access to the appropriate data with a new custom SQL-like query language. Tobie discusses building SurrealDB from scratch, including the initial prototype in Golang and the decision to reimplement it entirely in Rust. Tobie also explains why Rust is the ideal choice for creating high-performing, resilient, modern applications.