Interesting read on how the CPython JIT effort has been saved.

Or why this latest trend in genAI hype is a fool's errand.

The commentaries and analysis of those unjust laws continues. The motives behind the people pushing for them are getting clearer and it isn't pretty.

Also, it's likely a pessimistic estimate... Indeed, it's mostly based on a list from Kagi, which likely doesn't list many sites which would qualify.

This is definitely a disturbing result. It indeed makes democracies more fragile, all the more reason to build more democratic resilience.

Looks like an interesting ORM which brings advantages of the Django one without all the bagage. It's still young, let's see how it evolves.

Vulkan compute shaders are very much capable nowadays. Exemplified by its use in FFmpeg.

Let's help them help us. There are a few things to have in place for governments to be able to pay maintainers.

Here are the main levers to make Python code faster. Tries also to distinguish the effort level of each approach.

Interesting model for bringing architectural and organisational changes. This is indeed at least in part political games... so you need some political capital to spend.

Kind of obvious I think, but this likely bears repeating. Containers are not a magical recipe for security. There are many attack vectors to keep in mind and evaluate.

Wondering how JPEG works? Here is a primer.

On the little known history of Lotus Notes. Crossed its path as a teenager during an internship at a bank. Can't say I remember it fondly though.

Good initiative to push these unjust laws to their limits. Hopefully it'll show how absurd they are.

Interesting lesson here. It looks like XML still has its place in our modern tool belts. We should stop dismissing it too quickly.

It looks more and more likely that the current age verification fever has dark origins...

Good exploration on how to make grid shaders. It's definitely not a simple problem.

Interesting look at Zig's comptime feature. It's not a purely Zig post though, does a good job of explaining parametricity and the implications of loosing it.

Looks like an interesting approach to lift some of the limitations around the Rust trait system. The learning curve doesn't look too great though, clearly requires effort to get into.

In praise of code reviews. This article does a good job showing all the advantages if properly managed. Teams have to pay attention to latency but otherwise you get lots of benefits for not so much time spent.