Meter, Note Values and Your First Grooves

This module builds toward the first genuinely musical thing most live coders and bedroom producers make: a two-bar drum groove that sounds like it belongs to a genre. Whether you are step-sequencing an 808-style pattern in a browser sandbox or typing a drum line into a live-coding buffer, the same skill is at work — hearing a pulse, knowing where the strong and weak positions sit, and placing kick, snare and hats so the groove drives rather than plods. This is the rhythmic literacy every later module leans on.

The arc starts on paper, not the grid. First you learn how meter groups beats into bars, how a time signature encodes that, and how note values and the dot work — the fractional-proportion naming of note lengths and the dotted-note rule are your JIT references here. Then you translate that notation onto the sequencer: the 16-step grid atom shows how two bars of 4/4 become slots 1–16, and the drum pattern construction procedure walks you through a supported first pattern — kick anchored on the downbeat, snare answering on the backbeat, hats riding above. From there the supports come off: you add an offbeat open hat, push one accent onto a weak position using the syncopation concept, and finish by picking samples and a tempo that fit your target genre before programming a fresh groove unassisted.

Every required atom is load-bearing for that capstone: you cannot place a dotted-rhythm variation without note values, or a genre-appropriate tempo without the BPM ranges. The supporting atoms widen the frame — what drum programming is historically, why a groove can feel faster or slower than its BPM, and how the two-step strips a break to its skeleton — enriching taste without gating the task.

Walkthrough

Open strudel.cc. Ctrl-Enter (Cmd-Enter) plays, Ctrl-. stops. We build the capstone groove one layer at a time on a sixteen-step grid — two bars of sixteenth notes written out as sixteen slots, so you can see where every hit lands before you hear it. Each step is a complete, playable program.

1 — the grid, and the one. Write all sixteen slots of a bar. ~ is a silent step; a name is a hit. A kick on slot 1 is the downbeat — the anchor every other hit is felt against ([[sixteen-step-grid]], [[kick-on-downbeat]]). Right now it’s one kick per bar so you can hear the grid’s length.

setcpm(120/4)
$: sound("bd ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~")

2 — four on the floor. Put a kick on each of the four strong beats — slots 1, 5, 9, 13. Counting the grid in fours is how you read meter off the page ([[meter-beats-per-bar]]). This is the house/techno pulse; note it’s the same thing as the shorthand bd*4, just spelled out on the grid.

setcpm(120/4)
$: sound("bd ~ ~ ~ bd ~ ~ ~ bd ~ ~ ~ bd ~ ~ ~")

3 — the backbeat. Add a snare answering on beats 2 and 4 — slots 5 and 13 — as its own $: track. Kick-and-backbeat is the load-bearing skeleton of almost every groove ([[kick-snare-backbeat-patterns]]).

setcpm(120/4)
$: sound("bd ~ ~ ~ bd ~ ~ ~ bd ~ ~ ~ bd ~ ~ ~")
$: sound("~ ~ ~ ~ sd ~ ~ ~ ~ ~ ~ ~ sd ~ ~ ~")

4 — hats on the offbeat. Ride closed hats on the “and” of each beat — slots 3, 7, 11, 15 — the weak positions between the kicks. Offbeat hats are what make a groove move instead of march ([[open-hat-on-offbeat]]).

setcpm(120/4)
$: sound("bd ~ ~ ~ bd ~ ~ ~ bd ~ ~ ~ bd ~ ~ ~")
$: sound("~ ~ ~ ~ sd ~ ~ ~ ~ ~ ~ ~ sd ~ ~ ~")
$: sound("~ ~ hh ~ ~ ~ hh ~ ~ ~ hh ~ ~ ~ hh ~")

5 — syncopation. Grab one accent off the strong grid. Add a kick on slot 16 — the very last sixteenth — so it pushes into the next bar’s downbeat instead of sitting squarely on a beat. That single displaced hit is [[syncopation]], and it’s most of what separates a groove that drives from one that plods.

