EuroRust 2024

Through the Fire and the Flames - Jon Gjengset | EuroRust 2024

Why does my thing need to be Send, and why isn’t it? Why does this function have ten lines of where clauses; what are they all for? What do you mean foo doesn’t live long enough? Why is this async code just using a single CPU core? These are questions most of us have muttered under our breath after too much time staring at a screen of Rust code that we just can’t quite get right. Maybe we do some searching or blindly move things around and manage to find our way around our particular issue, but lo’ and behold another very similar one crops up a short time later. These kinds of recurring stumbling blocks make us doubt ourselves, hate the language, and ultimately limit our ability to actually getting things done! The reality is that Rust is a language with some inherent complexity (and associated features) that isn’t present in many other common languages. And these questions, and others like them, tend to stem from a lack knowledge of the underlying principles and mechanisms. Often, even a surface-level understanding of these deeper concepts will allow you to self-diagnose or entirely avoid 80% of the challenging cases. *About Jon Gjengset* 🦀 Jon is a Principal Engineer at Helsing and the author of Rust for Rustaceans. Before that, he owned the internal Rust build infrastructure at AWS. He is passionate about teaching (Rust and otherwise) and has published Rust live-coding and educational videos since 2018. He also co-hosts the podcast Rustacean Station. Jon started with Rust in 2015 when he built what eventually became his PhD thesis at MIT — a fast SQL database built from scratch in Rust. Outside of the world of programming, Jon is a Storyteller for the social deception game Blood on the Clocktower, and otherwise mostly sits around waiting for the next Rust conference. -------------------- *EuroRust 2024* – the yearly 2 day conference for the European Rust community ➡️ https://eurorust.eu _EuroRust is organized by Mainmatter, experts in Rust and distributed systems_ ➡️ https://mainmatter.com/rust/

Build bigger in less time: code testing beyond the basics - Predrag Gruevski | EuroRust 2024

Modern software projects are huge: hundreds of thousands of lines of code across hundreds of dependencies. How do they avoid falling apart due to an endless stream of bugs? The answer: advanced testing techniques — much more than just _clippy_, unit tests, and end-to-end CI. Better testing allows us to build bigger in less time, while minimizing bug triage and debugging needs. Let’s dig into some of those advanced techniques and see how they power the projects that we use every day! *About Predrag Gruevski* Predrag has spent the last 8 years working on query engines for almost every kind of data imaginable: from relational and graph databases to APIs and unstructured data files. He built Trustfall, a universal query engine that can query any data source(s), and cargo-semver-checks, a semantic versioning linter for Rust. Previously, Predrag was a principal engineer at Kensho Technologies, did performance engineering research at MIT, and competed in international math and programming competitions. When not in front of a screen, Predrag enjoys skiing, ice hockey, and board games. He is also a huge space nerd. Ask him about the time he went to watch a giant rocket explode! -------------------- *EuroRust 2024* – the yearly 2 day conference for the European Rust community ➡️ https://eurorust.eu _EuroRust is organized by Mainmatter, experts in Rust and distributed systems_ ➡️ https://mainmatter.com/rust/

A gentle introduction to procedural macros - Sam Van Overmeire | EuroRust 2024

Procedural macros are often seen as one of the most challenging things to learn in Rust. At the same time, they have immense utility and are ubiquitous in the language and crates, making basic familiarity with them very desirable. This talk presents the outlines of what these macros are, the different types, how they work, when to use them, and how to write your own. After a bit of theory and a lot of talking, we will do some live coding and write a derive macro that simplifies working with (AWS) SQS. *About Sam Van Overmeire* Professional software developer (and formerly historian and archaeologist). He likes writing on various subjects. Recently wrote a book for Manning on Rust macros, hence the proposal for a talk on that subject! -------------------- *EuroRust 2024* – the yearly 2 day conference for the European Rust community ➡️ https://eurorust.eu _EuroRust is organized by Mainmatter, experts in Rust and distributed systems_ ➡️ https://mainmatter.com/rust/

