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
The second Crust of Rust video is up! We went over how to implement the vec! macro, including how to get it to efficiently pre-allocate memory for the provided elements. Get it while it's hot! 🥧 #rustlang https://youtu.be/q6paRBbLgNw
The Crust of Rust mini session on lifetimes seems to have been helpful, so let's do more! I'll cover declarative macros (macro_rules!) on Wed at 8:30p UTC (https://everytimezone.com/s/2761f055). As before, it'll assume you have some #rustlang
experience already, but anyone is welcome ❤️ 🥧 Just like always, the stream will be live on https://youtube.com/c/JonGjengset/live on https://twitch.tv/jonhoo, and I'll upload it to YouTube after :)
The recording of my first #rustlang mini session is now up! We covered lifetime annotations through a real code example, and people seemed to follow along and understand why the lifetimes were needed and how they worked 🎉 Watch it at https://www.youtube.com/watch?v=rAl-9HwD858&list=PLqbS7AVVErFiWDOAVrPt7aYmnuuOLYvOa.
In about 6 hours, I'll do a shorter and more beginner-friendly #rustlang stream on multiple lifetimes, strings, and some generics. As usual, the stream will be live on https://twitch.tv/jonhoo and https://youtube.com/c/JonGjengset/live, and I'll upload it afterwards. While it'll be *more* beginner-friendly than my usual streams, it won't be *introductory*. I'll assume that you've read the Rust book, and that you have written some Rust code. But as always, anyone is welcome, so stop by even if just to say hi ❤️
Recording of the Noria stream is up! I think it went well — people seemed to follow the system design and the bug we ended up partially fixing, even though it was quite technical! If you're stuck at home and craving some research-y #rustlang, give it a try: https://www.youtube.com/watch?v=kiMUI0y91YI. You can find the project website with code, papers, and other related material at https://github.com/mit-pdos/noria
It seems like there's a lot of interest in a live-stream where I work on Noria, my research database written in #rustlang. So, I will do one *tomorrow* at 8:30pm UTC (4:30p Eastern; https://everytimezone.com/s/c34ddd6c) on YouTube and Twitch as usual. Come do research with me 🤓