setcpm(120/4)
$: sound("bd ~ ~ ~ bd ~ ~ ~ bd ~ ~ ~ bd ~ ~ bd")
$: sound("~ ~ ~ ~ sd ~ ~ ~ ~ ~ ~ ~ sd ~ ~ ~")
$: sound("~ ~ hh ~ ~ ~ hh ~ ~ ~ hh ~ ~ ~ hh ~")

6 — a dotted variation, a kit, and a tempo (the capstone). Two finishing moves. First a dotted rhythm: a low tom on a 3–3–2 pulse (lt ~ ~ lt ~ ~ lt ~ — hits every dotted-eighth, then a short one to fill the bar), the classic tresillo lift ([[dotted-notes]]). Then commit to a genre: .bank("RolandTR808") picks an 808 kit and setcpm(124/4) sets a house tempo — sample and tempo chosen to fit the genre, not left at defaults ([[drum-sample-selection]], [[genre-tempo-ranges]]). The last offbeat hat opens up (oh) to breathe. This is the two-bar groove the capstone asks for:

setcpm(124/4)
$: sound("bd ~ ~ ~ bd ~ ~ ~ bd ~ ~ ~ bd ~ ~ bd").bank("RolandTR808")
$: sound("~ ~ ~ ~ sd ~ ~ ~ ~ ~ ~ ~ sd ~ ~ ~").bank("RolandTR808")
$: sound("~ ~ hh ~ ~ ~ hh ~ ~ ~ hh ~ ~ ~ oh ~").bank("RolandTR808")
$: sound("lt ~ ~ lt ~ ~ lt ~").bank("RolandTR808").gain(0.7)

What good sounds like. A groove that pockets: the kick sits square on the one, the snare answers with authority on 2 and 4, and the offbeat hats fill the gaps without crowding the kick. Play it and try to nod — if you can’t find the pulse, something is fighting the downbeat. The commonest beginner mistake here is over-filling: every slot occupied reads as busy noise, not groove. Space (the ~) is doing as much work as the hits. The syncopated push (slot 16) and the tresillo tom should feel like lift, not clutter — if they blur the backbeat, pull one out. (Skill map: live-coder Domain B1 — groove, backbeat, pocket.)

Now make it yours. Swap RolandTR808 for RolandTR909 for a techno bite. Move the syncopated kick from slot 16 to slot 11 (the “and of 3”) and feel the push change. Try hh → [hh hh] on one slot for a sixteenth-note flurry. Drop the snare’s slot-13 hit for a half-time feel. Change setcpm to 140/4 (footwork) or 90/4 (hip-hop) and hear the same grid become a different genre.

Runnable examples

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

four-on-the-floor

s("bd*4")

_{strudel-0001 · CC0}

setcps 0.52

_{tidal-0044 · CC0}

offbeat-hats

s("~ hh ~ hh")

_{strudel-0002 · CC0}

d1 $ sound "~ hh ~ hh"

_{tidal-0002 · CC0}

backbeat

s("~ sd ~ sd")

_{strudel-0003 · CC0}

d1 $ sound "~ sn ~ sn"

_{tidal-0003 · CC0}

breakbeat

out: speed 4.0 >> seq 60 _ _ 60 _ 60 _ _ >> bd 0.2 >> mul 0.6

_{glicol-0035 · MIT}

setcpm(174/4)
stack(
  s("amencutup*8").chop(8).sometimesBy(0.3, x => x.speed(2)),
  note("c1 ~ ~ c1 ~ g1 ~ ~").s("sawtooth").lpf(500),
  s("~ cp").room(0.2)
)

_{strudel-0050 · CC0}

subdivision

seq [55, 82.5, 110, 82.5] & osc >> audio

_{punctual-0014 · CC0-1.0}

d1 $ n "0 .. 7" # scale "minor" # sound "arpy"

_{tidal-0030 · CC0}

syncopation

Pbind(\degree, Pseq([0, 4, 7], inf), \dur, 0.5, \amp, Pseq([0.4, 0.1, 0.1, 0.1], inf)).play

_{supercollider-0036 · CC0}