Practical Rust for Web Audio - Attila Haraszti | EuroRust 2024

This talk will document the author’s journey utilizing Rust while developing a custom low-level audio processing engine for web targets. Audio on the web has long been plagued by the lack of performance guarantees, with many applications and use cases held back due to insufficient API support by select browser engine implementations. The situations has, however, dramatically improved in the last two years, in no small part thanks to the rise of WebAssembly and developments in the ecosystem. _We will explore:_ *Navigating web vs. systems programming *Common audio engine internals *Architectural decisions for the web platform *AudioWorkletProcessor code in Rust *compilation hacks for minimizing WebAssembly bundle sizes *Using custom allocators, or none *Hand-crafted bindings to JavaScript *“safe” unsafe code *Practical real-world limitations *The current state of web audio *Performance tradeoffs we need to deal with for the foreseeable future The talk will wrap around technical parts with briefly addressing the important ”why”s: exploring philosophical drivers, implications and futures of interactive, interconnected musical works that could live on the web. *About Attila Haraszti* Attila Haraszti / h̷a̷y̷w̷i̷r̷e̷z̶ is a veteran dance music producer and independent software professional specializing in networked media applications. He is currently developing Songsling, a web-based creation and publishing suite for interactive music and audio. -------------------- *EuroRust 2024* – the yearly 2 day conference for the European Rust community ➡️ https://eurorust.eu _EuroRust is organized by Mainmatter, experts in Rust and distributed systems_ ➡️ https://mainmatter.com/rust/

Augmented docs: a love letter to rustdoc and docs.rs - Francois Mockers | EuroRust 2024

Docs are one of the superpower of Rust, thanks to the tooling and the central platform hosting them. Let’s take it to the next level! After a quick look at some of the most known features of rustdoc and docs.rs, we’ll review the guidelines and explore some of the advanced features available, like interacting with the #[doc] attribute directly or scraping examples. We’ll then look at how to enrich the docs with some crates from the ecosystem, like aquamarine for graphs, katex-doc for mathematical expression or document-features for automatic feature documentation, or with some templating, and see how far we can take it to have a complete documentation. To finish, we’ll dip our toes into documentation theory, through the Diátaxis framework and the Good Docs Project, check how rustdoc fit in those, and how other tools like mdbook or zola can complement it. *About Francois Mockers* He is a QA lead at PayLead and a Maintainer of Bevy. -------------------- *EuroRust 2024* – the yearly 2 day conference for the European Rust community ➡️ https://eurorust.eu _EuroRust is organized by Mainmatter, experts in Rust and distributed systems_ ➡️ https://mainmatter.com/rust/

The Impact of Memory Allocators on Performance: A Deep Dive - Arthur Pastel | EuroRust 2024

This talk will explore the world of memory allocation and its impact on application performance. Memory allocators are an often overlooked topic but are the backbone of most applications’ performance. After covering the fundamentals of heap memory allocation, we will build a simple allocator to illustrate the basic concepts. We’ll then tackle common challenges in memory allocation, such as fragmentation and memory overhead. We will then explore multiple scenarios from toy examples to real-world applications. Contributing to accurately measure how effectively allocation challenges are managed. This will be followed by analyzing popular memory allocators, exploring their strategies and performance in addressing these issues. By the end of the talk, attendees will have a deeper understanding of how memory allocators work and how to choose the right one, depending on their applications.e a deeper understanding of how memory allocators work and how to choose the right one, depending on their applications. *About Arthur Pastel* Hi, I’m Arthur, a software engineer based in Paris 🇫🇷🥖 I worked as an engineer in a few tech companies over the past years and started with Rust two years ago. I’m also passionate about (too??) many other software fields. Two years ago, I founded CodSpeed, a Continuous Performance Analysis solution helping tech companies and Open-Source projects prevent performance issues during development instead of waiting until the production breaks to start working on optimizing. We’re already helping some big open-source projects optimize their performance continuously and hope to continue contributing to an overall faster ecosystem -------------------- *EuroRust 2024* – the yearly 2 day conference for the European Rust community ➡️ https://eurorust.eu _EuroRust is organized by Mainmatter, experts in Rust and distributed systems_ ➡️ https://mainmatter.com/rust/

