message passing
Imagine workers in separate offices with no shared whiteboard. Each has a private notebook only they can read, and to coordinate they must mail letters: 'please add these numbers, here they are' and back comes 'the sum is 42.' There is no peeking into a colleague's notebook — every piece of shared information travels as an explicit message. Message passing is computing organized this way: each processor has its own private memory, and they cooperate only by sending and receiving messages.
The model rests on two operations, send and receive. To share a value, one processor calls send with the data and a destination; the other calls receive to get it. There is no common address space — address 0x4000 on one node is unrelated to 0x4000 on another. This makes the communication explicit and visible in the code, which is more work to write but removes the hidden cache-coherence problem entirely: if a node never holds a copy of another node's data, no copies can go stale. The price is that the programmer must orchestrate every exchange.
Message passing is how clusters and supercomputers scale to thousands or millions of cores, where one shared memory simply cannot reach — you connect many independent computers by a network and pass messages (the MPI library is the standard). It also underlies warehouse-scale data processing. The trade is clear: shared memory is easier for a few cores and small data; message passing scales further but pushes all the communication, and its latency, into the open where the programmer must manage it.
Summing a huge array across 1000 networked machines: split the array into 1000 chunks, send one chunk to each machine, each computes its local sum, then each sends its partial sum back to a coordinator that adds them up. No machine ever reads another's memory — only explicit messages cross the wires.
Distributed-memory message passing scales past where shared memory can reach, at the cost of writing every communication by hand.
Message passing avoids the cache-coherence problem but does not avoid coordination: network latency, load imbalance, and the cost of marshaling data still limit speedup, and a too-chatty design can be slower than shared memory.