No really... ants are scary!

Nice explanation of the Mastodon architecture, how it propagates messages and interactions or how it scales.

An old piece, I sometimes like to revisit the basics so here it goes. A very nice explanation of how Git is built and how it works internally. It's of course a simplification in some way but close enough to have a good mental model of what goes on behind the commands we use.

I'm not a huge fan of the "Steve Jobs said..." to justify thing, a clear rhetoric trick. Still, I think this short piece nails it down, it's just better when managers actually know the job. It's better to promote someone who knows it and coach that person into the job. There's only one challenge then (which is glanced over in the paper): how to keep this manager technically relevant over time. It's not that easy in our field.

That looks like a nice even though a bit niche 3D model editor. I like this kind of style.

This is really going down the drain. Right wings extremists basically took over the content moderation vacuum. I wonder how long before this turns into simply into an extremist echo chamber with no real user on it.

Little simple benchmark of WebAssembly performances for the most common languages found there. Careful to the payload size though.

Interesting take about what could make dynamic typing truly shine if it got all the way to runtime manipulation in a consistent manner. We're far from it though.

Looks like a good set of resources for OSPO and compliance in companies.

Undefined behavior do exist and well... they're really undefined, don't make any assumption about them.

Obscure feature definitely but we're happy it's there... maybe one day it'll indeed allow to have much more independence from the code forges.

Definitely this, we have to stop pointing disk I/O so much for performance issues. This is just not really slow anymore. Obviously network is a different story.

Nice list of things to keep in mind when working on projects, even small personal ones. This greatly improve maintainability in the long run.

This looks like an interesting OS level monitoring solution.

Interesting set of memory patterns. Didn't know all of them, some are definitely useful and I already use, I'll try to look for the others next time I need to.

Nice summary on the false sharing problem with caches and how it can impact your performances in multithreaded contexts.

Don't believe claims about Rust (or any other options in fact) being a language for universal use. It has a few spaces where it shines and others where it'll be a drag. Picking the right language and stack is a multi-factor decision process where the technical advantages of the language itself say less than half of the story.

There's definitely a tension between something which you can organize and search easily (by typing) and something you can remember better (by hand writing). That's why I can't get rid of hand written notes completely, I practice a mix of both depending on the use.

Now this is a very interesting trick for git. This way large reformatting commits are less of a concern when exploring commit history.

Interesting deep dive on how sets and dicts are implemented in CPython. There are a couple of interesting tricks in there.