Schedule

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

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

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

Curious about Rust? Join us for an exciting, hands-on workshop where you’ll create your very first web application using the language. We’ll guide you through Rust basics, help you build a command-line tool, and then transform it into a fully-fledged web application.

LEVEL: Introductory and Overview

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.

> The workshop material is published at https://github.com/orhun/rustlab2024-ratatui-workshop

LEVEL: Intermediate

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

Software today is generally brittle, wasteful and insecure. We can do much better. This talk shows you, as a Rust developer, can contribute to a better status quo through incremental improvements.

The talk will spend most of its time showing you ways to remove human error by using automated tools as much as possible. Our tools can prevent bugs and minimise the impact of any that do occur.

LEVEL: Intermediate

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

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

At Code Your Future, we teach beginners from disadvantaged backgrounds to become professional software engineers. We've mostly been doing this in JavaScript, and a bit of Go.
This talk explores our experiences of teaching software engineering, what makes Rust hard for beginners to approach, and invites individuals to volunteer with us, and companies to partner with us to help us prove that Rust can be a great learning language.

LEVEL: Introductory and Overview

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 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

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

Lightning Talks on the 10/11/2024

To add a lightning talk proposal, please click here: https://survey.typeform.com/to/WJSbl5XZ

• Adam Leventhal: SDK generation from OpenAPI (and so can you)
  
• Felipe Ramos da Silva: Socket-Flow - A Rust async websockets library
  
• Thorsten Ball: Optimizing a Rope with bit twiddling
• Gianluca Randazzo: How I oxidized my Neovim config
• Domenico Mastrangelo: Axum - a quick intro to web development with 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

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

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

DTrace was developed at Sun to understand the whole system, from the lowest levels of the kernel to the highest levels of application abstraction. Since its release in 2003, DTrace has been ported to macOS, Linux, FreeBSD, Windows and others. In addition to dynamic instrumentation, developers can write static hooks in their code in languages from C to JavaScript, and--of course--Rust!
In this session, Adam Leventhal, one of the original authors of DTrace, will discuss the fundamentals of DTrace, Rust support for DTrace, and how DTrace is constantly used at Oxide to debug and performance tune our work in Rust.

LEVEL: Intermediate

Lightning Talks on the 10/11/2024

To add a lightning talk proposal, please click here: https://survey.typeform.com/to/WJSbl5XZ

• Magnus Drangevåg: Newtype or newtrait? Ways around the orphan rule
• François Mockers: Pathfinding in Rust
• Matteo Bertini: Array languages
• Arthur Belleville: How we built a more performant regex engine at Datadog

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

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

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.

LEVEL: Intermediate

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

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

There are many reasons you may want to roll your own JavaScript runtime — building an interactive web app with a Rust backend, extending your platform with a composable plugin system, and more.
Here's an introduction to building your own JavaScript runtime with Rust, where I'll also give ideas for directions in which you can take yours.

LEVEL: Intermediate

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

Lightning Talks on 11/11/2024.

To add a lightning talk proposal, please click here: https://survey.typeform.com/to/WJSbl5XZ

• Michal Rostecki: Writing safe wrappers in Rust
• Santiago Fraire: nix and duren for dev environments
• Orhun Parmaksız: 7 awesome Rust terminal tools that you should use

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

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) 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

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