One of the things that I’m trying to work out in Strudel are ways to build movement and complexity in rhythm in a live setting. One of the interesting and difficult things to negotiate when working live is that once a rhythm exists, I sometimes find it hard to “hear” variations and kind of get locked in. There are a lot of different rhythmic notations available, and each of them features different tradeoffs between familiarity, ease of expression, and openness to change or alteration. With study, new applications of the notation become clear, and I’d like to compare a few of these devices.

Craving the Grid

If you’re used to using sequencers, it seems like one of the most natural ways to express beats would be using the grid. We love the grid! The grid usually leads us towards the beat function, which is very grid-like and only requires that we take our grid-based thinking into a 0-indexed world. So like, your four on the floor bass drum looks like o---o---o---o--- on a sequencer, and we tend to think of that as a drum on 1, 5, 9, and 13. But we’re programming, so with zero indexing we shift that down to 0,4,8,12. How does that look in strudel?

Affordance and Exclusion

So what this gives us is the ability to take some of our knowledge about what a given beat looks like and express it quickly, but what does it cut off in the process?

I think there are a couple of things that fall out of this: First off, it separates each rhythmic element into its own voice. This is useful when we’re applying effects or doing sound design, or applying things like side chain to other voices, but it’s not very concise.

It’s especially verbose when it comes to change. If we want to add variation, we often end up copying and repeating large portions of the beat. We still get to use mini notation but it’s weird because we’ve dropped into this subnotation where for example commas no longer mean “play these at the same time”.

So if we want to create a two cycle beat in beat notation we often have something that looks like this:

This works, and it can be edited fast enough, but maybe a part of what we need to do is learn to let go of the grid.

Mini-notation

Mini-notation is absurdly powerful, very concise, and requires that you start thinking differently than you might on the grid. With mini-notation, the basic building block is the cycle, and we can think of mini-notation as something that divides cycles. Immediately this allows us to do things that are pretty hard to do with beat without a huge amount of change (if you wanted to go from 16 beats to 18 beats, you’d immediately change the structure of your existing rhythm and leave some blank space at the end, every beat will have to change). Subdivisions of cycles “stabilize” our beat a little, allowing us to change parts of a beat without altering the rest. The last example in mini-notation looks like:

This works, and it can be edited fast enough, but maybe a part of what we need to do is learn to let go of the grid.

It’s concise! It’s flexible! It lets us drop into triplets pretty easily, it lets us combine instruments, add chance operations, etc. At my current level of study, I still end up using “<[]>” a lot, but there’s a lot to learn. That said, this involves spending a lot of time splitting cycles up, figuring out where you are in a given beat, and this can be challenging. It’s also a machine for serendipity, you can just try something and see if it makes you happy.

Euclidean rhythms with mini-notation

I was studying this piece though and found a usage that opened my brain up, let’s look at a simplified version.

-->

So already, we’ve introduced a new idea, which is euclidean rhythm. A good-enough explanation of euclidean rhythm is that we have n total beats and we want to distribute k drum sounds “mostly evenly” across them. This gives us a really high level way to think of rhythm, and it’s something that we can alter pretty easily! Strudel also adds the notion of a third parameter for “rotation”, which allows us to offset a given rhythm, so for example bd(4,16) will give us o---o---o---o--- and bd(4,16,2) will give us --o---o---o---o-, which sounds like this:

I didn’t really think about using mininotation as arguments for euclidean rhythms and honestly didn’t even know that it could be done, but I think they’re concise, they open up the grid, and are extremely open to experimentation (throw a paremeter in for a cycle, see how it feels!)