November 9th, 2024
Registration
Write yourself a shell
One of the things developers use every day is a shell. It comes in many flavors like bash, fish or zsh.
In this workshop, you'll write your own fully functional shell in Rust using the latest best practices with a focus on idiomatic code, with one caveat: you can only use the standard library (no external crates allowed).
You'll play with I/O, error handling, and syscalls while getting more hands-on Rust experience.
LEVEL: Intermediate
Build a Ray Tracer with Rust and wgpu
WebGPU is the novel graphics standard that makes it possible to implement high performance graphical applications on mobile, desktop and the web.
In this workshop, I guide you through the process of using Rust and WebGPU compute shaders for computer graphics applications whose needs go beyond the traditional rasterization pipeline.
Together, we will write a GPU-accelerated ray tracing renderer from scratch!
LEVEL: Intermediate
Building cross-platform UIs with Rust and Slint
As a low level language, Rust is perfectly suitable for making user interfaces the old-fashioned way, with native APIs. However, writing a GUI application in today’s world typically means supporting many platforms.
This workshop introduces Slint, a Rust based declarative GUI toolkit, and will show you how to build GUI applications with Rust. By the end of the workshop, you will have built a fully functioning cross-platform application in Rust.
LEVEL: Intermediate
Coffee break
Lunch
Cooking up with TUIs with Ratatui
This workshop will walk you through the fundamentals of building terminal user interfaces, shedding light on how they function and giving you a solid grasp of their inner workings.
LEVEL: Intermediate
Let's build our first Bevy game!
After an introduction to Bevy, attendees will be able to select a starter kit for a Bevy game, then we'll look at finishing it.
Attendees should be able to leave with a game that run natively on their laptop, in Wasm on their browser, and if all goes well as a game on their mobile phone too.
LEVEL: Intermediate
Coffee break
November 10th, 2024
Registration
Conference presentation
Welcome coffee
Design and Implementation of the `#[diagnostic]` attribute namespace
The talk aims to introduce the `#[diagnostic]` attribute namespace. This new tool namespace allows to hint the Rust compiler to emit a specific error message text in certain situations. It's meant to help crate authors to take control over error messages emitted by the compiler that occur while upholding certain domain specific compile time constraints. The feature was stablized with Rust 1.78.
LEVEL: Advanced
Exploring lending async iterators
Rust async ecosystem is evolving, bringing the opportunity of exploring new ways to express powerful abstractions. Together we will define the concept of a "lending async iterator", assessing its practical usefulness and investigating some interesting implementation details.
We will leverage the power of Rust toward the current limits of the language, showing how it could be improved to make these abstractions easier to express.
LEVEL: Advanced
Borgo – a Rusty language that compiles to Go
People have been talking about a Simpler Rust for years now. Remove the borrow checker and lifetimes, bolt on a Garbage collector and you should get a fairly solid language for application development. Borgo is my attempt at creating such a language! In this talk, we'll go through the ideas behind it and my experience in building it (Borgo itself is written in Rust). If you ever felt like Rust was too hard at times and wished for a simpler alternative, come and check out Borgo!
LEVEL: Introductory and Overview
Rhino: low-latency key-value database in Rust
Rhino is a key-value database optimised for low-latency edge workloads. This talk is a deep dive into how we leveraged Rust and actors to implement highly concurrent networking services that power Rhino. Strap in!
LEVEL: Intermediate
Generating ergonomic C++ APIs using Rustdoc, procedural macros, and Serde
How to integrate your new shiny Rust code into an existing codebase is a common problem. For this you might need to provide an API so that your Rust code can be accessed from the non-Rust side, for example from a C++ codebase. Rust only provides tools out of the box to define a low level C API, and even that can be troublesome. In this talk we want to demonstrate how you can use procedural macros, Rustdoc's unstable JSON format, and Serde to generate an idiomatic and ergonomic C++ API based on your existing Rust API.
LEVEL: Advanced
Lunch
Crafting a Linux kernel scheduler in Rust
In the realm of operating systems, the heart of performance lies in the CPU scheduler: a critical component responsible for managing the execution of tasks on a system.
Playing around with CPU scheduling policies has always been a dream for many kernel hackers and OS enthusiasts. However, such material typically remains within the domain of a few core kernel developers with extensive years of experience.
What if we could bring this dream to life and make it really accessible, thanks to sched-ext, eBPF and Rust?
LEVEL: Advanced
Chips don't bite! A fearless introduction to µController programming for Rusteaceans
Rust is "A language empowering everyone to build reliable and efficient software." And that is not only true for normal everyday software. But it also empowers you to delve into more niche areas of software development, such as embedded systems. And on the way it opens up new perspectives for you as a developer. No operating system and little memory might seem scary at first, but the compiler has your back! The ecosystem offers great tools, abstractions, and crates which will help you to blink your first LED (The equivalent of "Hello world" in the embedded space).
LEVEL: Introductory and Overview
The Guard pattern in Rust
Guards are data structures that guarantee properties at compile time and safely mediate runtime functionality.
We will introduce the Guard pattern in Rust and present a number of use cases.
LEVEL: Introductory and Overview
Coffee break
Keynote: Scaling out operational research with Rust
We used Rust to implement a scalable distributed system to handle vehicle routing problems, with hundreds of complete plans solved every second. I will explain why we chose Rust, its strengths in a project like this, how it influenced our software architecture, and how it worked out in the end.
LEVEL: Intermediate
November 11th, 2024
Registration
Cooking parsers with winnow
I'm going to share how I started with parser and how I use a special language to collect recipes and share them with friends and family. I built a language designed specifically to write recipes, which is open source: https://github.com/reciperium/recipe-lang
This talk is good for beginners to advanced rust developers who would like to get familiar with parsers.
Hopefully, there will be some live coding.
At the end of the talk, the attendees should be able to write a small parser using winnow, which is very similar to nom.
LEVEL: Introductory and Overview
Fearless Refactoring and the Art of Argument-Free Rust
Large professional codebases naturally form conventions and competing conventions lead to messy code. This talk discusses what we learned from creating standards documents and a hackable linter (in Rust) and applying it to large codebases at an organisation with more than 1000 people.
Speed, Safety, Sustainability. Have all 3 with serverless & Rust
Serverless provides a way to ship application code, only using the resources you need when you need them whilst shifting the operational responsibility on to the cloud provider. It enables developers to focus on writing code and shipping features, and doing that in a performant and safe way.
This talk will explore the beauty of this combination, and how it’s a fantastic way to build modern business applications with Rust.
LEVEL: Intermediate
Low Latency Rust
What does rust offer for low latency performance optimization? This talk will serve as an introduction and an exploration of performance tuning and what rust offers for engineers working on products with strict performance requirements.
LEVEL: Intermediate
Coffee break
Unsafe for Work
What's the deal with unsafe? The word alone seems to scare the living hell out of every Rust developer, at the same time it's heavily misunderstood even by the best of us.
No more trust issues. Let's analyze what unsafe is (surprisingly little), and what harm you can cause by using it (less than you think but still enough to wreak havoc).
In the end, we will see if we have practical use for unsafe in our own, real-world software, or if we should consider everything not safe for work.
LEVEL: Advanced
From Smart Home to Smart Cats: extending my home automation to my pets
When going online and searching for new gadgets for our home, we often find Alexa, HomeKit or Google Assistant compatibility badges. Are these compatibility layers hard to code? What if I want to code mine?
The truth is that every gadget that is connected to the internet is probably speaking to an HTTP or MQTT API. And this means you know how to use it.
In this talk, I will show you how I easily made my cat’s life way technological.
LEVEL: Introductory and Overview
Lunch
The currents of concurrency: reasoning with Async Rust
Reasoning through concurrent systems has always been a challenging task. Poor code can be riddled with race conditions, non-terminating cases and other complex concurrency bugs; and even well-written code can be hard to understand. Async programming is an innovative concurrent programming model that rises to this challenge. In this talk, we'll explore reasoning with async Rust. We'll be introduced to its fundamental building blocks, such as `async`, `await`, `join` and `select`, and learn how to predict the behavior of code written with them. We'll build on these to simplify more complex concurrency puzzlers. Finally, we'll explore different approaches to handling concurrent state and see how they compare.
LEVEL: Intermediate
From 0 to UI using Slint
Slint is a GPL/commercial/Royalty free licensed, reactive UI toolkit written in Rust. Using a tooling-friendly declarative language to describe the UI, it allows for rapid prototyping and allows for developers and designers to cooperate on the UI.
The Slint language is compiled into Rust code and runs well anywhere, from micro-controllers with a few hundred KiB of RAM all the way up to desktop OS platforms with GUI acceleration and even Android.
This presentation shows how to quickly create a simple UI project using Rust.
LEVEL: Intermediate
Profile-Guided Optimization (PGO) for Rust applications: Practical Guide
Profile-Guided Optimization (PGO) is a compiler optimization technique that helps with optimizing software based on runtime statistics. This optimization is available for a long time in the Rustc compiler. I applied PGO to many kinds of software (compilers, databases, log solutions, CLI tools, and many more), collected a lot of carefully hidden traps on my journey, reviewed many open-source projects, and found multiple PGO integration approaches. In this talk, I want to share with you my experience.
LEVEL: Intermediate
Don't panic! - Our journey to error handling in Rust
In this talk, I will delve into the transformative journey of error handling in our first Rust project. From an initial state where panic-induced chaos was widespread, making it challenging to pinpoint the root causes of crashes, we navigated through the Rust ecosystem to establish a robust and stable foundation.
LEVEL: Introductory and Overview
