TIL "immutable variable" is a contradiction. "variable" means it can change, and "immutable" means it can't.

I made it through the wilderness Somehow I made it through Didn't know how lost I was Until I found #rustlang I was beat, incomplete I've been had, I was sad and blue But #rust made me feel Yeah, #rust made me feel Shiny and new

I recommend enhancing go's panic on nil pointer message: panic: runtime error: nil pointer dereferences can be avoided in #rustlang, but not #golang, and this code dereferenced one at runtime and the code didn't bother to check, and the reviewer didn't catch it either. Use a better language.

TIL about i64::div_euclid. So many ways to do math in rust. doc.rust-lang.org/std/primitiv...

I need to make this bumper sticker! Any suggestions for an online site to do it?

The next person who tells me rust is too verbose will get this post. TIL that in #javascript, parseInt(0.0000005) results in 5. Here's the equivalent in rust. Definitely too verbose. play.rust-lang.org?version=stab...

#rustlang discourages basic math -- addition, subtraction, etc! Why is that? Because off-by-one errors and overflow errors are a major source of bugs. Enable this lint and use checked operations instead of just raw math. rust-lang.github.io/rust-clippy/...

#rustlang iterators are so amazing. Do you know what an ExactSizeIterator is and a FusedIterator?

Just like a junior engineer, AI is really bad at rust error handling.

Hire or don't hire? Gave the classic "two-sums" problem, where you try to find offsets of elements that sum up to some target value. Here's their rust implementation, rolled out quite quickly.

Please. Same time tomorrow is not `now += hours(24)`. There are *NOT* 24 hours in every day. Some days have 23 and some have 25, assuming you live in a region where this horrible thing called Daylight Savings Time exists, which is in ~40% of all countries, affecting ~15% of the world population.

Glad it's Friday. Please, no more #golang next week. `go vet`, codeql, `go race`, `golangci-lint`, oh my! So many things to check. What am I missing? To be fair, in #rustlang you have to do `cargo fmt -- check` and `cargo clippy`

Writing some #golang code today. Feels so painful. Renaming a function to change it's visibility feels so wrong.

Back from Avalanche Summit in London! So happy to present my project. Ran into a few #rustlang enthusiasts as well. Of course, the perf numbers tell the story for me.

Super insightful response. The memory model rust wants you to use is actually also friendly to the garbage collector as well

Today's word of the day from worddaily.com is rubiginous, which describes my code recently. #rustlang

Cursor's ability to rewrite from #rustlang to #golang seems better than the other way around. I wonder if it's because there are fewer examples of good rust code than go for the LLM.

Great #golang article: analyticsindiamag.com/ai-features/... "Rust continues to dominate in areas where performance and safety are non-negotiable, albeit with a steeper learning curve.". #rustlang

One of the things that is medium level annoying in Rust is that sometimes it fails to communicate to you how easy your problems are if you just used that other method that also exists. I didn't programm in this language for a few months, forgot everything about file ops and there were far too many

Learning #rustlang combinators was a slow process. Coworker reminded me of learning the subtle differences between things like `unwrap_or` and `unwrap_or_else`. While these are well documented, there's some cognitive load and learnings in languages other than #golang.

Ooh, nifty! `rustup` updates itself. Unfortunately, it doesn't tell you which version it is updating to so you can read the release notes. So if you see: info: checking for self-update info: downloading self-update Then head over to github.com/rust-lang/ru... to see what you got.

Grokable? #rustlang

Quiz question! #rustlang code: let a = 0; What type is `a`?

@malware.delivery Profile says you're looking for work... any rust backend interest?

I officially declare myself a lousy #golang code reviewer. I seem to look at the code and go "wow, #rustlang would never have let this compile" far too often at this point.

Looking at a #golang code review, which clippy would have just told you if it were in #rust. Some interesting comments: "(leaving comment for later): the logger is unused" [warn(unused_variables)] #rustlang

True or false? #golang outshines #rustlang for cross compilation.

