Firenze
November 9th, 2024
November 11th, 2024

Schedule

We've been working tirelessly for months to bring the best and brightest minds in the industry to RustLab.

This version is not definitive: from now to November there will be some minor changes or some additions (we are still working on the social events) but these are going to be the main features of the conference.

See you there!

November 9th, 2024

Day 1
Grand Hotel Mediterraneo
08:30
Registration desk
Networking time

Registration

09:30
Workshop #1
min
workshop

TBA - McNamara

TBA

Workshop #2
180
min
workshop

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

Workshop #3
min
workshop

TBA

TBA

Workshop #4
min
workshop

TBA2

TBA

11:00
Coffee break room
Networking time

Coffee break

13:00
Lunch Room
Networking time

Lunch

14:30
Workshop #2
180
min
workshop

Cooking up with TUIs with Ratatui

Do you like terminal UIs? Do you like Rust?
Join us in this workshop to become a terminal chef and master the art of cooking up delicious TUIs with Ratatui!

LEVEL: Intermediate

Workshop #3
180
min
workshop

Let's build our first Bevy game!

From a starter kit to a playable game, you'll discover the ECS, input management, shader development, ...

LEVEL: Intermediate

16:00
Coffee break room
Networking time

Coffee break

November 10th, 2024

Day 2
Grand Hotel Mediterraneo
09:15
Registration desk
Networking time

Registration

09:45
Main Hall
Networking time

Conference presentation

11:00
Coffee break room
Networking time

Welcome coffee

11:30
RustLab Discovery
25
min
talk

Design and Implementation of the `#[diagnostic]` attribute namespace

This talk will introduce the `#[diagnostic]` attribute namespace. We will go through all the steps starting with designing a new language feature up until proposing stabilisation.

LEVEL: Advanced

RustLab Deep
40
min
talk

Exploring lending async iterators

I will define the trait for lending async iterator, which lifts the idea of lending iterators over the async/await realm. Starting from there, I will show the usefulness of the concept, especially in embedded systems, and the problems that comes up with both stable and unstable Rust.

12:30
RustLab Discovery
25
min
talk

Borgo – a Rusty language that compiles to Go

Over the past couple of years I've been working on a new programming language which has recently seen a surge in interest. I'd like to present the ideas behind it and the lessons learned in tackling my first real-world Rust project.

LEVEL: Introductory and Overview

RustLab Deep
40
min
talk

Fast and efficient network protocols in Rust

Elfo (https://github.com/elfo-rs/elfo) is a distributed actor system which can send messages between nodes. For this to work, we implemented a custom networking protocol entirely in Rust with support for compression and TCP-style flow control. In this session, we will dive deep into all the technical details and challenges we faced along the road. Strap in!

LEVEL: Intermediate

13:00
RustLab Discovery
25
min
talk

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

13:30
Lunch Room
Networking time

Lunch

15:00
RustLab Deep
40
min
talk

Don't panic! - Our journey to error handling in Rust

This session will talk about how the transition of our team at Microsoft from C# to Rust reshaped our error handling strategies. Gain insights into the team's journey as we navigated new paradigms, transforming chaos into stability. We will explore how this shift in mindset revolutionized our approach to coding, offering valuable lessons for the team.

LEVEL: Introductory and Overview

15:30
RustLab Discovery
25
min
talk

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

17:00
Coffee break room
Networking time

Coffee break

17:30
Main Hall
40
min
talk

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

Day 3
Grand Hotel Mediterraneo
08:30
Registration desk
Networking time

Registration

10:00
RustLab Discovery
25
min
talk

Chips don't bite! A fearless introduction to µController programming for Rusteaceans

This talk will introduce Rusteaceans, who have not tried out microcontroller programming, to the embedded Rust ecosystem. It will give a perspective on how exploring this space can be done fearless and will gain them new perspectives that will allow them to grow as developers.

The central message of the talk is "you don't need to be afraid" as the compiler and tooling will keep you on the right track, and if you get stuck there is a very friendly community that can help you.

LEVEL: Introductory and Overview

RustLab Deep
40
min
talk

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

11:00
Coffee break room
Networking time

Coffee break

11:30
RustLab Deep
40
min
talk

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

12:30
Lunch Room
Networking time

Lunch

14:00
RustLab Deep
40
min
talk

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

15:00
RustLab Discovery
25
min
talk

Profile-Guided Optimization (PGO) for Rust applications: Practical Guide

This is the second talk in my series about PGO. The first one will be presented at OxidizeConf and RustFest Zurich - the talk about PGO overview: what is it, PGO kinds, etc.

This talk is about practical PGO usage for Rust applications. How PGO can and should be integrated, PGO-related documentation in projects, review of multiple examples about how PGO is integrated into different projects right now with discussion about pros and cons in each situation, etc.

During the talk, I expect to discuss as much as possible practical pieces of advice about PGO for Rust applications. I think after the talk Rust engineers will know many things about PGO in practice.

LEVEL: Intermediate

RustLab Deep
40
min
talk

Crafting a Linux kernel scheduler in Rust

In this talk I will show my journey on how to implement a fully functional Linux scheduler in Rust that runs in user-space, channeling all the scheduling events and communication from kernel space to user-space (and vice-versa) using sched-ext and eBPF.

LEVEL: Advanced

16:00
Coffee break room
Networking time

Coffee break

17:30
Main Hall
Networking time

Goodbye Rustaceans!

RustLab is a conference made by Develer.
Develer is a company based in Campi Bisenzio, near Florence. Our motto is : "Technology to give life to your products". We produce hardware and software to create exceptional products and to improve industrial processes and people's well being.
In Develer we have passion for the new technologies and we offer our clients effective solutions that are also efficient, simple and safe for the end users. We also believe in a friendly and welcoming environment where anybody can give their contribution. This passion and this vision are what we've been driven to organize our conference "made by developers for developers".

Subscribe to our newsletter

We hate spam just as much as you do, which is why we promise to only send you relevant communications. We respect your privacy and will never share your information with third parties.
©2024 RustLab | The international conference on Rust in Florence-Design & devCantiere Creativo-Made withDatoCMS