AI supercharged scam. I guess we'll see more of those.

Well done LibreOffice! I'd love to see many more announcements like this one.

Improved static analysis for C straight from GCC. This is definitely welcome.

Interesting article, shows quite well the complexities of D-Bus and Polkit. Unsurprisingly such complexity easily leads to mistakes which can compromise security. This then hints to interesting things to keep in mind when you have to deal with D-Bus and Polkit.

Funny experiment. This shows what you can achieve in terms of teaching and learning during pair programming setups. Shadowing someone is a powerful approach.

Definitely a good idea, we'd need several such institutes across the world. Would governments be willing to try this?

You think the xz vulnerability was a one time event? Think again, this kind of bullying with ulterior motives happen regularly to critical projects.

When you're distributed, this is all about asynchronous communication. You can't walk to a person desk (and you should probably avoid it anyway if colocated).

Another example of enforcing conventions using automated checks. This time using Python and Django tricks.

This is a nice way to frame the three activities. They help people progress but in different ways.

Excellent post showing unhealthy consumer/maintainer dynamics in FOSS projects. This particular example was instrumental in getting the xz backdoor in place.

You should be mindful of the dependencies you add. Even more so when the name of the dependency has been proposed by a coding assistant.

Fascinating article which explores the behavior of the NTP Pool. If you wondered how it gives you an NTP server to query, you'll know the answer. It also covers the consequences of its restrictive approach. This even raises security concerns. Still even though it's not perfect this keeps being an essential service mostly run by volunteers.

Excellent work to improve Llama execution speed on CPU. It probably has all the tricks of the trade to accelerate this compute kernel.

This is indeed a more interesting way to perceive garbage collection. This also lead to proper questions to explore on the topic.

A proposal for data bindings as first class citizens in JavaScript? This could be a good thing indeed.

Smaller models with smarter architectures and low-bit quantized models are two venues for more efficient use. I'm really curious how far they'll go. This article focuses on low-bit quantized models and the prospects are interesting.

With some tuning SQLite can go a long way, even for server type workloads. There are still a few caveats but in some case this can reduce complexity and cost quite a bit.

Lots of good advices of course. It goes a long way to improve the quality of the project and the ease to on-board people. This is quite some initial work though.

Or why a clean commit history can help quite a lot to find how and why a bug was introduced. This shows a few nice tricks around git log to speed up the process.