Today's #golang gotcha: you really need to call runtime.Keepalive on all pointers passed to C, otherwise the garbage truck can make a mess of your pointers, as there might be no references to it after that.

#golang developers are so used to having to handle `err` as a bunch of code, whereas in #rustlang you have a really nice `Result<T, E>` that you can treat as a single thing, using all kinds of transformations.

I'm speaking at www.avalanchesummitlondon.com about #firewood! #avax #avalanche #summit #avalanchesummit2025 #avalanchesummitlondon

Love teaching #rustlang, especially to #golang peeps Replacement for all the code in the pic is: db.root_hash_sync()?.unwrap_or_else(|| "no root hash".into())

Sent today to someone learning #rustlang: in rust you have to be much more concerned about when things are dropped than you do in #golang. Things are dropped in golang when there are no references and the garbage collector comes along.

#rustlang peeps, is this unreadable and is there a better way to write this? I want to handle overflows! Without overflows, this is just some subtractions, multiplications, and divisions.

Blockchain block storage is really simple. Working on a design to speed things up dramatically!

On a call today, a really good engineer said "oh too hard to call #rustlang from #golang" so I quickly whipped up an example: github.com/rkuris/block... It's only hard if you have a big surface area. Or you don't know how to make unsafe code safe (see the last commit for how I did it).

Whoa, #golang lint that isn't implemented in #rustlang clippy? I'm thinking about implementing it!

Completely convinced the software engineering discipline required to write #rustlang is higher than that required to write #golang which is higher than that required to write #python.

Today's fiasco: I rewrote a section of golang code in #rustlang, only to find out that that algorithm is already implemented in a crate, a pretty nifty one: crates.io/crates/range... A search for a similar crate in #golang yielded no results. Are there just more algorithms in rust than golang?

Whatsapp sucks. I got a message from "WhatsApp", the Official WhatsApp account that looks like this:

Just tested #rustlang #firewood on various filesystems. Inserting 10M rows on zfs took 20m10s. Same thing on e2fs was 2m11s, or 10x faster. No filesystem (raw disk) was 2m1s. Why is zfs so slow? I'm going to attempt to tune it some tomorrow.

The moment you know #rustlang AI is lost. I let it run for about 30 minutes after this before telling it to give up.

#rustlang has too many things named Error. std::io, std::error, std::fmt, serde::de, serde::de::value, ... If you want the trait, you have to know it's std::error. I get why they did this: it's nice to have specific errors, but it makes learning error handling in rust harder.

#rustlang has no garbage collector because it has no garbage. Let's fine #golang for littering.

Uh, #rustlang is NOT a Tesla, as much as #golang is NOT a skateboard. Hmm, maybe if while you ride the skateboard, you stop every so often to collect garbage, stop every now and then to make sure the wheels aren't nil, and fall over every time you hit a concurrency bug.

If you really want to love #rustlang, convert some #golang into rust. This function github.com/ava-labs/ava... becomes infallable.

I hate that #rustlang moment when you are attempting to resolve a merge conflict and search for the "end of diff" marker ">>>" and it finds a line like this instead: match <Arc<ArcSwap<NodeStoreParent>> as arc_swap::access::DynAccess<Arc<_>>>::load(

I love watching this video www.youtube.com/watch?v=ZTPr... over and over again, which made me realize that #rustlang is just now hitting critical mass, and #golang is on the downward trend. Still surprising to see so much python and it still hasn't reached its peak.

TIL in #rustlang there are actually three output formatting traits: Debug, Display, and Binary. Yep, fmt::Binary is a thing. doc.rust-lang.org/std/fmt/trai...

Today's fun: the #golang cache for my project is corrupt. I've never seen a corrupt #rustlang cache. Lemme guess: the go cache was written in golang and the rust cache was written in rust?

Interesting #golang vs #rustlang article, as the point is correct but the examples and usage aren't as great as they could be. medium.com/@bryan.hylan...