Proving macro expansion with expandable - Sasha Pourcelot | EuroRust 2024

Macros are a very powerful Rust feature. They allow developers to quickly and easily build domain-specific languages, with no runtime cost. However, the Rust compiler does surprisingly few checks on macros. For instance, it happily accepts a macro whose expansion is not syntactically valid, which makes them hard to debug. In this talk, we will see how expandable allows to check at compile time that a macro always expands to valid code and give a brief explanation under the hood. Finally, we’ll see a few techniques expandable uses to generate excellent error messages. *About Sasha Pourcelot* Sasha is a software engineer living in the southeast of France. She has been writing Rust both as a hobby and as a professional developer for many years. Her work mostly consists of compiler and static analysis tool development. When she’s not doing computer things, she reads, climbs, or cooks delicious Italian food. -------------------- *EuroRust 2024* – the yearly 2 day conference for the European Rust community ➡️ https://eurorust.eu _EuroRust is organized by Mainmatter, experts in Rust and distributed systems_ ➡️ https://mainmatter.com/rust/

Runtime Scripting for Rust Applications - Niklas Korz | EuroRust 2024

Runtime Scripting for Rust Applications Rust is a statically typed, ahead of time compiled and memory safe programming language. But sometimes, the restrictions Rust puts on us developers can be a hindrance, for example when prototyping new application ideas or when you want your end users to be able to change your application’s runtime behavior. Thankfully, we can embed dynamically typed scripting languages with a lower learning curve into our Rust applications to get the best of both worlds. In this talk, we will have a look at the scripting languages available to the Rust ecosystem and compare how well they integrate into Rust. Finally, we go through the process of embedding such a scripting runtime, Deno, into a Rust application and investigate how we can expose operations from our host applications to our scripts as well as share state between them. *About Niklas Korz* Co-Founder of alugha, the multilingual video platform from Germany. MSc graduate of Heidelberg University. Rust programmer since 2020. Organizer of the “Nix Your Bugs & Rust Your Engines” meetup in Heidelberg and Mannheim. I love dive into different application fields of computer science and software development. Among others, these include devops, cloud computing, distributed systems, web development, multimedia, graphics programming, mobile programming and game development. I also enjoy natural languages and pen & paper roleplaying games. -------------------- *EuroRust 2024* – the yearly 2 day conference for the European Rust community ➡️ https://eurorust.eu _EuroRust is organized by Mainmatter, experts in Rust and distributed systems_ ➡️ https://mainmatter.com/rust/

Unleashing 🦀 The Ferris Within - Victor Ciura | EuroRust 2024

“Let’s rewrite it in Rust” is no longer a party joke. It’s happening! Let me share a couple of stories of learning, appreciating and rewriting stuff in Rust. How we came to love 🦀 Ferris: cargo cult or real need? What is it like to come to Rust from two very different directions: C++ and C#? What are the gaps, the needs, the gems and the tools you should know about? Here’s a real journey and the various experiments leading up towards the success stories at Microsoft. Want to compare notes? Let’s chat. *About Victor Ciura* Victor Ciura is a Principal Engineer on the Microsoft365 Substrate team, building the Rust foundational libraries needed as part of the broader 🦀Oxidizer effort across the organization. Spent the last 20+ years doing systems programming in C++ on various teams, such as: Visual C++(DevDiv), Advanced Installer, Clang Power Tools. He’s a regular guest at Computer Science Department of his Alma Mater, University of Craiova, where he gives student lectures & workshops on algorithms and optimization techniques, using modern C++, Rust, Haskell. -------------------- *EuroRust 2024* – the yearly 2 day conference for the European Rust community ➡️ https://eurorust.eu _EuroRust is organized by Mainmatter, experts in Rust and distributed systems_ ➡️ https://mainmatter.com/rust/

