A language for building concurrent software with confidence
(github.com/inko-lang)
Inko is a language for building concurrent software with confidence.
Inko is a language for building concurrent software with confidence.
Ruby, Ractors, and lock-free data structures
(iliabylich.github.io)
This story is about concurrent data structures in the context of Ruby. The goal here is to demonstrate how true parallelism can be achieved with global mutable state (which at the time of writing, is not supported by built-in Ruby primitives).
This story is about concurrent data structures in the context of Ruby. The goal here is to demonstrate how true parallelism can be achieved with global mutable state (which at the time of writing, is not supported by built-in Ruby primitives).
Notes on structured concurrency, or: Go statement considered harmful (2018)
(vorpus.org)
Every concurrency API needs a way to run code concurrently.
Every concurrency API needs a way to run code concurrently.
Lock Contention
(maksimkita.com)
Recently, I revisited Resolving a year-long ClickHouse lock contention post and spoke about it at C++ Russia 2025 conference.
Recently, I revisited Resolving a year-long ClickHouse lock contention post and spoke about it at C++ Russia 2025 conference.
What's the Deal with (Ruby) Ractors?
(byroot.github.io)
When Ractors were announced 4 or 5 years ago, many people expected we’d quickly see a Ractor-based web server, some sort of Puma but with Ractors instead of threads. Yet this still hasn’t happened, except for a few toy projects and experiments.
When Ractors were announced 4 or 5 years ago, many people expected we’d quickly see a Ractor-based web server, some sort of Puma but with Ractors instead of threads. Yet this still hasn’t happened, except for a few toy projects and experiments.
Concurrency bugs in Lucene: How to fix optimistic concurrency failures
(elastic.co)
Debugging concurrency bugs is no picnic, but we're going to get into it. Enter Fray, a deterministic concurrency testing framework from CMU’s PASTA Lab, that turns flaky failures into reliably reproducible ones. Thanks to Fray’s clever shadow lock design and precise thread control, we tracked down a tricky Lucene bug and finally squashed it. This post explores how open-source heroes and tools are making concurrency debugging less painful—and the software world a whole lot better.
Debugging concurrency bugs is no picnic, but we're going to get into it. Enter Fray, a deterministic concurrency testing framework from CMU’s PASTA Lab, that turns flaky failures into reliably reproducible ones. Thanks to Fray’s clever shadow lock design and precise thread control, we tracked down a tricky Lucene bug and finally squashed it. This post explores how open-source heroes and tools are making concurrency debugging less painful—and the software world a whole lot better.
Exposing concurrency bugs with a custom scheduler
(lwn.net)
Jake Hillion gave a presentation at FOSDEM about using sched_ext, the BPF scheduling framework that was introduced in kernel version 6.12, to help find elusive concurrency problems.
Jake Hillion gave a presentation at FOSDEM about using sched_ext, the BPF scheduling framework that was introduced in kernel version 6.12, to help find elusive concurrency problems.
Ruby “Thread Contention” Is Simply GVL Queuing
(island94.org)
For the longest time, I’ve misunderstood the phrase “thread contention”. It’s a little embarrassing that given I’m the author of GoodJob (👍) and a maintainer of Concurrent Ruby and have been doing Ruby and Rails stuff for more than a decade. But true.
For the longest time, I’ve misunderstood the phrase “thread contention”. It’s a little embarrassing that given I’m the author of GoodJob (👍) and a maintainer of Concurrent Ruby and have been doing Ruby and Rails stuff for more than a decade. But true.
Par: Process language with an interactive playground for exploring concurrency
(github.com/faiface)
Par (⅋) is an experimental concurrent programming language. It's an attempt to bring the expressive power of linear logic into practice.
Par (⅋) is an experimental concurrent programming language. It's an attempt to bring the expressive power of linear logic into practice.
The Mythical IO-Bound Rails App
(byroot.github.io)
When the topic of Rails performance comes up, it is commonplace to hear that the database is the bottleneck, so Rails applications are IO-bound anyway, hence Ruby performance doesn’t matter that much, and all you need is a healthy dose of concurrency to make your service scale.
When the topic of Rails performance comes up, it is commonplace to hear that the database is the bottleneck, so Rails applications are IO-bound anyway, hence Ruby performance doesn’t matter that much, and all you need is a healthy dose of concurrency to make your service scale.
The Mythical IO-Bound Rails App
(byroot.github.io)
When the topic of Rails performance comes up, it is commonplace to hear that the database is the bottleneck, so Rails applications are IO-bound anyway, hence Ruby performance doesn’t matter that much, and all you need is a healthy dose of concurrency to make your service scale.
When the topic of Rails performance comes up, it is commonplace to hear that the database is the bottleneck, so Rails applications are IO-bound anyway, hence Ruby performance doesn’t matter that much, and all you need is a healthy dose of concurrency to make your service scale.
Ada for the C++ or Java Developer – Concurrency
(adacore.com)
Java and Ada both provide support for concurrency in the language. The C++ language has added a concurrency facility in its most recent revision, C++11, but we are assuming that most C++ programmers are not (yet) familiar with these new features. We thus provide the following mock API for C++ which is similar to the Java Thread class:
Java and Ada both provide support for concurrency in the language. The C++ language has added a concurrency facility in its most recent revision, C++11, but we are assuming that most C++ programmers are not (yet) familiar with these new features. We thus provide the following mock API for C++ which is similar to the Java Thread class:
Clojure core.async.flow
(github.com/clojure)
The fundamental objective of core.async.flow is to enable a strict separation of your application logic from its topology, execution, communication, lifecycle, monitoring and error handling, all of which are provided by and centralized in, c.a.flow, yielding more consistent, robust, testable, observable and operable systems.
The fundamental objective of core.async.flow is to enable a strict separation of your application logic from its topology, execution, communication, lifecycle, monitoring and error handling, all of which are provided by and centralized in, c.a.flow, yielding more consistent, robust, testable, observable and operable systems.
Show HN: Pyper – Concurrent Python Made Simple
(github.com/pyper-dev)
Pyper is a flexible framework for concurrent and parallel data-processing, based on functional programming patterns. Used for 🔀 ETL Systems, ⚙️ Data Microservices, and 🌐 Data Collection
Pyper is a flexible framework for concurrent and parallel data-processing, based on functional programming patterns. Used for 🔀 ETL Systems, ⚙️ Data Microservices, and 🌐 Data Collection
Python Concurrency: Threads, Processes, and Asyncio Explained
(newvick.com)
I recently needed to learn Python concurrency. I always thought I’d get to that topic someday. That someday arrived.
I recently needed to learn Python concurrency. I always thought I’d get to that topic someday. That someday arrived.
Database Concurrency Patterns for Developers
(taki-mekhalfa.github.io)
I have been developing applications interacting with databases for many years now and I have always taken concurrency for granted.
I have been developing applications interacting with databases for many years now and I have always taken concurrency for granted.
In-Depth Ruby Concurrency: Navigating the Ruby Concurrency Landscape
(jpcamara.com)
I was honored to present a talk on Ruby concurrency at RubyConf 2024. It represents a high-level distillation of much of my writing and research over the past year. The conference itself was great, and presenting was such a fun experience.
I was honored to present a talk on Ruby concurrency at RubyConf 2024. It represents a high-level distillation of much of my writing and research over the past year. The conference itself was great, and presenting was such a fun experience.
Show HN: Lfi – a lazy functional sync, async, and concurrent iteration library
(lfi.dev)
lfi is a lazy functional sync, async, and concurrent iteration library
lfi is a lazy functional sync, async, and concurrent iteration library
A Science of Concurrent Programs (final draft)
(azurewebsites.net)
The book A Science of Concurrent Programs will be published by Cambridge University Press.
The book A Science of Concurrent Programs will be published by Cambridge University Press.
Swift Vision: Improving the Approachability of Data-Race Safety
(mjtsai.com)
This document lays out several potential paths for improving the usability of Swift 6, especially in simple situations where users aren’t intending to use concurrency at all.
This document lays out several potential paths for improving the usability of Swift 6, especially in simple situations where users aren’t intending to use concurrency at all.
Show HN: Rill – Composable concurrency toolkit for Go
(github.com/destel)
Rill is a toolkit that brings composable concurrency to Go, making it easier to build concurrent programs from simple, reusable parts.
Rill is a toolkit that brings composable concurrency to Go, making it easier to build concurrent programs from simple, reusable parts.
Ultra-low-latency, batching and concurrent queue for IPC in Java
(github.com/coralblocks)
CoralRing is an ultra-low-latency, lock-free, garbage-free, batching and concurrent circular queue (ring) in off-heap shared memory for inter-process communication (IPC) in Java across different JVMs using memory-mapped files.
CoralRing is an ultra-low-latency, lock-free, garbage-free, batching and concurrent circular queue (ring) in off-heap shared memory for inter-process communication (IPC) in Java across different JVMs using memory-mapped files.
Linux 6.13 Quadrupling Workqueue Concurrency Limit
(phoronix.com)
The Linux kernel Workqueue (WQ) is used for handling asynchronous process execution. For the past many years there has been an upper limit on the number of workqueue execution contexts per CPU at 512, but with Linux 6.13 that is being quadrupled to a limit of 2048.
The Linux kernel Workqueue (WQ) is used for handling asynchronous process execution. For the past many years there has been an upper limit on the number of workqueue execution contexts per CPU at 512, but with Linux 6.13 that is being quadrupled to a limit of 2048.
Playground Wisdom: Threads Beat Async/Await
(pocoo.org)
It's been a few years since I wrote about my challenges with async/await-based systems and how they just seem to not support back pressure well. A few years later, I do not think that this problem has subsided much, but my thinking and understanding have perhaps evolved a bit. I'm now convinced that async/await is, in fact, a bad abstraction for most languages, and we should be aiming for something better instead and that I believe to be thread.
It's been a few years since I wrote about my challenges with async/await-based systems and how they just seem to not support back pressure well. A few years later, I do not think that this problem has subsided much, but my thinking and understanding have perhaps evolved a bit. I'm now convinced that async/await is, in fact, a bad abstraction for most languages, and we should be aiming for something better instead and that I believe to be thread.
GenMC: Model checking for concurrent C programs
(mpi-sws.org)
GenMC is an open-source state-of-the-art model checker for verifying concurrent C/C++ programs under the RC11, IMM, and LKMM memory models.
GenMC is an open-source state-of-the-art model checker for verifying concurrent C/C++ programs under the RC11, IMM, and LKMM memory models.
We built a self-healing system to survive a concurrency bug at Netflix
(pushtoprod.substack.com)
Our CPUs were dying, the bug was temporarily un-fixable, and we had no viable path forward. Here's how we managed to survive.
Our CPUs were dying, the bug was temporarily un-fixable, and we had no viable path forward. Here's how we managed to survive.