Nice feature, but more interesting in its explanation is the topic of static initializers in Rust. They're clearly not a settled area in the language, that's in part because of how low level static analyzers are.

Interesting JS library for animation on the Web. It's nice that it seems really small.

Rust itself might bring interesting properties in term of safety. As soon as it needs to interact with other languages though the chances of undefined behavior increase drastically. This definitely pushes towards using more dynamic analysis tools to catch those.

We just can't leave the topic of how the big model makers are building their training corpus unaddressed. This is both an ethics and economics problem. The creators of the content used to train such large models should be compensated in a way.

Between this, the crawlers they use and the ecological footprint of the data centers, there are so many negative externalities to those systems that law makers should have cease the topic a while ago. The paradox is that if nothing is done about it, the reckless behavior of the model makers will end up hurting them as well.

Unsurprisingly, Wikimedia is also badly impacted by the LLM crawlers... That puts access to curated knowledge at risk if the trend continues.

This is a very smart way to create pure CSS placeholders.

Could be interesting if it gets standardized. Maybe other forges than Gerrit will start leveraging the concept, this would improve the review experience greatly on those.

I somehow recognise myself in this piece. Not completely though, I disagree with some of the points... but we share some baggage so I recognize another fellow.

A good look back at parallelisation and multithreading as a mean to optimise. This is definitely a hard problem, and indeed got a bit easier with recent languages like Rust.

A good reminder of why you often don't want to follow an architecture pattern to the letter. They should be considered like guidelines and depending on your technical context you should properly balance the costs. Here is an example with the Ports and Adapters pattern in the context of an ASP.NET application.

Nice way to have a web frontend which respects the system color choices of the user.

This is indeed a nice pattern to obtain a value, brings neat advantages.

This is interesting research. It shows nice prospects for WebAssembly future as a virtualization and portability technology. I don't think we'll see all of the claims in the discussion section realized though.

This paper is a look back at SCCS. This is nice to see how much progress was made in version control systems since then, it's also interesting to see how the design choices changed.

Dependency resolution is harder than people generally expect. This is a difficult problem and is very sensitive to the context.

Nice post about pros and cons of ECS architectures.

Clearly the security practice around Pixelfed bears questioning. I'm also a bit surprise at the lack of protection of private messages in the ActivityPub protocol (even though it's a hard admittedly a hard problem).

For sure the aforementioned manager need to fix his communication style. That being said the core advice was indeed good.

This is considered standard practice at this point. The article does a good job explaining it and the reasoning behind it.

Looks like a nice resource to deep dive into CSS layouts and really understand their behaviours.