Atomics party.

Join Our "Atomics" Party in London!

Ok. Now that I got your attention...

Remember that slightly weird individual who stood up at the Rust London Meetup last week and announced he wanted to start a study group for "Rust Atomics and Locks"? Well, that was me, and surprise – I wasn't kidding! 🎉

What's All This About?

We're diving headfirst into Mara Bos's brilliant book Rust Atomics and Locks, Low-level concurrency in practice. This isn't your typical "Hello World" Rust tutorial – oh no, we're going straight for the deep end where threads dance, mutexes party, and memory ordering becomes our new best friend (or worst nightmare, depending on your perspective!).

For those who don't know, Mara Bos is the Rust concurrency expert – she's the team lead of the Rust library team and knows more about low-level concurrency than most of us. The book promises to teach us everything from basic thread safety to building our own synchronisation primitives from scratch. No pressure, right? 😅

Where & When?

We will start very openly and relaxed, with not too many plans and rules —aka, I have no idea how to do it. 😅

Despite the jokes, I'd like to extend the group to people who can't physically attend the meetups in London and have no or limited experience with Rust. To do so, I'm thinking of starting digital while keeping the in-person meetings at the "Hack & Learn" sessions at the Rust London User Group, a community of more than 3000 Rustaceans in the core of London.

The Hack & Learn format is ideal for our study group – it's designed for collaborative learning, working on projects together, and delving deeply into challenging topics. Plus, there's something beautifully meta about learning concurrency in a concurrent learning environment! 🤯

Our Digital Playground

All our code examples, discussions, and, likely, our collective tears of confusion will reside in the shared GitHub repository. Think of it as our digital campfire where we'll gather to share war stories about deadlocks and celebrate those sweet, sweet race condition victories!

I'm considering using GitHub issues to manage requests and feedback. I will start writing the README soon to share the instructions with everyone.

Why Join This Beautiful Chaos?

Study groups are a great way to tackle complex technical topics. Here's why this particular adventure is worth your time:

• Collaborative Learning: Two (or more) brains wrestling with memory ordering are better than one
• Accountability: It's harder to give up when you have study buddies expecting you to show up
• Diverse Perspectives: Everyone brings different experiences and "aha!" moments to share
• Practical Application: We'll be building actual concurrency primitives, not just reading about them
• Safe Space for Confusion: Because let's be honest, atomics can be mind-bending, and it's okay to admit it!

What to Expect

We'll follow the "Build Our Own X" approach that the book champions. Each chapter focuses on constructing fundamental concurrency primitives from scratch – spin locks, channels, reference counting, and more. Think of it as LEGO for systems programmers, but with more potential for subtle bugs and existential crises!

The study format will likely include:

• Chapter reading and studying, this is the only part that I think is better to do alone
• Chapter discussions (because someone needs to explain what the heck memory ordering actually means)
• Code walkthroughs (live debugging sessions, anyone?)
• Practical exercises (where theory meets the harsh reality of compiler errors)
• Show and tell moments (celebrating when our atomic operations work!)

Perfect for All Levels

Whether you're a Rust newbie curious about concurrency, Rust or both, or you are a seasoned systems programmer wanting to understand Rust's approach to low-level parallelism, this book and study group have something for you. Mara Bos designed the content to be accessible to "Rust programmers of all levels". However, we'll all be beginners when it comes to the more esoteric memory ordering semantics! 😄

Ready to Join the Atomic Party?

If you're excited about:

• Understanding how mutexes actually work under the hood
• Learning why memory ordering isn't just academic nonsense
• Building concurrent data structures that don't randomly explode
• Impressing your colleagues with deep knowledge of processor cache coherency (okay, maybe not impressing, but definitely confusing them)

Then come join the dark side—ops, I mean, join our study group, and if you can, let's meet at the next Rust London Hack & Learn session! Look for the group of people staring intensely at laptops, muttering about "acquire-release semantics" and occasionally making excited noises when their atomic compare-and-swap operations work correctly, while eating (a lot) of pizza and drinking coffee (espresso, of course).

The Fine Print

⚠️ Warning: Side effects may include but are not limited to: sudden understanding of why debugging concurrent code is an art form, uncontrollable urge to optimise everything with atomics, and the ability to explain why "it works on my machine" takes on a whole new meaning in concurrent programming. No milk, soya or nuts have been used to make this post.

But seriously, concurrent programming is one of the most challenging and rewarding aspects of systems development, and Rust's approach to making it safer and more ergonomic is genuinely revolutionary. This study group is our opportunity to gain insight into the magic behind the scenes.

See you in the threads! Happy hacking 😉