MC Opening Address

I will share my personal journey as a contributor to the Rust Project. From enhancing the compiler with valuable lints and the powerful check-cfg feature to improving documentation through rustdoc. I will also mention some of my contributions to Cargo and the standard library, highlighting the collaborative spirit and community support that drive our progress, and maybe convince you to join us.

This talk focuses on what happens once you have called Rust's "panic!" macro. After a brief discussion of the various ways control flow is managed in Rust and other languages, we will focus on the internal working of the panic machinery of Rust. We will then discuss the trade-offs implied by its use, as well as recent improvements in how it interfaces with other languages through new ABIs for the FFI.

This talk will showcase the evolution and technical challenges of hs-bindgen, a tool for generating C-ABI FFI bindings between Rust and Haskell, while reflecting on the broader limitations of Rust’s procedural macros and lack of compile-time reflexivity (and the hacks to work around that). I will display how using a trait-based approach helps our tools to semantically understand Rust types, and enable safe and efficient interoperability. This will allow introducing a generic framework (mostly runtime-agnostic) for binding generation that extends beyond hs-bindgen. This session offers both practical insights for Rust developers and a conceptual roadmap for advancing tooling in strongly typed, compiled languages.

The Embedded Rust ecosystem has evolved rapidly, offering a modern, safe, and efficient alternative to traditional C/C++ development for embedded systems. However, building successful embedded applications requires more than just a powerful language—it needs a robust ecosystem that addresses key aspects of the development lifecycle. In this talk, I'll be exploring five essential pillars that form the foundation of Embedded Rust & how they align with current trends: Development Tools, Crates Ecosystem, Education & Community Resources, Debugging & Testing Capabilities, and Frameworks & RTOSs.I’ll dive into each pillar, highlighting the strengths and limitations of the current ecosystem, and providing insights into which areas can benefit from further contribution.

Rust’s macro system is a gateway to innovation, enabling developers to push boundaries by crafting powerful abstractions and domain-specific tools.
In this talk, we’ll explore the real-world use of macros in building Slint, a Rust-based toolkit for creating modern user interfaces, along with other innovative projects.From the `slint!` macro that embeds a custom DSL into Rust, to the `cpp!` macro that seamlessly bridges Rust and C++, and `document_features!`, which automates Cargo-based documentation,
we’ll dive into practical examples that demonstrate the versatility of Rust macros.
You’ll learn about the challenges of error reporting, syntax parsing, and IDE integration, including how the Slint Language Server works with `rust-analyzer` to provide a smooth development experience.Whether you’re new to macros or an experienced Rustacean looking for advanced insights, this talk will offer a blend of practical advice, lessons learned, and inspiration to apply macros creatively in your own projects.

I continue to see people confused at the role of RFCs or dread the process.
I'll be stepping through how the place RFCs have in the Rust ecosystem and how the process can work to help make it a better experience for people to effect change within the Rust ecosystem.

Doctests are a key component of rust: they ensure that code examples are up-to-date... but not only! They also allow you to test things that you can't test with unit tests.This talk will describe what you can do with them, how they are work internally and finally, what to expect in the future.

As amazing as the Rust programming language can be, one of its very few shortcomings is its infamous compile times, which can be quite high. But why is it slow in the first place? What does a compiler do, in fact? In this talk, we'll get through the high-level steps a compiler goes through before you can execute your code, and we'll stop at each step to find out how we can reduce the compile times, find tradeoffs to compile faster without compromising quality, showing tools that can help us during this journey, along with studying a real-world example of improving the compiles times of a project.

"There‘s a hidden change happening in software. While the struggle of the last decade was moving fast and growing quick, we now face additional challenges: how to we keep those system intact? While still quickly iterating and growing them? Rust is the poster boy of this change: it has - knowingly and unknowingly - addressed the problem that many companies face nowadays. Not only through memory-safety, but also through other means and its community mindset. This talk guides you through how this change is going - inside and outside Rust. It sharpens your thinking for the engineering challenges to tackle in the future and how to sell people on them. It will show clear and pragmatic examples where Rust helps - and where it is currently still lacking to reach the ambition for safe and efficient futures."

Microservices offer modularity and flexibility for development and deployment. However, this comes at the cost of complexity and maintenance. People also state that Rust is fast and safe, but slow to write and not flexible. However, with smart approaches, we can have the flexibility of microservices, the ease of deployment or monoliths, and the freedom of dynamic languages while using Rust. Maxwell Flitton has built fully functioning distributed systems in Rust that are in production with Caroline Morton including medical simulation software for the German government, resulting in awards. Here, they had to rewrite the deployment and testing infrastructure multiple times. This talk will show you the finished approach, where the servers can be run as microservices if needed. But with a different command, all rust servers compile into one binary. The frontend JavaScript app is also embedded into the Rust binary and served by the same single Rust server. Here we have the development experience of microservices, with the deployment and running experience of running a single rust binary. We also get the option to burst our system out and run it as a cluster of microservices if needed. Finally, this talk will cover how to utilise traits so we can swap out different databases and mock networking, data, and auth sources in unit testing without any third-party packages. Building flexible, easy to deploy, unit testable web servers in Rust is now a reality. These approaches are also bleeding into Maxwell’s work in surgical robotics at School of Biomedical Engineering & Imaging Sciences of King’s College London in the emerging field of medical IOT. This nanoservices approach recently reduced server costs from $2,100 a month to $100 a month.

How WebAssembly and Rust are helping us unleash the innovation of the AI Engineer. WebAssembly's unique properties allow us to plug user-defined AI logic directly into a robust execution environment, allowing us to reduce complexity for our customers, and allow them to focus on solving the task at hand.

Rust is famous for some of its unique language features such as ownership and fearless concurrency. These are not the features I miss most when programming in other languages however. In this talk I'll explore some less-flashy features of the Rust language and community that make it a fun and reliable language to program in.