Schedule

Sunday 2nd October (Workshops)*

* WORKSHOPS WILL BE ACCESSIBLE ONLY IN PRESENCE: THEY WILL NOT BE STREAMED OR RECORDED.

13:00 Registration


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

  • SPEAKER: Marco Ieni
  • LENGTH: 3h
  • ABSTRACT:
    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.
  • DESCRIPTION:
    This workshop consists of a series of interactive exercises (similar to [rustlings](https://github.com/rust-lang/rustlings)) that will guide you through creating an HTTP API iteratively.
    The API will:
    – Receive a Star Wars character name in input.
    – Call [swapi](https://swapi.dev/), 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](https://docs.rs/reqwest/latest/reqwest/).
    – Build an HTTP API by using [axum](https://docs.rs/axum/latest/axum/).
    – Handle errors by using [thiserror](https://docs.rs/thiserror/latest/thiserror/) and [anyhow](https://docs.rs/anyhow/latest/anyhow/).
    – Use [tracing](https://docs.rs/tracing/latest/tracing/) for logs and traces. You will visualize traces by running [jaeger](https://www.jaegertracing.io/) locally.
    – Write tests by mocking external APIs with [wiremock](https://docs.rs/wiremock/latest/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.
    Have you played with Rust before but aren’t comfortable writing Rust backend code yet?
    Then this workshop is for you!
    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.

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

  • SPEAKER: Edoardo Morandi
  • LENGTH: 3h
  • ABSTRACT:
    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.
  • DESCRIPTION:
    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](https://en.wikipedia.org/wiki/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`](https://docs.rs/futures/latest/futures/prelude/trait.Stream.html) 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 – Location – Social Event #1 TBA


Monday 3rd October

8:30 – Registration


10:00 – Smart Room – Welcome Coffee


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

  • SPEAKER: Alice Ryhl
  • LENGTH: 1h
  • ABSTRACT:
    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 – Coffee Hall – Get the best of both worlds – Integrating Rust with other languages

  • SPEAKERS: Harald Reingruber, Fred Morcos
  • LENGTH: 1h
  • ABSTRACT:
    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 – Coffee Hall – TBA


13:30 – Acero Rosso – Lunch


15:30 – Coffee Hall – Building a Kubernetes monitoring dashboard in Rust. Why not?

  • SPEAKER: Deepu K Sasidharan
  • LENGTH: 1h
  • ABSTRACT:
    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:30 – Coffee Hall – Extending Redis with Rust

  • SPEAKER: Brian Sam-Bodden
  • LENGTH: 1h
  • ABSTRACT:
    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:30 – Smart Room – Coffee Break


18:00 – Coffee Hall – Dockerising and deploying a full stack Rust + WASM web app

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

20:00 – Location – Social Event #2 TBA


Tuesday 4th October

9:00 – Registration


9:30 – Smart Room – Welcome Coffee


10:00 – Tea Hall – Keynote: TBA


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

  • SPEAKER: Marco Napetti
  • LENGTH: 1h
  • ABSTRACT:
    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 – Coffee HallWeb Of Things and Rust

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


15:00 – Coffee Hall – Oxidizing rpm-ostree

  • SPEAKER: Luca Bruno
  • LENGTH: 1h
  • ABSTRACT:
    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!
    https://github.com/coreos/rpm-ostree

16:00 – Coffee Hall – Building a distributed search engine for logs

  • SPEAKER: François Massot
  • LENGTH: 1h
  • ABSTRACT:
    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.

17:00 – Smart Room – Coffee Break


17:30 – Coffee Hall – Rust APIs for performance and type safety: a case study

  • SPEAKER: Filippo Costa
  • LENGTH: 1h
  • ABSTRACT:
    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:30 – Bye, Rustaceans!


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

Share on