The first six years in the development of Polonius - Amanda Stjerna | EuroRust 2024

When the current borrow checker, non-lexical lifetimes (NLL), was developed, one of the patterns the Rust developers wanted to add support for had to be abandoned: Case 3, in which a reference is conditionally returned early from a function. This case is particularly tricky to support as it requires a high-resolution analysis of the conditional flow references beyond the means of the current borrow checker. Therefore, current Rust does not support this code pattern (and others like it), even though it is provably safe. Since 2018, work has been ongoing to extend the borrow checker to support this case in the Polonius project. An early prototype implemented in Datalog is available in nightly Rust under an experimental flag. However, its performance and scaling properties make it insufficient for stabilisation. The working group is aiming to ship a prototype of Polonius with acceptable performance characteristics for the Rust 2024 edition, this time without Datalog. This talk presents a history of the work on Polonius, explains how it differs from the current borrow checker, and describes the path to stabilisation and beyond. *About Amanda Stjerna* Amanda is a PhD student in Web security at Uppsala university for increasingly broad definitions of "Web" and "security". She was exposed to Rust during her undergraduate shortly after the group project on making a garbage collector in C where she met her wife. Rust's type-system driven memory management was an easy sell after the experience. She has been working on Polonius on and off since writing her master's thesis on it and is currently working near full time alongside Rémy Rakic and Niko Matsakis in the Polonius Working Group on finishing a prototype on schedule. Amanda lives with her wife, a high-energy herding dog and an even higher-energy toddler on the outskirts of Uppsala, Sweden. In her spare time she sleeps or does the dishes. -------------------- *EuroRust 2024* – the yearly 2 day conference for the European Rust community ➡️ https://eurorust.eu _EuroRust is organized by Mainmatter, experts in Rust and distributed systems_ ➡️ https://mainmatter.com/rust/

Non-binary Rust: Between Safe and Unsafe - Boxy Uwu | EuroRust 2024

When writing unsafe code it is often easy to throw away a lot of the guardrails that safe Rust provides: the language stops helping you write your code, and you take on the burden of being the compiler and ensuring that all the invariants are upheld. It might feel like you’re either writing safe Rust or you’re responsible for doing everything yourself. In practice though it is possible to design your unsafe code to find a middle ground. You can offload some of the burden back onto the type system, like in safe Rust, while still being able to use the required unsafe functionality. Learning from my experience in refactoring and improving large amounts of unsafe code in Bevy’s ECS, I will explore this middle ground, leveraging the borrow checker and the type system to recover as many guardrails as we can. *About Boxy Uwu* Boxy is a member of the Rust Project, where she maintains the type system in her spare time. Before this she worked on the Bevy game engine’s unsafe code ensuring it’s soundness and long term maintainability. -------------------- *EuroRust 2024* – the yearly 2 day conference for the European Rust community ➡️ https://eurorust.eu _EuroRust is organized by Mainmatter, experts in Rust and distributed systems_ ➡️ https://mainmatter.com/rust/

Writing a SD Card driver in Rust - Jonathan Pallant | EuroRust 2024

The SD Card specification is an interesting example of a protocol which runs over an SPI bus, and provides access to blocks on the disk. We’ll dig into the Embedded Devices Working Group’s “embedded-hal”, which allows us to write an SD Card driver that works with almost any microcontroller and see how we can use Rust types to represent the commands and responses we need to be able to talk to an SD Card and get it initialized. We’ll then look at the Microsoft FAT filesystem, and see how blocks on disk can represent the files and directories we’re familiar with. We’ll then run a few demos to see what we’ve learned in action. *About Jonathan Pallant* My name is Jonathan, or JP to my friends. I’m @thejpster most places, except where I was late to the party and had to settle for @therealjpster. I’ve been doing Embedded Rust since 2016 and embedded systems since the mid-90s, when I stripped a Commodore 64 and turned it into a line-following robot. These days I am with Ferrous Systems, teaching Rust and offering consulting. Someone once asked me what I’d do if I won a million pounds and I said, uh, probably exactly the same thing I do now really. -------------------- *EuroRust 2024* – the yearly 2 day conference for the European Rust community ➡️ https://eurorust.eu _EuroRust is organized by Mainmatter, experts in Rust and distributed systems_ ➡️ https://mainmatter.com/rust/

