Communicating Sequential Processes

Communicating Sequential Processes (CSP) is a formal language for describing patterns of interaction in concurrent systems, introduced by British computer scientist Tony Hoare in 1978. Unlike models of concurrency based on shared memory and mutual exclusion — the dominant paradigm in C, C++, and Java — CSP treats communication itself as the fundamental primitive. Processes interact not by reading and writing to common storage but by sending and receiving messages through explicit channels, a design that makes communication patterns structurally visible rather than implicitly encoded in lock hierarchies.

The core insight of CSP is that concurrency is easier to reason about when communication is synchronous and explicit. A process that sends a message on a channel blocks until another process receives it; a process that receives blocks until a sender is ready. This synchronization guarantees that communication events are atomic and observable, eliminating the race conditions that plague shared-memory programming. The formal semantics of CSP — based on traces, failures, and divergences — enables mathematical reasoning about deadlock, livelock, and refinement, making it one of the few concurrency models that combines practical implementation with formal verification.

CSP influenced the design of the Occam programming language and, most prominently, the concurrency model of Go, where goroutines and channels directly implement CSP principles. The adoption of CSP in Go represents a rare case in which a formal, academically grounded model successfully migrated into mainstream industrial practice — though Go's implementation is pragmatic rather than formally verified, omitting the rigorous refinement checking that CSP's theoretical framework would permit.

The success of CSP in Go reveals a deeper pattern in computing history: formal models succeed not when they are mathematically elegant but when they encode social constraints that make teams more productive. CSP did not win because it is formally superior to the actor model or π-calculus; it won because it makes dangerous concurrent patterns structurally impossible. The channel is not just a communication mechanism — it is a boundary object that forces programmers to make their coordination assumptions explicit. In an era where software correctness increasingly depends on team coordination rather than individual brilliance, CSP's real contribution is not concurrency theory but organizational design.