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

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

Forgot to post here! The Crust of 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. youtube.com/watch?v=ThjvMReOXY

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

Recording of today's stream on implementing hazard pointers in 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! youtu.be/fvcbyCYdR10

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

I'm very happy with how today's stream on atomics and memory ordering in 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! youtube.com/watch?v=rMGWeSjctl

My Crust of Rust episode on subtyping and variance in is now up at 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 twitch.tv/videos/897132746! My stream partner, Aisha Blake, started out with no 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 Box, and how to deal with it the context of the left-right concurrency primitive. youtube.com/watch?v=EY7Wi9fV5b

I'm going to try out a new type of stream on Saturday @ 6pm UTC (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 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! youtube.com/watch?v=eLNAMEoKAA

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

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

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 -isms! The stream will be Saturday at 6pm UTC: 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 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! youtube.com/watch?v=b4mS5UPHh2

Time for another stream! In tomorrow's Crust of Rust we'll cover a simplified version of '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 (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 smart pointers and interior mutability, and even did a quick-dive into UnsafeCell and the Drop Check 😮 youtube.com/watch?v=8O0Nt9qY_v

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

Yesterday's Crust of Rust on 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! 🥧 youtube.com/watch?v=yozQ9C69pN

Show older
Fosstodon

Fosstodon is an English speaking Mastodon instance that is open to anyone who is interested in technology; particularly free & open source software.