My Journey from WebDev to Medical Visualization Rustacean - David Peherstorfer | EuroRust 2024

My partner and I became parents this year. When we learned that our son has a congenital heart defect I decided to do something to make his life better. This is when I remembered this one class about “Medical Visualization” and I decided to start my journey into this field using Rust (which I had previously learned). In my talk I will quickly go through how I studied Rust as a total beginner yet experienced developer. I will present how volumetric medical data can be rendered in 3D. For this, I used a raycasting technique which I will show you the basics of. Then I will dive into my journey through graphical Rust crates (three-d, gl, glow, wgpu). From the three-d crate I used the volume rendering example and extended it to be able to render DICOM files. Since I was not satisfied with the displayed result I went a level deeper and created my own volume renderer using raycasting. For this I started out with the gl crate. After making it work and being super proud I decided to switch to glow because of it being exposed by the three-d crate. Furthermore, I also ported this renderer to wgpu. And finally I will present my result by giving you a live demo of a volume renderer that has camera and threshold controls and can switch between three different raycasting shaders. * About David Peherstorfer* David Peherstorfer is a Full Stack Web Developer and has been making web apps leveraging decoupled Drupal using React for about 10 years. For about one year he has been on a quest to go into the field of Medical Visualization to improve his son’s life in the long-run. Originally he is from the mountainous region Vorarlberg in the west of Austria but he has spent about half of his life in the beautiful city of Vienna. He still enjoys a lot of different mountaineering (hiking, biking, climbing, trail running). He studied Computer Graphics at the university and is a self-taught Rustacean. -------------------- *EuroRust 2024* – the yearly 2 day conference for the European Rust community ➡️ https://eurorust.eu _EuroRust is organized by Mainmatter, experts in Rust and distributed systems_ ➡️ https://mainmatter.com/rust/

Code to contract to code: making ironclad APIs - Adam Chalmers | EuroRust 2024

If you’re providing customers with an API, then you’ve got to make sure that API is well-documented, and that the documentation is actually accurate! If you really want to make your API easier to use, you should provide users with API clients (or SDKs) in various languages. Again, those API clients should be well-documented, and those docs should actually be accurate! Too many times, engineers spend precious hours and energy fixing inaccuracies in their API clients or documentation. As the server changes, old clients and docs get out of sync with the server in production. But why manually update your software when you could automate it? Instead, generate API docs directly from your API server code. And if those docs are machine-readable, then you could even generate API clients from them! I used to do all this the manual, toilsome way. As a recent convert to the power of generated schemas and clients, let me show you how to set up a system like this, to reduce your toil and free up valuable work hours. *About Adam Chalmers* Adam has worked professionally with Rust for six years, building web services, high-performance proxies, and programming language tools. -------------------- *EuroRust 2024* – the yearly 2 day conference for the European Rust community ➡️ https://eurorust.eu _EuroRust is organized by Mainmatter, experts in Rust and distributed systems_ ➡️ https://mainmatter.com/rust/

Rust Irgendwie, Irgendwo, Irgendwann - Henk Oordt | EuroRust 2024

