O: $ cargo new surviving Created binary (application) `surviving` package $ cargo add argh sha3 color-eyre Updating 'https://github.com/rust-lang/crates.io-index' index Adding argh v0.1.3 to dependencies Adding sha3 v0.9.1 to dependencies Adding color-eyre v0.5.1 to dependencies Whoa, amos, cool off. Why all the

Nov 17 11:35 /tmp/elf-file-header.svg Whoa, that’s much larger than draw.io’s original svg output! It is! But it looks great in Chrome… And in Eye of Gnome: And where the original SVG referred to the Iosevka font, that one doesn’t: $ xmllint --format /tmp/elf-file-header.svg | grep --color=always Iosevka | head <div style

writing this in assembly!! That sounds cool actually, why don’t we do that? Do th- in assembly? Whoa, whoa, bear, come on, this is just banter, I’m not about to write the whole th- I mean, nah, there’s still a bunch of logic in there that using a higher-level language could be justified, because- Right, right, because having an Addr type with

Docker, because… …because rust-toolchain.toml is not part of the build context. Whoa, these are easy to miss, you weren’t kidding! Yeah! But you know what? Some developers actually love technologies that make it easy to make mistakes, because then there’s always something to do! Every single one of these commits counts towards some metric

does show line numbers in glibc’s “.c” sources, because I installed glibc debug symbols recently, for reasons, but yeah, whoa, look at that output. So anyway, silly me, I freed upp right before printing it, my fingers slipped, luckily this never happens in real life right haha. It would be cool if the compiler could tell me about it at

bytes::complete::take, combinator::map, error::ParseError, IResult}; impl Addr { pub fn parse<'a, E>(i: &'a [u8]) -> IResult<&'a [u8], Self, E> where E: ParseError<&'a [u8]>, { map(take(6_usize), Self::new)(i) } } Whoa, that’s a lot of use directives. Get used to those! Let’s walk through these: Addr::parse is

std::ops::Add; fn main() { println!("ten = {}", add(4, 6)); } fn add<T>(a: T, b: T) -> T where T: Add<Output = T>, { a + b } Whoa hey, that escalated quickly. What’s all that syntax? Don’t worry about it for now. Now that we’ve followed directions, it works, finally: $ cargo run --quiet ten = 10 So - you’re smarter than Rust

beamish boy!" Robin declares the Rust version production-ready, and locks the old C version in the basement, never to be found again. Five years later The Rust style guide checker has served Overbook well. Nobody has complained about it in five years, which, as far as software goes, is admirable. But all good things come to an end (whoa, déjà vu

works! Did we do it? No, you did it. Whoa. I feel smarter already. Okay but, uh, aren’t we still mutably borrowing self twice? No, you’re, uh… no, you’re borrowing different parts of self mutably. That’s perfectly okay. So splitting state is good? Because it makes it easier to track the lifetimes of various things? Very good. Much

state machines are… not fun. For now! Whoa. Thanks cool bear! Don’t mention it