Pattern thinking and rhythmic idioms

This module builds toward the move that separates a live coder from a step-sequencer user: getting a groove the audience hears as complex out of two lines of trivially simple code. In a Strudel or TidalCycles set — at an algorave, in a practice jam, or on stream — you rarely have time to specify every hit. Instead you lay down a Euclidean rhythm from two integers, stack a second simple layer against it, and let their phase relationship generate the actual music. The capstone asks you to do exactly this, then annotate it: name the structural principle each layer illustrates, proving you can hear and explain the mechanism, not just stumble into it.

The arc starts supported. First internalize the working definition of pattern — structure of the making perceivable in the structure of the outcome — as a test you can apply to your own output. Then drill the Euclidean mini-notation idiom, (k,n) and its pattern-of-parameters extension, until typing a new groove costs nothing; this is the recurring micro-skill the whole task leans on. Next, a guided exercise layers two simple repetitions and listens for the emergent figure neither contains, applying the interference principle. Finally, the unsupported capstone combines all three, with the multi-level view of pattern (from software architecture down to the audible result) framing your annotations.

The four required atoms gate the capstone directly: without the pattern definition, the interference principle, the Euclidean idiom, or the levels-of-pattern concept, either the groove or the annotation fails. The supporting atoms enrich the picture — Spiegel’s transformation taxonomy and its live-coding encodings suggest where to go next, affordance and tool-constraint thinking explain why the idiom shapes your ideas, and the embodied and note-vs-sound perspectives deepen how you listen.

Walkthrough

At strudel.cc (Ctrl-Enter play, Ctrl-. stop). The goal: get a groove the ear hears as complex out of two trivially simple lines — by letting two patterns interfere rather than specifying every hit. Each step is a complete, playable program.

1 — a Euclidean rhythm from two numbers. bd(3,8) spreads 3 hits as evenly as possible across 8 steps — you don’t place them, the algorithm does ([[euclidean-rhythm-in-live-coding]]). That (k,n) idiom is the whole micro-skill: two integers, an instant groove.

sound("bd(3,8)")

2 — the idiom is a vocabulary. Different (k,n) give named world-rhythms for free. (3,8) is the tresillo; try (5,8), (7,16), (4,9). Type a new one — it costs nothing, which is the point.

sound("bd(5,8)")

3 — a second, simple layer. Add straight eighth-note hats against the Euclidean kick, on their own $: line. On their own both lines are dead simple — a pattern is just structure made audible ([[pattern-definition-outcome-structure]]).

$: sound("bd(3,8)")
$: sound("hh*8")

4 — interference: complexity neither line contains. Give the second layer its own Euclidean rhythm with a different k. (3,8) against (5,8) drift in and out of phase, and the combined groove — the thing you actually hear — is present in neither line ([[pattern-as-interference]]). This is the mechanism, not an accident.

$: sound("bd(3,8)")
$: sound("hh(5,8)")

5 — the groove, annotated (the capstone). Anchor the interference with a plain backbeat and a kit so it reads as music. Two-layer interference + a stabilizing snare — and you can name what each line does: kick (3,8) = the tresillo Euclidean layer, hats (5,8) = the interfering layer, snare = the structural anchor the ear locks to ([[patterns-at-all-levels-live-coding]]).

$: sound("bd(3,8)").bank("RolandTR909")
$: sound("hh(5,8)").bank("RolandTR909").gain(0.5)
$: sound("~ sd ~ sd").bank("RolandTR909")

What good sounds like. Interference should feel alive — the kick and hats crossing so the groove seems to shift while nothing actually changes — but the backbeat must keep you oriented. If you lose the pulse, the snare is too weak or both Euclidean layers are too busy; if it sounds mechanical, the two k values are too close (try (3,8) vs (5,8), not (4,8) vs (5,8)). The skill is hearing the emergent figure and knowing it came from the phase relationship, not from either line. (Skill map: live-coder Domain B1 — Euclidean rhythms used musically.)

Now make it yours. Change the kick to (5,8) and the hats to (7,8) and hear the density climb. Rotate a pattern with a third number — bd(3,8,2) shifts the start. Put a bass on a third Euclidean layer: note("c2").s("sawtooth").struct("t(3,8)"). Swap RolandTR909 for RolandTR808.

Runnable examples

Generated from the context/ instrument corpus by concept (redistributable idioms only). Do not edit — regenerate with gen-module-examples.mjs.

euclidean-rhythm

s("bd(3,8)")

_{strudel-0004 · CC0}

d1 $ sound "bd(3,8)"

_{tidal-0004 · CC0}