Ever forgot something? Thought so. Myself, I forget loads of stuff. I have the remarkable ability of totally forgetting what somebody is talking about during our conversation. It’s not a very useful ability. But you’ll probably also know what it feels like, standing in front of your fridge, staring into the abyss that is the veggie drawer, and pondering on your life choices. Only to remember 10 minutes later that you actually didn’t want to go to the kitchen at all. Luckily, we live in 2024. Where just about everything does have working memory. For instance, my laptop does, my colleagues, my wife has a very functional memory it would seem, and so does my car and my neighbour’s doorbell. I figured I want to make that memory work for me. So, being a software developer, a job title that should in my opinion be renamed to ‘computer whisperer’, I went ahead and created a little app that functions as my hippocampus. But then I forgot where I put it. This talk is about taking Rust everywhere. It showcases how a single piece of business and communications logic written in Rust can run on anything, from browser to backend, from CLI to bare-metal firmware. And beyond. *About Henk Oordt* Henk is a Senior Software Consultant at Mainmatter. Henk is an embedded software engineer and one of the lucky people who mainly uses Rust in embedded. He's so passionate about Rust that he can't help spreading the word by hosting Rust training for all kinds of areas, and by developing teach-rs, the modular, reusable Rust university course platform. -------------------- *EuroRust 2024* – the yearly 2 day conference for the European Rust community ➡️ https://eurorust.eu _EuroRust is organized by Mainmatter, experts in Rust and distributed systems_ ➡️ https://mainmatter.com/rust/

Linting with Dylint - Samuel Moelius | EuroRust 2024

Dylint is a tool for running Rust lints from dynamic libraries. Dylint is similar to Clippy, but whereas Clippy runs a predetermined, static set of lints, Dylint runs lints from user-specified, dynamic libraries. Thus, Dylint allows developers to maintain their own personal lint collections. *About Samuel Moelius* Samuel Moelius is a Staff Engineer on the Blockchain Team at Trail of Bits. -------------------- *EuroRust 2024* – the yearly 2 day conference for the European Rust community ➡️ https://eurorust.eu _EuroRust is organized by Mainmatter, experts in Rust and distributed systems_ ➡️ https://mainmatter.com/rust/

Renaissance of Terminal User Interfaces with Rust - Orhun Parmaksız | EuroRust 2024

The terminal is essential for every programmer when it comes to productivity and efficiency. Leveraging text-based user interfaces (TUIs) in the terminal is a powerful way to take full advantage of this environment. And what could be better than using a highly performant systems programming language like Rust to build TUIs? This talk aims to demonstrate how the terminal experience (TX) can be enhanced with TUIs and provides an introduction to building them using Rust with the Ratatui library. The following points will be addressed: What is a terminal user interface (TUI) and why is it used? What is Ratatui and how does it work? What are the main concepts and main design patterns used in Ratatui? What does the future hold for TUIs in Rust? *About Orhun Parmaksız* Hey, I’m Orhun, a Rust aficionado with a strong passion for all things open source! I’m the creator/maintainer of various Rust projects including git-cliff, kmon, and more. See: https://github.com/orhun I have been leading the Ratatui.rs project since last year, where we’re pushing the boundaries of the terminal by offering a TUI library for Rust developers. Also, I’m actively packaging Rust tools for Alpine Linux & Arch Linux (btw) and trying to improve the Rust ecosystem for GNU/Linux users. -------------------- *EuroRust 2024* – the yearly 2 day conference for the European Rust community ➡️ https://eurorust.eu _EuroRust is organized by Mainmatter, experts in Rust and distributed systems_ ➡️ https://mainmatter.com/rust/

Windows Kernel Programming with Rust - Matthias Heiden | EuroRust 2024

