concurrency

The article analyzes inherent concurrency bugs in SQL, such as atomicity failures, TOCTOU issues, and deadlocks, using a money transfer example to demonstrate correct locking and transaction practices.

This paper proposes Multi-Stream LLMs, which transition from sequential message-based instruction tuning to parallel stream processing. This approach allows language models to simultaneously read, think, and generate across multiple concurrent data flows, addressing bottlenecks in autonomous agent applications.

This technical article explains how to use Erlang's :counters and :atomics modules for high-performance counting and shared mutable state outside the standard process isolation model. It covers atomic operations like add_get, exchange, and compare-and-swap within the BEAM runtime.

Explains how `&self` on an async trait method with a `Send` future implicitly requires `Sync` on the implementing type, and offers fixes like switching to `&mut self` or using `Sync` interior mutability.

The article analyzes the scalability limitations of using PostgreSQL as a job queue, specifically highlighting performance bottlenecks caused by MultiXact SLRU contention under high concurrency. It explains why this architecture fails in production despite working well in development and suggests considering alternatives.

A deep dive into the evolution of async programming models—from callbacks to promises—highlighting how each wave solved prior resource and performance issues while introducing new ergonomic challenges.

An Atlassian Principal Engineer highlights how concurrency concepts intimidate junior engineers and dominate backend interview fears.