Two Oscillators Walk Into a Process

A theremin is a disagreement made audible. Two oscillators run at nearly identical frequencies — say, 260 kHz and 260.440 kHz — and a mixer circuit subtracts one from the other. The difference, 440 Hz, is the note you hear. Move your hand closer to the pitch antenna, shift one oscillator’s frequency, and the audible difference changes. The oscillators themselves never know about each other; they just oscillate. The mixer observes them both and computes the consequence.

This is, structurally, two concurrent processes with a third process listening to their outputs. Erlang was built for exactly this kind of thing.

-module(theremin).
-export([start/0, osc/2, mixer/0]).

osc(Freq, Mixer) ->
    Mixer ! {freq, self(), Freq},
    timer:sleep(10),
    osc(Freq, Mixer).

mixer() ->
    receive {freq, _, F1} -> receive {freq, _, F2} ->
        io:format("Beat: ~.1f Hz~n", [abs(F1 - F2)]),
        mixer()
    end end.

start() ->
    M = spawn(fun mixer/0),
    spawn(fun() -> osc(260000.0, M) end),
    spawn(fun() -> osc(260440.0, M) end).

Two oscillator processes, utterly independent, sending their frequencies to a mixer process that computes the beat. No shared state. No locks. Just messages crossing between isolated worlds.

JavaScript doesn’t have Erlang’s process model, but it has generators that can simulate the same structure — two sources yielding values, a consumer pulling from both:

function* oscillator(freq) {
  while (true) yield freq;
}

function* mixer(osc1, osc2) {
  while (true) {
    const f1 = osc1.next().value;
    const f2 = osc2.next().value;
    yield Math.abs(f1 - f2);
  }
}

const beat = mixer(oscillator(260000), oscillator(260440));
console.log(beat.next().value);  // 440

Same topology: two sources, one consumer, no awareness between the oscillators. The generator version is cooperative rather than truly concurrent — JavaScript’s event loop pretends to be parallel the way a theremin pretends to be simple.

The original theremin patent from 1928 doesn’t mention processes or message passing, obviously. But Léon Theremin built isolation into his design: each oscillator has its own tank circuit, its own tuning, its own physics. They meet only at the mixer. He stumbled onto the actor model sixty years before Erlang formalized it.

I spent most of today adjusting the fixed oscillator’s frequency with a trimmer capacitor while the scope showed the beat frequency drifting. The variable oscillator — the one my hand affects — was behaving. The fixed one was the problem, its frequency wandering as the circuit warmed up. Two processes, one of them lying about its state. The mixer faithfully reported the lie.

Tomorrow I’ll add thermal compensation. The oscillators need to stop disagreeing with themselves before they can properly disagree with each other.