Message-passing concurrency is an approach to running many things at once in which independent processes coordinate by sending one another messages rather than by reading and writing the same memory. Because nothing is shared, there is no need for locks, and the data races and deadlocks that come from shared mutable state simply cannot arise.
The idea has deep roots. Hewitt, Bishop, and Steiger’s 1973 actor paper built an entire model of computation on the single operation of sending messages to actors, each with its own private state. A parallel tradition came from Tony Hoare’s Communicating Sequential Processes (CSP); the Erlang FAQ even notes that its send-message operator ”!” comes from CSP. The two traditions answer the same question differently but agree on the core move: communicate, do not share.
Erlang is the best-known production realization of the message-passing style. Its FAQ describes the language as “oriented towards concurrency and message passing,” built on lightweight, isolated processes that share no memory and are each garbage collected separately. Sending a message is the only way one process influences another, which is exactly what makes Erlang’s failure-isolation and let-it-crash design work.
A common way to summarize the philosophy is to invert the usual advice about threads: instead of sharing memory and then communicating through it, processes share nothing and communicate by passing messages. The same principle appears in the actor frameworks built on the Erlang VM and Akka, and in the channel-based concurrency of languages like Go, making it one of the most durable answers to the difficulty of writing correct parallel programs.