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.
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.
The talk explores how Rust’s type system and memory safety can be leveraged to enforce mandatory guardrails at the infrastructure level, where traditional frameworks often fall short.
This talk puts popular Rust rewrites to the test. We'll examine how these tools stack up against their battle-tested predecessors, looking at real-world performance, compilation times, binary sizes, feature completeness, and ecosystem maturity.
What if we took Rust... on-chain? 🦀
This talk explains how Rust debugging actually works: how compiler-generated debuginfo (DWARF/PDB) maps binaries back to source, and how LLDB/GDB interpret that data in practice.
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.
