Property-testing async code in Rust to build reliable distributed systems - Antonio Scandurra

🔔 FOLLOW RUSTLAB CHANNEL 🔔
ABSTRACT:
Building reliable distributed systems is extremely challenging. Every await point in a codebase creates an explosion of possible execution sequences, some of which only occur in rare circumstances. If a buggy sequence occurs 1% of the time, you'll be plagued with production bugs and intermittent CI failures that are extremely hard to reproduce. The only solution is to test every possible sequence, but how?
This talk will explain how Zed Industries leveraged Rust's unique asynchronous programming model to maximize the reliability of our CRDT-based collaborative editor. After reviewing the foundational concepts of Rust futures, we'll explore an implementation of a deterministic runtime that executes all possible permutations of asynchronous code paths. We think this represents a game-changing strategy for rapidly developing reliable concurrent systems, and by the end of the talk, you'll be equipped with practical tools to bring the same level of reliability to your own applications.
This channel is dedicated to the videos of the RustLab conference.
⚙️ Follow us on TWITTER:
/ rustlab_conf
⚙️ Follow us on FACEBOOK:
/ rustlabconference
RustLab is the first Italian international conference on the Rust programming language, organized by Develer.
Develer is not just an Italian company projecting and releasing hardware and software solutions for the industrial environment, but is also an ensemble of people sharing their great passion for new technologies and how they can be applied to your everyday life.
⚙️ Follow DEVELER on INSTAGRAM:
/ wearedeveler
⚙️ Follow DEVELER on FACEBOOK:
/ we.are.develer
⚙️ Follow DEVELER on TWITTER:
/ develer
⚙️ Follow DEVELER on LINKEDIN:
/ 114426
⚙️ Follow DEVELER on TELEGRAM: t.me/wearedeveler
⚙️ Follow DEVELER on TIK TOK:
/ wearedeveler

[@no-bias-]

Great talks! looking forward to tech talk like this especially on the chaos testing with Rust.

[@patmelsen]

Been looking forward to watching this talk. I think property testing is an incredibly useful tool to have in your belt, and the ability to combine it with futures execution ordering is really useful. This means you can basically get some features that you would get from formal verifications systems (promela, TLA+) for *free* in Rust! At least for promela, it works simply by trying out all possible permutations of orderings and ensuring your assertions hold. Combining property testing with execution ordering achieves the same. How awesome is that?

[@sirgibsonable]

I didn't follow the bug at ~4:00. Wouldn't flipping the order of request handling and the connection checking have the same issue afterward (if a connection happens while deserializing the server response)?

[@thomasw.4298]

Don't tokio's file/net handles require to be run exclusively on the tokio runtime? If you have a Tokio::net TcpStream and run it on a home brew executor, wont it not work? I think it throws an error when it can't detect the tokio runtime. Is this where the mocks come in?