Jon Gjengset @jonhoo@fosstodon.org

We didn't actually make the cargo crate compile faster, but we did explore pretty much every tool that might help you reduce your #rustlang crate build time. And found that the tools still have some ways to go to produce actionable information 😅
https://www.youtube.com/watch?v=pMiqRM5ooNw

I... accidentally another 7 hours video on implementing hazard pointers in #rustlang. Implemented some neat optimizations added to folly since last time, and then added some tests with loom!
https://www.youtube.com/watch?v=tGn0mQF0804

Forgot to post here! The Crust of #rustlang stream on async/await is now up! My hope is that it's a bit more approachable than the deep-dive video I did a while ago, and that it provides some of the intuition and mental model that comes in handy when _using_ async/await. https://www.youtube.com/watch?v=ThjvMReOXYM

Part two of the Hazard Pointer in #rustlang implementation series now up — get it while it's fresh 🦀 https://youtu.be/_LK7qvBWNYo

Recording of today's stream on implementing hazard pointers in #rustlang is up! We actually got to running tests, which is good progress for the first iteration. Still some known TODOs and missing features, but a great start! https://youtu.be/fvcbyCYdR10

I'm writing a #rustlang book! The full announcement is over on Twitter (sorry): https://twitter.com/jonhoo/status/1399824695600418817

The video of our first steps into implementing "A Practical Wait-Free Simulation for Lock-Free Data Structures" in #rustlang is up! I miss these longer streams — they're a lot of fun. Still some way to go, but we made good progress! https://youtu.be/Bw8-vvtA-E8

I'm very happy with how today's stream on atomics and memory ordering in #rustlang turned out. Hopefully this'll help clear up the confusion and mystery that surrounds the std::sync::atomic module, and allow more people to write good concurrent code! https://www.youtube.com/watch?v=rMGWeSjctlY

My Crust of Rust episode on subtyping and variance in #rustlang is now up at https://youtu.be/iVYWDIW71jk. Even though it's a thorny topic that I'm fairly new to myself, I _think_ we managed to explain the concepts and their practical implications without too many 🍿 moments.

My segment on New Relic's "The Relians" 24h stream is now up on https://www.twitch.tv/videos/897132746! My stream partner, Aisha Blake, started out with no #rustlang experience, yet we got all the way to a CSV-to-JSON converter 🎉 Good stream for anyone curious about this "Rust thing" coming from the world of JavaScript 🍿

First episode of The Unsafe Chronicles is now up on YouTube! We talk through some particularly funky unsoundness around aliasing a #rustlang Box, and how to deal with it the context of the left-right concurrency primitive. https://www.youtube.com/watch?v=EY7Wi9fV5bk

I'm going to try out a new type of #rustlang stream on Saturday @ 6pm UTC (https://everytimezone.com/s/86025e61): "The Unsafe Chronicles". The idea is to go through an interesting experience with unsafe Rust code and how to fix it. It'll be more "explainer" than "coding" like my usual streams — but will hopefully be interesting nonetheless!

Recording of today's #rustlang stream on making the concurrency primitive behind evmap's fast concurrent reads generic is now up! I think it turned out pretty great, and am excited to see what people might do with it! https://www.youtube.com/watch?v=eLNAMEoKAAc

The PR (which still needs some cleanup before it'll land) is here for anyone who just wants to see where we ended up: https://github.com/jonhoo/rust-evmap/pull/73

Recording of yesterday's Crust of Rust stream is now up! We made our way through #rustlang implementations of bubble-, insertion-, selection-, and quicksort, and also benchmarked them all. And, crucially, we covered a bunch of Rust topics along the way! https://www.youtube.com/watch?v=h4RkCyJyXmM

I'll be doing another Crust of Rust stream on sorting implementations this weekend. I'm thinking that since the algorithms are well-known, we can focus specifically on various #rustlang-isms! The stream will be Saturday at 6pm UTC: https://everytimezone.com/s/15d26ae2. As usual I'll stream to both Twitch and YouTube, and upload the recording to YouTube after. This stream should hopefully be ok to follow even if you come from another language, so if you've been on the fence, now's a good time to watch 🍿

Today's stream on #rustlang channels is now up! We built our own unbounded mpsc channel using Mutex and Condvar, and talked about synchronization, different channel types, and other possible implementations along the way. Hope you learn something! https://www.youtube.com/watch?v=b4mS5UPHh20

Time for another stream! In tomorrow's Crust of Rust we'll cover a simplified version of #rustlang's mpsc channel type, plus some discussion of other channel implementations. The stream will be on YouTube and Twitch at 8:30p UTC as usual (https://everytimezone.com/s/076c2397). See y'all there!

The Crust of Rust episode on Rc/RefCell/Cell and Arc/RwLock/Mutex is now up — get it while it's hot! We covered #rustlang smart pointers and interior mutability, and even did a quick-dive into UnsafeCell and the Drop Check 😮 https://www.youtube.com/watch?v=8O0Nt9qY_vo

Several of you have asked me for a Crust of Rust on smart pointers (Arc/Rc/Deref) and interior mutability (RefCell/Mutex/Cell) in #rustlang, and I think it's about time. Let's do a stream on Wednesday at 8:30p UTC (https://everytimezone.com/?t=5ee95d00,4ce) as usual. Come one come all! 📺 🦀

Yesterday's Crust of Rust on #rustlang iterators and trait bounds is now on YouTube, fresh out of the oven (literally; my apartment was ~95°F at the end). We re-implemented Iterator::flatten, including the DoubleEndedIterator parts! 🥧 https://www.youtube.com/watch?v=yozQ9C69pNs