Watching Chess Moves Flow Like Light

Picture this: you’ve set up a long-exposure camera above a chess board, tiny LEDs attached to each piece. As players make their moves, the camera captures flowing trails of light—knight’s L-shaped arcs, bishops slicing diagonally across the frame, pawns marching forward in gentle curves. Each move becomes a luminous message traveling from one square to another.

This is exactly how message passing works in distributed systems. Each chess move is a message, each square a process waiting to receive it. In Erlang, this dance becomes beautifully explicit:

move_piece(From, To, Piece) ->
    From ! {vacate, Piece},
    To ! {occupy, Piece, self()},
    receive
        {move_complete} -> ok
    end.

The exclamation mark—Erlang’s send operator—fires messages like those light trails we captured. The From square gets told to release its piece, To gets the arriving piece, and the move coordinator waits for confirmation. No shared state, no locks, just pure message flow.

JavaScript takes a more event-driven approach, but the essence remains:

class ChessSquare extends EventTarget {
  occupy(piece) {
    this.piece = piece;
    this.dispatchEvent(new CustomEvent('occupied', {detail: piece}));
  }
}

squareE4.addEventListener('occupied', (e) => 
  console.log(`${e.detail} landed on E4`));

Both languages capture the same insight your light trails revealed: computation isn’t about manipulating shared memory—it’s about messages flowing between independent actors, each responding to what arrives in their inbox. The light doesn’t care about the destination until it gets there; the message doesn’t need global knowledge to find its target.

In 1987, when Erlang’s creators at Ericsson were designing fault-tolerant telecom systems, they discovered what your chess photography shows: the most robust systems are those where information flows like light—direct, purposeful, and beautifully isolated.