Bil is a Go-inspired language that integrates concurrency as a core language feature using constructs like par, proc, and chan instead of goroutines and libraries. It provides explicit fork-join parallelism, unbuffered channel-based communication, and a CSP/occam-inspired model for writing concurrent programs with stricter static checking.
This article demonstrates how to safely share mutable data across multiple threads in Rust using Arc<Mutex<_>>. A Mutex ensures only one thread accesses data at a time, while Arc (atomic reference counting) allows multiple threads to safely hold references to the same Mutex. The example spawns two threads that concurrently modify a shared vector, with one incrementing values and the other doubling them.
This article explains Arc and Mutex in Rust, two key types for safe concurrent programming. It demonstrates how Rust's ownership model prevents data races and shows why Arc is needed to share immutable data across threads while Mutex enables safe mutable access in concurrent environments.
A Rust developer discusses solving an expensive cloning problem in a concurrent cache implementation by using Arc pointers instead of cloning values, enabling cheap reference counting while maintaining thread safety.
PostgreSQL 19 introduces REPACK (CONCURRENTLY), a built-in command that rewrites bloated tables online without extensions, using logical decoding to maintain a consistent snapshot and record changes during the rewrite. The author benchmarked REPACK against pg_squeeze and pg_repack extensions on a 90-million-row table, finding REPACK comparable in performance but more practical for managed services since it requires no shared libraries or restart.
A Rust developer discusses solving the problem of expensive clones in a concurrent cache by using Arc<JSON> instead of direct values, allowing cheap pointer sharing while maintaining thread safety through read-write locks.
Turso 0.8 introduces BEGIN CONCURRENT to enable concurrent writes without SQLite's single-writer bottleneck, significantly reducing transaction tail latency and improving write throughput under concurrent workloads. The release demonstrates that Turso's MVCC architecture achieves sub-6ms latency at 32 concurrent connections while SQLite reaches 1.2 seconds, and scales write throughput to 9,500 transactions per second compared to SQLite's flat 1,370 tps.
A Rust port of ONCE Campfire achieves pixel-perfect parity with the original Rails application while delivering 20–95× faster performance. The single binary replaces Ruby, Puma, Redis, and Resque, handling 100,000 concurrent clients in 1.5 GB of memory and serving pages and real-time updates significantly faster than the Rails version.
AdaptiveFlow is a lightweight Java 21 library for executing task DAGs using virtual threads, offering a fluent API for workflow definition with automatic validation, topological sorting, and type-safe result handling—eliminating the need for heavy frameworks or configuration.
A developer argues that experienced programmers should leverage their expertise to fundamentally improve their technology stacks rather than simply using AI to generate code. They propose concrete improvements to Ruby and Rails, such as performance optimization, better concurrency support, advanced type systems, and architectural changes like embedding SQLite3.
This article explores Optimistic Lock Coupling, a synchronization technique for concurrent data structures that improves scalability by allowing readers to perform read-only operations without acquiring locks. Unlike traditional lock coupling which creates contention on frequently accessed nodes like tree roots, optimistic lock coupling uses version numbers to detect concurrent writes, enabling better multi-core performance while requiring careful validation to avoid race conditions.
Optimistic UI—showing changes immediately before server confirmation—requires fundamental architectural changes beyond a simple UX tweak. Implementing it in Rulrmail exposed cascading challenges: handling overlapping requests, synchronizing feedback, managing premature undo clicks, preventing race conditions in shared state, and resolving database locking issues.
CUDA_DEVICE_MAX_CONNECTIONS is an environment variable that controls GPU hardware concurrency by limiting the number of concurrent connections to the GPU device. Setting it appropriately is critical for maximizing GPU utilization when using multiple CUDA streams, as the default value of 8 may underutilize hardware capabilities. Similar constraints apply to AMD GPUs via the GPU_MAX_HW_QUEUES environment variable.
Go Concurrency Distilled is a mini-book providing an overview of Go concurrency topics with interactive examples, covering goroutines, channels, and related patterns. It serves as a quick refresher rather than a beginner's guide, with code examples demonstrating foundational concepts like wait groups and channel communication.
Sference implements prefill concurrency in SGLang to maintain consistent time-to-first-token (TTFT) latency across multi-tenant GPU deployments. The approach addresses the architectural challenge of scheduling prefill work (prompt processing) versus decode work (token generation), which stress different GPU subsystems and have different queue dynamics. Prefill concurrency allows smaller requests to proceed without waiting behind large prompts, improving TTFT consistency for all users.
Article explaining the lost-update concurrency problem where two simultaneous database writes can erase each other, and three approaches to fix it: conditional updates with WHERE clauses, pessimistic locking with SELECT FOR UPDATE, and optimistic locking with version checks.
PHP lacks structured concurrency despite having fibers and an event loop, unlike languages such as Python, Kotlin, Swift, and Java that have implemented it. The article traces how programming evolved by trading freedoms for machine-enforceable guarantees—from eliminating goto to managed memory—and argues structured concurrency should follow the same pattern by confining tasks to scopes with guaranteed cleanup. Two RFC proposals for PHP structured concurrency failed due to process concerns and uncertainty about effects on global state, though the author argues a userland library rather than engine changes could solve the problem.
A 2026 benchmark compared PHP 8.5, Node.js 22, Go 1.24, and Python 3.12 under database I/O load, finding that PHP 8.5 with Swoole coroutines achieved 4.9–5× higher throughput than traditional synchronous runtimes at 50–200ms latency. Swoole's coroutine-based concurrency model allowed single workers to handle multiple concurrent requests, dramatically outperforming PHP-FPM, Node.js, Go, and Python in I/O-bound scenarios.
This post discusses practical challenges in implementing thread-safe concurrent B+Tree using crab latching, a fine-grained concurrency protocol that uses readers/writer latches on nodes. The author explains how top-down latch ordering prevents deadlocks when multiple threads access the tree concurrently, and demonstrates a deadlock scenario that occurs without proper ordering.
A reviewer discusses their experience reading Paul E. McKenney's free online textbook on parallel programming. They attended a 2026 conference where conversations about lock-free concurrency sparked interest in the subject, leading them to choose this textbook for its focus on concurrent programming and CPU cache effects rather than specific synchronization patterns.