RustLab 2022

In this workshop, YOU will write a rust HTTP API that you wouldn’t be too ashamed of running in production at your company.
Using a Test Driven Development approach, you will learn to call external APIs, write integration tests and observe your API with traces and logs.

You need to query a web API that returns paged data and throttles your requests? Would you appreciate an abstraction layer that separates getting the data from handling it? Let’s implement a Stream step by step, learning the current limitations of the language and how to avoid them.

Actors are an elegant way to work with shared resources. Furthermore, actors fit together with Rust’s ownership rules very well, and learning how to write actors gives a better understanding of how to write code that the borrow checker likes.

The initial hype is over – Rust is becoming mature. This also means it is getting more and more interesting how existing applications can benefit from Rust’s superpowers.
Rust can be integrated with probably any language, in this talk we will show examples of how to integrate with C, C++, and Java.

In the last few years, eBPF opened the way for a new wave of technology built on top of its Linux kernel instrumentation capabilities. We will explain how eBPF works, write some eBPF code in Rust and talk about our journey building Exein Pulsar, an eBPF-based security observability tool for Linux.

Why did I build a Kubernetes Dashboard in Rust? I’ll explain the reason behind it and show what KDash does and how it differs from existing tools. I’ll also be deep-diving into the challenges I faced and the reason I choose to do it in Rust.

Redis is a multi-model in-memory-first database. Redis can be extended with new data structures and associated commands to do all kinds of interesting and fun things! In this talk, I will show you how you can use Rust to add new “modules” to Redis and bring data and computation together.

My journey learning how to write a web app fully powered by Rust (Actix backend and Yew frontend) and to set up the necessary infrastructure (Docker and Kubernetes) to deploy it live.
A useful case study for both newcomers and Rustaceans at their first encounter with the devops side.

Rust is great for implementing hard problems, thanks to its combination of performance and reliability. But providing clean, beautiful APIs for that functionality can be a challenge, especially because patterns developed for other languages don’t necessarily translate to Rust.

TRT code historically was a big Ruby monolith, in the last year I singlehandedly took that apart and ported to numerous Rust microservices.
During this path I had to solve a lot of problems, some less common than others, like writing a proc-macro to populate from database compile-checked dictionaries.

Within the SIFIS-Home project we are building on top of it to make the whole experience also trustworthy.
This talk will explore how we implemented all in Rust.

We want to share out experiences related to oxidizing rpm-ostree, a core component of several “hermetic” Linux distributions.

In a data-driven world, having to search through terabytes of logs is common. This simple task can turn out to be daunting and very expensive.

What Rust patterns are most effective when designing useful abstractions with low overhead? In this case study, we’ll be looking at the Financial Information eXchange protocol and how to build a crate with a large API surface without sacrificing performance.