kassane/awesome-concurrency

Awesome Concurrency is a curated reading list for developers who want to understand how to make programs do multiple things at the same time without breaking. When software runs tasks in parallel, it risks subtle bugs where operations collide or data gets corrupted. This project collects the best articles, papers, and talks on how to avoid those pitfalls. The list is organized by topic rather than by programming language. It covers foundational concepts like memory models (how different parts of a program see shared data), futures and promises (a way to represent work that will finish later), coroutines and fibers (lightweight alternatives to traditional threads), and schedulers (the logic that decides which task runs when). Each section links to external resources, blog posts, academic papers, YouTube talks, and language documentation, spanning languages like C++, Rust, Go, Java, Kotlin, and others. The audience is developers building systems where performance and correctness both matter, especially in systems programming or backend services. For example, someone writing a high-throughput web server in Rust might consult the scheduler and lock-free data structure sections, while a C++ engineer working on a game engine could dig into the memory consistency model links. The resources range from beginner-friendly explainers to dense academic papers, so there's material for different experience levels. One notable thing about the project is its breadth. Rather than focusing on one language or framework, it treats concurrency as a cross-cutting concern and pulls together how different ecosystems approach the same fundamental problems. This makes it useful for comparing approaches, say, how Go handles scheduling versus how Kotlin or Rust does it, even if you only write code in one of those languages. The list also covers less obvious but important topics like structured concurrency (organizing parallel work so it's easier to reason about), cancellation (safely stopping work mid-flight), and tools for detecting data races automatically. These are the kinds of issues that bite in production but are easy to miss during development.