I admit I like CRDTs as well. They really are the foundation of cool use cases. Of course it raises questions related to security to broker properly the sessions between users. Still, it's nice to see them more and more used.

Early days but this looks like interesting tooling to inspect and debug programs using Rust channels.

Indeed, in most case you don't need the extra complexity. Also interesting is showing that even if the application has to scale rapidly you still got quite some time to plan the transition to something else. It makes Postgres a sane default choice.

Interesting paper about metastable failures and novel approaches to try to analyse them. It's early days but we would need to get toward better prevention.

Good explanation of an important design pattern as soon as you have remote calls.

Definitely a handy catalog for designing distributed systems.

At some point the complexity is high enough that you indeed need more tools than only handcrafted tests to discover bugs.

Interesting reasoning about what is hard in systems with concurrency. It's definitely about the state space of the system and the structure of that space.

Interesting point. You likely need to be careful with fallback modes especially in distributed systems. They might bring even more issues when the system is already under stress.

Retries are becoming common place to deal with transient errors. That said, they can be a problem with recovery of longer failures due to amplification. There are options on the table to solve this though.

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

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

An exploration of how databases work from first principles, going all the way to distributed nodes etc. Good list of topics to explore further.

What's cooking up for the next generation of peer-to-peer applications? Here are two exciting examples of building blocks which are in the works.

Time and synchronization are complicated in distributed systems. Luckily there are solutions to try to ease the pain. It's not completely avoidable though.

Long article in two parts (make sure to read the second one as well) showing how to build an interactive painter with CRDT. Nice way to understand how they work.

Interesting research, this shows opportunities to push CRDTs to the next level.

Neat way to see how several queuing strategies behave. Picking the right one for your system is important.

Nice set of advises when dealing with concurrency. Don't fall into some of the anti-patterns which are pointed out.

Interesting experiment... with surprising results in places. What stays available or not is not necessarily what one would think. It's not that easy to be flexible and available across regions.