LOADING
We’ll take a deep dive into Rust channels — from synchronous channels to asynchronous channels — to explore how message passing enables reliable concurrent programming.
Concurrency in Rust is powerful, but safe and efficient communication between tasks can be tricky to master. In this talk, we’ll take a deep dive into Rust channels — from synchronous channels to asynchronous channels — to explore how message passing enables reliable concurrent programming.
We’ll start with simple synchronous channels and examine common patterns for multi-producer and multi-consumer setups. Then we’ll move to asynchronous channels in Rust’s async ecosystem, showing how channels coordinate tasks in real-world systems. Along the way, we’ll discuss backpressure, error handling, and performance trade-offs, with practical examples inspired by cloud-native workloads like Kubernetes operators, runtime schedulers, and event pipelines.
Attendees will see live demonstrations of channels in action and learn how Rust’s ownership and type system ensures safety while enabling scalable, reliable concurrency. We’ll also compare different channel strategies and patterns to illustrate where design choices impact performance and simplicity.
Attendees will leave with:
- A clear understanding of how synchronous and asynchronous channels work in Rust
- Patterns for multi-producer, multi-consumer messaging- Insights into handling backpressure and errors safely
- Practical knowledge for building scalable, concurrent systems
- Confidence applying Rust channels in real-world cloud-native and async workloads
This talk provides a practical, approachable exploration of Rust channels, empowering developers to write safer and more efficient concurrent Rust programs.
In this talk, we’ll re-create the core ideas of Karpathy’s micrograd, but entirely in Rust.
I’ll share what the Rust job market really looks like in 2025 — where companies are hiring, which skills stand out, and how the recruitment process actually works behind the scenes.
In 2024, I added the `Option::as_slice` and `Option::as_mut_slice` methods to libcore. This talk is about what motivated the addition, and looks into the no less than 4 different implementations that made up the methods. It also shows that even without a deep understanding of all compiler internals, it is possible to add changes both to the compiler and standard library.
I'll initiate you in the art of 'CAN bus sniffing': Connecting to the central nervous system of a modern car, interpreting the data, and seeing what we can build as enthousiastic amateurs.
For infrastructure engineers, SREs, platform teams, and Rust developers who've felt the pain of configuration drift, failed deployments, and infrastructure code that simply doesn't scale safely.