Ever wanted to know what goes on in the core of the Windows operating system? With Rust, you can craft your own Windows kernel drivers, empowering you to expand, explore and manipulate system functionalities like never before. It’s not just about developing hardware drivers; it opens doors to root kits, game hacks, antivirus solutions, and more. Whether you’re on the defensive or exploring offensive tactics, Rust in kernel programming offers a versatile toolkit. Join me in the exploration of the state-of-the-art techniques for programming Windows kernel drivers. From navigating pitfalls to essential considerations, this session provides a comprehensive overview. Gain insights into leveraging Rust’s safety and performance for crafting robust and efficient kernel drivers. Don’t miss your chance to harness the power of Rust for both innovation and security in Windows kernel programming! *About Matthias Heiden* Matthias Heiden is a computer science student with over four years of proficiency in Rust and C++. He has written projects and blog posts in the areas that interest him, including low-level programming, reverse engineering, software security, game modding, and artificial intelligence. During his free time, he finds joy in working on side projects and is equally passionate about sharing his expertise with others. -------------------- *EuroRust 2024* – the yearly 2 day conference for the European Rust community ➡️ https://eurorust.eu _EuroRust is organized by Mainmatter, experts in Rust and distributed systems_ ➡️ https://mainmatter.com/rust/

Fast and efficient network protocols in Rust - Nikita Lapkov | EuroRust 2024

Elfo is an actor system which can send messages between nodes. For this to work, we implemented a custom networking protocol entirely in Rust with support for compression and TCP-style flow control. We will dive deep into all the technical details and challenges we faced along the road. Strap in! *About Nikita Lapkov* Nikita is a Senior Software Engineer at Prisma and low-level Rust engineer specializing in databases and distributed systems. Previously, they worked on MongoDB, ClickHouse and YDB, as well as in high-frequency trading sector. -------------------- *EuroRust 2024* – the yearly 2 day conference for the European Rust community ➡️ https://eurorust.eu _EuroRust is organized by Mainmatter, experts in Rust and distributed systems_ ➡️ https://mainmatter.com/rust/

I/O in Rust: the whole story - Vitaly Bragilevsky

Many applications require as efficient input-output (I/O) as possible, including tasks such as reading from a disk or a network connection. However, I/O devices are known to be slow compared to CPUs and RAM. This contrast leads to various approaches for organizing I/O, ranging from step-by-step operations to enabling devices to write directly to main memory using Direct Memory Access (DMA). These methods correspond to different OS interfaces, from blocking I/O operations to highly asynchronous calls, and even emerging interfaces like io_uring, a new Linux kernel I/O interface. In this talk, we’ll explore I/O on three parallel levels: devices, operating system calls, and Rust code. It’s crucial to understand that software efficiency regarding I/O critically depends on the specific operations in use. Even more importantly, Rust code does not work in isolation—it relies on specific OS features and interfaces. Thus, we should learn about our Rust coding choices and their underlying implementations. There’s one more aspect: due to this dependency on OS interfaces, it’s impossible to implement a once-and-for-all solution that works across all operating systems at the most efficient level. However, by examining practical examples, we can discover some effective workarounds. Rust already enables us to write highly performant software. By deepening our understanding of I/O internals, we can make our code even more efficient! *About Vitaly Bragilevsky* I’m a developer advocate at JetBrains. I taught programming languages at universities for more than 20 years. I am the author of ‘Haskell in Depth’, published by Manning Publications in 2021, but I work with many other programming languages as well. -------------------- *EuroRust 2024* – the yearly 2 day conference for the European Rust community ➡️ https://eurorust.eu _EuroRust is organized by Mainmatter, experts in Rust and distributed systems_ ➡️ https://mainmatter.com/rust/

Generating ergonomic C++ APIs using Rustdoc, procedural macros, and Serde - Björn Wieczoreck

This talk introduces a novel approach to generate C++ APIs from an existing Rust API by using procedural macros, Rustdoc, and Serde. Functions and impl blocks which should be exposed in the C++ API are annotated with a procedural macro attribute. This macro generates low level extern “C” functions for the corresponding function definitions. Arguments and return values of these functions are passed as byte buffers in this case. Ultimately, Rustdoc’s unstable JSON format is used to generate a set of low level bindings for the generated extern “C” functions and, on top of that, a set of ergonomic high level C++ bindings. An intermediate layer handles all the required (de-)serializing of the argument/return type byte buffers to acquire the corresponding native representations. *About Björn Wieczoreck* After getting his master’s degree in Geoinformationscience, Björn joined GiGa infosystems in 2017. Ever since he has been working on software to store, manage and distribute 3D geological data, and almost all of this day to day work involves Rust. When there is time he tries to work on and improve an iOS app that visualizes this 3D data in Augmented Reality. Maybe there will be an opportunity to integrate Rust with the Swift code base as well. -------------------- *EuroRust 2024* – the yearly 2 day conference for the European Rust community ➡️ https://eurorust.eu _EuroRust is organized by Mainmatter, experts in Rust and distributed systems_ ➡️ https://mainmatter.com/rust/

