Sunday 2nd October (Workshops)*


12:45 Registration

13:00 – Coffee Hall – Workshop: Write a production-ready Rust HTTP API

  • SPEAKER: Marco Ieni
  • LENGTH: 3h
    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.
    This workshop consists of a series of interactive exercises (similar to [rustlings]) that will guide you through creating an HTTP API iteratively.
    The API will:
    – Receive a Star Wars character name in input.
    – Call [swapi], a free Star Wars API, to check how tall the character is.
    – Return a boolean in a JSON payload to indicate if the character is taller than Yoda or not.
    Your tasks will include:
    – Call the swapi API to retrieve data asynchronously by using [reqwest].
    – Build an HTTP API by using [axum].
    – Handle errors by using [thiserror] and [anyhow].
    – Use [tracing] for logs and traces. You will visualize traces by running [jaeger] locally.
    – Write tests by mocking external APIs with [wiremock].
    After these tasks, you can choose what to implement next. Some suggestions from me:
    – Use an in-memory cache of responses from `swapi`.
    – Write a Dockerfile.
    – Set a CI pipeline.

    After this workshop you will know:
    – How to build a simple HTTP API in Rust.
    – How to use some key libraries of the Rust backend ecosystem.
    – Where to look if you want to go deeper into the topics covered by the workshop.

    Have you played with Rust before but aren’t comfortable writing Rust backend code yet?
    Then this workshop is for you!

16:00 – Smart Room – Coffee break

16:30 – Coffee Hall – Workshop: Writing a stateful Stream from scratch

  • SPEAKER: Edoardo Morandi
  • LENGTH: 3h
    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.
    It is very common to interact with Web APIs that expose paged data and, at the same time, use some algorithm like the leaky bucket in order to limit the amount of requests per user. Nonetheless, it is not trivial at all to handle these situations in a clean way, and the ideal solution is to separate the logic behind requesting the paged data from the processing of the results.
    During the workshop we are going to learn how to implement a Stream in order to build an abstraction layer able to perform the right queries with the right timing.
    In details, we will learn about:
    – expressing a `Stream` as a state machine;
    – how `Pin` works in practice;
    – the current limitations of the type system and how to avoid them;
    – when to use `async` and when to avoid it (and why).
    During the event we will not have time to write everything_, instead you will be given some basic code to work with, in order to focus on the implementation of the `Stream`. Moreover, the entire workflow will be divided in steps and a repository will be available with the code for each step.

20:00 – Acero Rosso – Gopher’s and Rustacean’s Dinner

Monday 3rd October

8:30 – Registration

9:30 – Smart Room – Welcome Coffee

10:15 – Introduction to the conference

10:30 – Tea Hall – Keynote: Actors with Tokio – a lesson in ownership

  • SPEAKER: Alice Ryhl
  • LENGTH: 1h
    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.

11:30 – Tea Hall – Get the best of both worlds – Integrating Rust with other languages

  • SPEAKERS: Harald Reingruber, Fred Morcos
  • LENGTH: 1h
    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.

12:30 – Tea Hall – Tracing the Linux kernel with eBPF and Rust

  • SPEAKER: Domenico Salvatore
  • LENGTH: 1h
    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.

13:30 – Acero Rosso – Lunch

14:30 – Recruiting Session – M4SS

14:45 – Recruiting Session – TRUELAYER

15:00 – Tea Hall – Building a Kubernetes monitoring dashboard in Rust. Why not?

  • SPEAKER: Deepu K Sasidharan
  • LENGTH: 1h
    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.

16:00 – Tea Hall – Extending Redis with Rust

  • SPEAKER: Brian Sam-Bodden
  • LENGTH: 1h
    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.

17:00 – Smart Room – Coffee break

17:30 – Tea Hall – Dockerising and deploying a full stack Rust + WASM web app

  • SPEAKER: Angelo Rendina
  • LENGTH: 1h
    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.

Tuesday 4th October

9:00 – Registration

9:30 – Smart Room – Welcome Coffee

10:00 – Tea Hall – Keynote: Ergonomic APIs for hard problems

  • SPEAKER: Raph Levien
  • LENGTH: 1h
    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. Building a UI toolkit is an especially hard problem, and the Druid architecture has evolved dramatically since the early days. The new Xilem architecture promises a powerful declarative approach, drawing on powerful features of the Rust language to provide strong static typing but also a concise and flexible interface. This talk presents five techniques that drive the GUI architecture, but are also general and likely can improve API design in other domains.

11:00 – Tea Hall – From Ruby to Rust, TheRockTrading porting experience

  • SPEAKER: Marco Napetti
  • LENGTH: 1h
    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.

12:00 – Tea HallWeb Of Things and Rust

  • SPEAKER: Luca Barbato
  • LENGTH: 1h
    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.

13:00 – Acero Rosso – Lunch

14:15 – Recruiting Session – PRIMA ASSICURAZIONI

14:30 – Tea Hall – Oxidizing rpm-ostree

  • SPEAKER: Luca Bruno
  • LENGTH: 1h
    We want to share out experiences related to oxidizing rpm-ostree, a core component of several “hermetic” Linux distributions.
    Since a few years we have been gradually moving part of its codebase to Rust, and we’ll be happy to show how this effort is progressing!

15:30 – Tea Hall – Building a distributed search engine for logs

  • SPEAKER: François Massot
  • LENGTH: 1h
    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.
    This talk will present how to implement such an engine with an efficient architecture strongly inspired by Snowflake which separated compute and storage.

16:30 – Smart Room – Coffee Break

17:00 – Tea Hall – Rust APIs for performance and type safety: a case study

  • SPEAKER: Filippo Costa
  • LENGTH: 1h
    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.

18:00 – Bye, Rustaceans!

DISCLAIMER: this schedule is not definitely confirmed. Sessions and time sessions may change.

Share on