Valentyn Kit

Spent the week reading readahead heuristics written before I started programming. They still guess right on hardware that did not exist when they were written. There is a kind of care in old kernel code that I do not often find in what I have shipped for money.

A Rust one. You lock a mutex but bind the guard to _, then lock the same mutex again in the same scope. Does it deadlock? Worth checking whether it gets that far.

A Rust one for you: iterate a HashMap with a for loop, and inside the loop remove the exact key the loop is currently on. Does it compile? If you think it does, what happens when you run it?

Rust: let x = -1i32 as u8; Does it compile, and what prints? Answer in a bit.

Same program, two outputs: 255u8 + 1 panics under cargo build, prints 0 under --release. Defined wrap, not UB. overflow-checks = true if you want release to panic too. wrapping_add if the wrap is the point.

Rebuilding my Redis clone's AOF in Rust. BufWriter erases the buffering discipline C forced on me. But flush() only reaches the kernel, sync_all() is what reaches the disk, and Drop's automatic flush ignores its error. The mechanics compile away; the durability policy doesn't.

Vec::new() never touches the heap. Capacity stays 0 until the first push, then 4 for small types, doubling after. Free to create, pay on first write. I'd used it for years without checking where the first allocation actually lands.

A Rust one: a map with a println inside, then a final println. Compiles, one warning. What prints? Answer in a bit.

I'm learning Rust by writing C. Backwards, I know. But every Rust feature answers a specific C pain, and you don't feel the answer until you've felt the pain. Write the manual error check 50 times in C, and ? stops being syntax and starts being relief.

I spent a week fighting "expected String, found &str" before it clicked. String owns its bytes on the heap and can grow. &str borrows a view into bytes someone else owns. The rule that ended it: take &str in args, return String when you built it.

A week of C reminded me what one character buys in Rust: the ? Every C syscall ends the same. Returned -1? Read errno, decide fatal or retry, handle it. Copy-pasted around every read and write. Rust folds that whole ritual into ?, a check you can't forget.

I froze my own TCP server for 1.51 seconds with one idle connection. No load. One client just holding the line. A second connected and waited 1.5s for a reply. That's when I actually understood why event loops exist. Not from a blog, from breaking it myself.

Rust puzzle. Does this compile? If you think it runs, what does it print?

"Rust is hard" is mostly the first time a language makes you be honest about who owns your data. C didn't make ownership simpler. It just let you ship the bug and find out in production.

Rust puzzle. Does this compile? If you think it runs, what does it print?

"How do you serve 10,000 clients with one program?" A 25-year-old question, the C10K problem. The answer is a ladder of I/O models. Each rung fixes the wall the last one hit. I rebuilt all seven in C this week, blocking up to epoll, to feel every wall myself.

"Rust is hard" is mostly the first time a language makes you be honest about who owns your data. C didn't make ownership simpler. It just let you ship the bug and find out in production. #rust

Check out our latest blog post for an interview with Tiffany Pek Yuan, one of the maintainers of the Rust programming language: blog.rust-lang.org/inside-rust/... This is the first in a series of blog posts highlighting our amazing maintainers. 💛

one odd thing about LLMs with programming is like... okay so obviously we all construct English and other human languages and sentences, and it learns from them when it talks but seeing code patterns that it learned that i specifically had a hand in creating is like, wild