Building an extremely fast Python package manager, in Rust - Charlie Marsh | EuroRust 2024

uv is an extremely fast Python package manager, written in Rust. Since its release in February, uv has seen adoption across the Python ecosystem, open source and enterprise, with over ten million downloads per month and growing – all grounded in a flagship focus on performance. Python packaging is a complex problem space with specifications and tools that date back decades. So what does it take to innovate in that space – to build something new, from scratch, that not only meets those standards, but performs orders of magnitude faster than the alternatives? And what kind of role can Rust play? This talk will walk through the architecture, design decisions, and optimizations that make uv so fast (think: allocators, concurrency, and zero-copy tricks), with a focus on the real-world experiments that we ran – and the lessons that we learned – over the course of uv’s development. *About Charlie Marsh* 🦀 Charlie is the founder of Astral, a company dedicated to building high-performance developer tools for the Python ecosystem, and the author of Ruff (a Python linter, formatter, and code transformation tool, written in Rust) and uv (a Python package manager, written in Rust). He’s spent his career working across programming ecosystems: first, at Khan Academy, where he focused on the Android, iOS, and web platforms; and more recently, as a Staff Software Engineer at Spring Discovery, where he led the development of a hybrid Rust-Python machine learning and data platform. Charlie received a BSc in Computer Science from Princeton and lives in Brooklyn, NY with his wife and son. -------------------- *EuroRust 2024* – the yearly 2 day conference for the European Rust community ➡️ https://eurorust.eu _EuroRust is organized by Mainmatter, experts in Rust and distributed systems_ ➡️ https://mainmatter.com/rust/

Powerful Macros, Good IDE Support, No Headaches. Choose Two - Lukas Wirth | EuroRust 2024

Macros are complicated, not only for the developers authoring them but also for the IDEs analyzing them. So how does rust-analyzer, a Rust IDE, actually handle them in a way such that features like completions and usage searching work transparently? In this talk we will explore the mechanism in rust-analyzer that enables these features, the current struggles with it and how both the IDE and library authors can improve the macro IDE experience. *About Lukas Wirth* Lukas Wirth has been working on rust-analyzer since early 2021, having taken on the team leadership at the end of 2022. He currently works at Ferrous Systems as a Software Engineer where he also co-authored the Ferrocene Language Specification for the Ferrocene toolchain. He is also a member of the macros working group and maintains an updated fork of the Little Book of Rust Macros. -------------------- *EuroRust 2024* – the yearly 2 day conference for the European Rust community ➡️ https://eurorust.eu _EuroRust is organized by Mainmatter, experts in Rust and distributed systems_ ➡️ https://mainmatter.com/rust/

EuroRust 2024 - Highlights

EuroRust 2024 was a blast! 🦀✨ The community had 2 busy days in Vienna with talks, side events, and loads of opportunities to connect. EuroRust 2024 brought together developers from across Europe and beyond – old friends met again and new friendships were made. 📍 What happened in Vienna, Austria? ✅ 24 talks from Rust experts ✅ Conversations and collaboration in the Impl. room ✅ Fun after party! ✅ Lots of engaging discussions with the Rustacean community ✅ Exiting side events, like karaoke, city tours, group diners, and more Missed the event? No worries! Stay tuned for EuroRust 2025, happening October 9–10 in Paris & online. 🎟️ 🔗 Learn more: eurorust.eu #eurorust #rustlang #rustcommunity #eurorust24 #eurorust25