JSON is full of pitfalls. Here is a good summary. Still it is very widespread.

Interesting piece, it highlights well the struggle for the C++ community to come up with a cohesive approach to improve safety. It doesn't look like the solution is going to come from the standardization committee (unfortunately).

Good explanation of what Rust's unsafe really does.

It's clear that a split is forming in the C++ community on how to evolve the language. Could it lead to a full fledged divorce?

If you still needed to be convinced you need to use std::array and std::span, here is the proof.

Excellent proof of why you don't want to "rewrite it all in Rust". It's important to respect the old code and focus on applying safety practices on the new code. This is also why the upcoming changes to C++ are worth it, it might improve the interoperability factor almost for free.

Lots of good stuff definitely coming. This should definitely help make it more approachable to lots of people.

People are putting LLM related feature out there too hastily for my taste. At least they should keep in mind the security and safety implications.

Interesting point. As the memory safety of our APIs will increase, can we reduce the amount of sandboxing we need? This will never remove completely the need if only for logic bugs, but surely we could become more strategic about it.

Interesting, it confirms garbage collectors can be the source of unrecoverable performance degradation in request based systems.

This is a very important distinction to keep in mind. It's one of those source of bad mistakes in C++.

This would definitely be a nice change to the Java language.

It's nice to see progress coming to lifetime checks in C++ compilers.

Definitely not as fashionable as the kubernetes craze. This gives very interesting properties that multi-tenant applications can't really provide. The article is nice as it lays out properly the pros and cons, helps make the choice depending on the context.

The cleanup of that mess is still on-going. A bit more automation would help.

Definitely this. C++ isn't going away anytime soon. Rewrites won't be worth it in important cases, so improving the safety of the language matters.

A nice zine introducing the topic of faults and failures in distributed systems.

Another cruel reminder that basic reasoning is not to be expected from LLMs. Here is a quote from the conclusion of the paper which makes it clear:
"We think that observations made in our study should serve as strong reminder that current SOTA
LLMs are not capable of sound, consistent reasoning, as shown here by their breakdown on even such a simple task as the presented AIW problem, and enabling such reasoning is still subject of basic research. This should be also a strong warning against overblown claims for such models beyond being basic research artifacts to serve as problem solvers in various real world settings, which are often made by different commercial entities in attempt to position their models as a strong mature product for end-users. [...] Observed breakdown of basic reasoning capabilities, coupled with such public claims (which are also based on standardized benchmarks), present an inherent safety problem. Models with insufficient basic reasoning are inherently unsafe, as they will produce wrong decisions in various important scenarios that do require intact reasoning."

Interesting use of cryptography without a security concern. It's more about safety and ensuring something wasn't missed by mistake.

On the importance of invariants and consistent requirements in our trade. Admittedly it's a long demonstration but it show the point well.