I added one statement and it only says `timed out`. I'll stick with Graphviz, which certainly doesn't time out.

When HDR is implemented properly, and you have a proper HDR display, it's such a transformative experience! Most games, however, don't have good HDR implementations. And for whatever reason HDR on Windows is still awful in 2025.

What ever happens to the coins in these thefts? Some of it goes to North Korea, but what about others?

I didn't see any analysis of network building as an alternative to M3s. For my project, ~40 million lines, past a certain minimum threshold, it doesn't matter how fast my machine is, it can't compete with the network build our infra-team makes.

So sure, an M3 might make my build 30% faster than my M1 build, but the network build is 15x faster. Is it possible instead of giving the developers M3s they should have invested in some kind of network build?

Ow. There's a paywall halfway through. Don't do what I did and get interested in the story if you aren't up to subscribing.

With the proviso that this all depends on the shape of your data, I think a single JSON document field us usually the right choice for anything that smells of content management. Relational database schemas become very complex very quickly when you strive for full normalization and that complexity is simply not worth worrying about until you have more data than RAM in a machine.

The know it all tone of this article is kind of annoying. Security professionals seem to have a common trait of thinking they know better.

Some good points in there, but limited pragmatism.

Hey! I'm the author and here's the clarification:

That was the official response I got from the district administration so had to post it. Also was being pressured by the government (indirectly) to take it down. So that was all bs. Next update I'll give is when I will have solved the problem.

The union-find data structure / algorithm is useful and a lot of fun.

The goal is a data structure where you can perform operations like "a and b are in the same set", "b and c are in the same set" and then get answers to questions like "are a and c in the same set?" (yes, in this example.)

The implementation starts out pretty obvious - a tree where every element either points at itself or some thing it was merged with. To check if two elements are in the same set, check if they have the same parent. Without analyzing it, it sounds like you'll average findRoot() performance of O(log(n)), worst-case O(n).

There are a couple of simple optimizations you can do to this structure, the type of things that seem like they shouldn't end up affecting asymptotic runtime all that much. The first is that, whenever you find a root, you can re-parent all the nodes you visited on the way to that root, so they'll all be quicker to look up next time. The other is that you keep track of the size of sets, and always make the larger set be the parent of the smaller.

And neither of those actually do anything impressive alone, but if you use both, the algorithm suddenly becomes incredibly fast, with the slowest-growing (non-constant) complexity I've ever heard of: O(the inverse of the Ackermann function(n)). Or, for any reasonable N, O(4 or less).