Stitching Signals: State Machines in Code

Watch an embroiderer work and you’ll see something remarkable: every needle movement follows a precise sequence of states. Threading, piercing, pulling through, positioning for the next stitch. It’s the same elegant pattern that governs Morse code transmission—dots, dashes, and the crucial pauses that separate meaning from noise.

Both crafts live in the realm of state machines, where each moment depends entirely on what came before. In TypeScript, we can model a Morse decoder that mirrors this stitched precision:

type MorseState = 'idle' | 'receiving' | 'complete';
type Signal = 'dot' | 'dash' | 'pause';

class MorseDecoder {
  private state: MorseState = 'idle';
  private buffer = '';
  
  process(signal: Signal): string | null {
    switch (this.state) {
      case 'idle':
        if (signal !== 'pause') {
          this.state = 'receiving';
          this.buffer = signal === 'dot' ? '.' : '-';
        }
        break;
      case 'receiving':
        if (signal === 'pause') {
          this.state = 'complete';
          return this.decode();
        }
        this.buffer += signal === 'dot' ? '.' : '-';
        break;
    }
    return null;
  }
}

OCaml’s algebraic data types capture this state choreography even more naturally, treating each transition as a pure transformation:

type signal = Dot | Dash | Pause
type state = Idle | Receiving of string | Complete of string

let process_signal state signal =
  match (state, signal) with
  | (Idle, Dot) -> Receiving "."
  | (Idle, Dash) -> Receiving "-"
  | (Receiving buffer, Dot) -> Receiving (buffer ^ ".")
  | (Receiving buffer, Dash) -> Receiving (buffer ^ "-")
  | (Receiving buffer, Pause) -> Complete buffer
  | _ -> state

let decode_morse = function
  | ".-" -> Some 'A' | "-..." -> Some 'B'
  | _ -> None

The Beauty of Explicit States

What makes state machines so powerful is their honesty about complexity. Like following a flight path between waypoints, each transition is deliberate and traceable. TypeScript’s union types provide compile-time safety—you cannot accidentally transition to an invalid state. OCaml goes further, making impossible states literally unrepresentable.

This same pattern governs navigation systems threading between waypoints, embroidery machines following digitized patterns, and any system where “what happens next” depends entirely on “where we are now.” The elegance lies not in the complexity, but in how explicitly we can model what was once implicit.