Rust Nation UK 2023

Rebecca is the Executive Director and CEO of the Rust Foundation. A global non-profit stewarding the Rust language, supporting maintainers, and ensuring that Rust is safe, secure, and sustainable for the future.

One of the best aspects of the Rust community is its dedication to teaching. Passing on what we have learned is undoubtedly virtuous, but that is not the only benefit. We genuinely know something once we can teach it - which means we also can only deliver software to its full potential once we can teach it to others. This Week in Rust features tutorials, blog posts, meetup and conference talks, podcasts, and projects seeking contributors every week. Come to this talk to learn how passing on what you have learned - primarily when you have just discovered - not only benefits the community. It also helps you build hard technical skills that level up your programming and career. Whether you are just taking your first steps with Rust or have been a long-time Rustacean, you have something to contribute to the community. Your experience is both wanted and needed. Come to this talk to learn why and how to share this experience to the benefit of all.

The Rhai scripting language is emerging as a really promising tool for use cases similar to how Lua has traditionally been used in C projects. For Rust developers, Rhai's "superpower" is its effortless interop with Rust programs: bridging your existing program to the Rhai scripting environment is pretty seamless. At Keyrock, we use Rhai scripts as a way for our trading team to continuously modify and iterate on numeric analysis applied to market data for use in our real-time, automated trading system. The discussion will: - detail advantages of this technique like quick feedback cycles ("deploy" to a live system) - share hard-won experience and wisdom from using this technique in production for a system with extreme performance requirements - and explore some future possibilities presented by the combination of blazing-fast reliability (Rust) with scripting flexibility (Rhai).

The holy grail of being able to write an application once and deploy it to iOS, Android and the Web continue to elude us. Some solutions exist — React Native, Flutter and Kotlin Multiplatform Mobile — but they all have challenges. We’ll look at these challenges and the architecture patterns we can use to solve them. In particular, we’ll show how to build applications for mobile and web that share a pure, functional core written in Rust. We’ll dig into working code that banishes the magic of Foreign Function Interface (FFI) and WebAssembly (Wasm) and demonstrates how the Onion architecture can make our application easy to test.

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.

Rust enforces unique lifetime and access bounds to data inside a program and thus impacts how memory must be managed. This is especially relevant for multi-threaded systems or applications where multiple parts may want to access some congested data. In this talk, I will cover some data synchronisation theory in Rust, starting at the common Arc˂Mutex˂T˃˃ pattern, and ending in an exploration of smart pointers and lock-free data structure design.

What does the Rust Foundation do? Why all the focus on security? How does the Foundation work with the Rust Project? The Rust Foundation team are here to answer your questions. Ask us anything!

What makes Rust on embedded hardware exciting and challenging is that we want to realize two conflicting objectives. On the one hand, we want to use safe and convenient high-level abstractions. This is particularly true for Tock OS, an embedded OS whose security model is built around Rust’s type safety guarantees. On the other hand, we want to efficiently use the platform’s resources, particularly regarding code size and memory usage. This becomes especially challenging when we account for all of the requirements that Tock OS imposes, including supporting dynamically-loaded applications and running the OS and the applications from arbitrary positions in ROM and RAM in devices without support for virtual memory. In this case study, we discuss how lowRISC is improving Rust support for RISC-V embedded platforms, driven by Tock OS. We describe our efforts for adding support for RISC-V position-independent code optimized for embedded applications, including the changes needed in the toolchain, rustc, the ABI, Tock OS and its libraries. We also detail how we are trying to optimize the Rust abstractions used in Tock OS, including the compiler transformations involved, metrics for the binary size improvements, and the current status of those optimizations.

More than 100 all new limericks about Rust. Delivered by the Rust bard himself. Ukulele included.

Rust and its ecosystem are in constant flux, and this can be scary, especially when you're building an application with stability and long-term project sustainability in mind. New Rust versions bring ever-higher editions, must-have new features, and lint and tool changes to keep on top. And as new features emerge, they'll fade into oblivion. In this talk, we'll look at the changes that may happen to you when working with Rust and how to live with them. We'll talk about Rust and crate versioning, backwards compatibility, unstable features, minimum supported Rust versions, and 1.0 releases. This talk is geared towards those using Rust to build applications and services, not those building Rust libraries. It won't tell you the right way to set up CI for your library crate or decide whether a change is backwards compatible. Instead, we'll dig into the kinds of stability challenges that can arise in Rust, what to do when they crop up, and some promising avenues for making the stable life easier.

Live stream from Track 1 of Rust Nation UK.