Did you know that in Rust, 'let _ = ...' and 'let _unused = ...' are NOT the same thing?
I didn't until today!

gaultier.github.io/blog/rust_un...

#rust

I just implemented light mode/dark mode on my blog, using modern css features like variables and the ‘light-dark()’ function.
Surprisingly easy, try it!

gaultier.github.io/blog/
#css #blog

Frog and Toad with a box illustration. Badly edited text. Frog put the KEY in a box. "There," he said. "Now we will not SIGN MALICIOUS MESSAGES." "But we can ASK THE HSM," said Toad. "That is true," said Frog.

The production bug that made me care about undefined behavior. New blog article fresh out of the oven.
gaultier.github.io/blog/the_pro...
#cpp #bug

New blog article!
Detecting goroutine leaks with DTrace: gaultier.github.io/blog/detecti...

#golang #dtrace

IMO it’s cruel to the users of your language because they will typically first suffer from data races way down the line, when the codebase is big and hard to modify to adopt thread safety principles.

Things that help: immutability at the language level (“const”), explicit shallow vs deep copy to avoid accidental sharing, documentation, high level concurrency constructs.
Things that make life harder: implicitly capturing closures, not documenting what is thread safe or not in the standard library

Rant: if you are designing a programming language from the ground up and the only solution you have for data races is “use the runtime race detector”, then you have not spent enough time in the trenches suffering from data corruption and rare, incoherent errors due to data races.

In defense of lock poisoning in Rust · sunshowers It's worth retaining one of multithreaded Rust's most valuable features.

New post: a defense of lock poisoning in Rust.

Followup to recent discussion: decided to write about lock poisoning, looking at the arguments on each side, and informed by our experience at @oxide.computer dealing with the parallel problem of unexpected async cancellations

Please give it a read!

I don’t even write Rust right now but this post got me caring about this topic and really smoothly explained the stakes !

Tracking and fixing many Go data races lately, I am getting a new found understanding and empathy for all these Mozilla developers who jumped on Rust the moment it was halfway usable.
Like a lost, thirsty traveler in the desert seeing an oasis from afar.
#golang #rust

Thank you, I will definitely watch this! For some reason I did not know about it!

A million ways to die from a data race in Go. New blog post. Well it’s not quite a million, but still.

gaultier.github.io/blog/a_milli...
#golang

But I’m getting tired of this status quo in 2025. You’ll probably have fewer data races in typical C code than in typical Go code!

Adding immutability, (deep) clone functions for most types, and explicit capture lists for closures would go a loooong way to help avoiding data races.

There are ways to reduce harm: do not use closures (prefer standalone functions) to avoid accidental captures, use value types that are passed by value (copied), etc.
But the language gives you no help at all and many ways to shoot yourself in the foot.

After many years of writing Go professionally and tracking very varied data races, I am slowly becoming convinced that if you care about data races, you should not use goroutines. At all.

#golang

“Hell is other people”.

Sartres clearly did not have to support 4 different SQL databases in the same codebase at scale.

Lucky bastard.

More DTrace, more Go, more blog articles!
gaultier.github.io/blog/how_to_...
#dtrace #golang #bug

And another blog article, once again about Go and DTrace:

gaultier.github.io/blog/go_dtra...
#dtrace #golang

I just wrote another Go + DTrace blog article!
This time: Are my SQL files read at build time or run time?
gaultier.github.io/blog/are_my_...

#golang #dtrace

Not a day after crafting this DTrace script and writing this article, I found myself using it to solve a completely different issue in a completely different Go program. Yeah, baby.

Go, SQL, and DTrace: a marriage made in heaven?
New blog post!
gaultier.github.io/blog/observe...

#golang #dtrace #sql

Short article today!
gaultier.github.io/blog/an_amus...

#golang

The good thing about spending your Friday afternoon pulling your hair troubleshooting a bug, is that it makes for a nice blog article afterwards…

gaultier.github.io/blog/subtle_...

#bug #golang

Your article on “defer” was a great read!

Thank you for making C better !
I am really looking forward personally to “defer” being standardized.

Go Assembly Mutation Testing Test coverage of delicate Go cryptographic assembly through a new mutation testing framework.

I joined the Go team just after exploiting a carry bug in a Go assembly core, and I've been looking for ways to prevent the next one ever since.

This year's attempt is very promising: mutation testing swapping e.g. ADC → ADD, CMOV → MOV, etc. to provide test coverage for constant time assembly.

Me: wow, my new work got me the new M4 MacBook Pro with 48 GB of RAM, every build is going to be instant!

npm run build: Worker terminated due to reaching memory limit: JS heap out of memory.

Tim Apple giveth, JavaScript taketh away

i hope to become the #1 RSS influencer