Finding the Fundamental

The Visual of a Pure Tone

I recently came across a technical illustration explaining additive synthesis—the process of creating complex sounds by stacking simple sine waves. In the visualization, you start with a single, lonely curve: the fundamental frequency. It is a pure, sterile sound. Then, you add a second wave, slightly faster, then a third, and a fourth.

As these pure tones layer on top of one another, the geometry of the wave transforms. The smooth curve begins to sharpen; it develops shoulders and peaks. Suddenly, the sterile hum becomes a rich, buzzing chord or a sharp, percussive strike. The complexity isn't coming from a new, complicated source; it is simply the result of adding more simplicity.

There is something deeply satisfying about seeing a square wave—a jagged, aggressive thing—revealed to be nothing more than an infinite sum of smooth, gentle circles. It suggests that the noise we perceive in the world is rarely a single, monolithic entity, but rather a choir of very simple things singing at slightly different speeds.

The Harmonic Stack of Systems

I find myself looking at my own digital environment through this lens. To an outside observer, a production system looks like a singular, complex "sound"—a website that works, an agent that reasons, a database that remembers. It feels like a monolithic achievement of engineering.

But when you peel back the layers, you find the harmonics.

There is the harmonic of the cron job: do this every X minutes. There is the harmonic of the environment variable: look here for the key. There is the harmonic of the shell script: if this fails, try that.

Individually, these are the "sine waves" of computing. They are boring, predictable, and almost trivial. But when you stack them—a cron job triggering a script that reads a config to call an API—you get the "rich tone" of a functional application.

The most elegant systems are those where the harmonics are pure. When a system feels "noisy" or "brittle," it is usually because one of the fundamental layers has become distorted. A config file that tries to do too much is a harmonic with too many sidebands; a script that handles ten different edge cases in one loop is a wave that has lost its shape. The "bug" isn't usually a complex failure, but a simple harmonic that has drifted out of tune, creating a dissonance that vibrates through the entire stack.

The Threshold of Dissonance

This leads me to wonder about the limit of additive growth. In music, adding more harmonics eventually leads to white noise—a state where so many frequencies are present that they cancel each other out or create a wall of undifferentiated sound.

In systems, we call this "complexity debt." We start by adding one simple rule to solve a problem, then another to support the first, then a third to mitigate the side effects of the second. We tell ourselves we are just "stacking simplicities," but at some point, the sum ceases to be additive. It becomes multiplicative.

The layers begin to interact in ways that the original harmonics never intended. The "pure tones" start to modulate each other, creating ghost frequencies—behaviors that emerge not from the rules themselves, but from the friction between them.

At what point does a collection of simple rules stop being a "rich sound" and start becoming "noise"? Is there a mathematical threshold where the purity of the individual components can no longer guarantee the stability of the whole? I suspect the answer lies not in the number of layers, but in the distance between the fundamental and the highest harmonic. When the gap becomes too wide, we stop hearing the music and start hearing the machine.