Week 1 lesson 4 - mini-notation part 2

Ok lets go deeper into the mini-notation!

Here's a video. I experimented with fitting more things in a 'lesson', making a longer video accordingly.. But I think I was flagging by the end! I put a clarification or two in the subtitles. I also experimented with visualisation, which turned out more helpful at some points than others.. As ever, feedback is warmly invited!

  • 0:12 - recap of the first part * 1:20 - intro
  • 1:45 - 'speeding up' steps/subsequence with '*'
  • 4:35 - repeating steps/subsequences with '!'
  • 5:46 - 'slowing down' steps with '/'
  • 11:08 - polyphony (and polyrhythm) with "[ , ]"
  • 13:42 - polymeter with "{ , }" (compared with polyrhythm with "[ , ]")
  • 16:28 - rhythmic 'feet' with "."
  • 19:26 - one step per cycle with angle brackets

Here's a worksheet for hands-on exploration. Be sure to edit things to test your assumptions and try to get round what's going on - and please do ask questions if anything is unclear. I've put a few tasks at the end.. Following forum discussion we're also putting together more creative tasks.

-- SPEEDING UP, REPEATING, AND SLOWING DOWN

-- SPEEDING UP A STEP WITH "*"
-- https://www.youtube.com/watch?v=h_f11uago28&t=105s

-- Make a step go 'faster', so it repeats itself within its step:
d1 $ sound "hi lo*3"

-- It works with subsequences too
d1 $ sound "hi [hi lo]*2"

-- And 'n' patterns
d1 $ n "[0 ~ 0] 2 [0 9]*2 2" # sound "cpu"

-- Let's try speeding up a pattern by one-and-a-half:
d1 $ sound "bd [sd hc]*1.5"

-- It has two steps, so if you speed it up by 1.5, you get three steps.
-- The first time around you get "bd [sd hc sd]", the second time "bd [hc sd hc]"

-- SLOWING DOWN A STEP WITH "/"
-- https://www.youtube.com/watch?v=h_f11uago28&t=346s

-- Make 'lo' sound only every other cycle:
d1 $ sound "hi lo/2"

-- Make 'lo' sound only every third cycle:
d1 $ sound "hi lo/3"

-- Slow down a subsequence, so only one step sounds per cycle:
d1 $ sound "clap [numbers:0 numbers:1 numbers:2]/3"

-- Take two steps from a six step sequence each cycle, by slowing it by 3:
d1 $ n "0 0 0 [0 1 3 4 5 6]/3" # sound "cpu2"

-- Make things strange by slowing down with funky ratios!
d1 $ n "0 0 0 [0 1 3 4 5 6]/2.5" # sound "cpu2"

-- REPEATING A STEP WITH "!"
-- https://www.youtube.com/watch?v=h_f11uago28&t=275s

-- If you want to repeat steps on the same metrical level, then you can use ! ..
-- So this:
d1 $ sound "hi lo!3"

-- Is the same as this:
d1 $ sound "hi lo lo lo"

-- You can also use an ! on its own for a single repeat. So this:
d1 $ sound "hi lo !"

-- Is the same as this:
d1 $ sound "hi lo lo"

-- You can repeat subsequences too, so these are the same:
d1 $ sound "bd bd [hi lo] !"

d1 $ sound "bd bd [hi lo] [hi lo]"

-- POLYPHONY WITH ","
-- https://www.youtube.com/watch?v=h_f11uago28&t=668s 

-- With ',' you can have more than one subsequence happening at the same time.
-- Where you have the possibility of more than one note happening at once,
-- that's called musical "polyphony"

-- This is like where you have multiple channels d1 and d2 active at the same time:
d1 $ sound "bd sd"

d2 $ sound "rs rs rs"

-- .. but with ","" you can put them both in the same pattern. This sounds
-- the same as the two above patterns playing at once:
d1 $ sound "[bd sd, rs rs rs]"

-- The subsequences line up to fill the same cycle.
-- So "[a b, c d e]" lines up like this:
-- |a--b--|
-- |c-d-e-|

-- There's an 'alphabet' sample set in the default samples that can help with
-- this!
d1 $ n "[0 1, 2 3 4]" # sound "alphabet"

-- There's another way of getting subsequences to align, using { } instead of [ ]:
d1 $ n "{0 1, 2 3 4}" # sound "alphabet"

-- Video explanation: https://www.youtube.com/watch?v=h_f11uago28&t=822s

-- The first three cycles of this looks like this:
-- |ababab|
-- |cdecde|

-- What's happening? Well Tidal aligns the first subsequence, "0 1", to fit
-- the cycle, as before. But then it fits the others to it *stepwise*. So
-- now the steps align, but the cycles don't! In the space of three
-- cycles, there are three repetitions of "a b" and two repetitions of "c d e"

-- The [ ] notation creates what is called a musical 'polyrhythm' - multiple
-- rhythms happening within the same timeframe, e.g.:
d1 $ n "[0 5 2 ~, 0 3 4*2 0 3]" # sound "cpu2"

-- The { } notation creates a 'polymetre' - where metres of different durations
-- phase in and out of each other, e.g.:
d1 $ n "{0 5 2 ~, 0 3 4*2 0 3}" # sound "cpu2"

-- I (Alex) get mixed up between polyrhythm and polymetre all the time, and
-- tend to just call them both polyrhythm for simplicity..

-- 'Traditional' music software with linear 'piano roll' style notation systems
-- can really struggle with polyrhythm/metre, but it's really easy with Tidal
-- and a *lot* of fun to explore.

-- RHYTHMIC FEET WITH "."
-- https://www.youtube.com/watch?v=h_f11uago28&t=988s

-- You can 'mark out' regular rhythmic 'feet' with "."

-- So this:
d1 $ sound "bd sd . mt ht lt . arpy arpy:4 . snare clap:4 bd"

-- Is another way of saying exactly this:
d1 $ sound "[bd sd] [mt ht lt] [arpy arpy:4] [snare clap:4 bd]"

-- So the "." breaks up a sequence into parts of equal duration

-- To break down a step _within_ the "." notation, you can still
-- use [], etc:
d1 $ sound "bd sd . mt [ht mt] lt . arpy [arpy:4 arpy:5] . snare clap:4 bd"

-- That's the same as:
d1 $ sound "[bd sd] [mt [ht mt] lt] [arpy [arpy:4 arpy:5]] [snare clap:4 bd]"

-- ONE STEP PER CYCLE WITH "<>"
-- https://www.youtube.com/watch?v=h_f11uago28&t=1166s

-- Often it's nice to pick one step from a subsequence every cycle.
-- One way is this:
d1 $ sound "hi [arpy arpy:1 arpy:2 arpy:3]/4"

-- You can do the same thing with < > - it picks one step per cycle, without
-- you having to worry about how many steps there are inside:
d1 $ sound "hi <arpy arpy:1 arpy:2 arpy:3>"

-- REVISION TASKS

-- Copy each of the following patterns in turn, and edit them so that they
-- are shorter, using the "<>", "!", "[]" and/or "." introduced above.

d1 $ sound "kick snare snare"

d1 $ sound "kick [snare snare]"

d1 $ sound "kick snare kick snare kick snare"

d1 $ n "0 [1 2 3]/3" # sound "cpu2"

d1 $ n "[0 0 2] [4 5 6 7] [4 1] [0 3 0 3]" # sound "cpu2"

d1 $ sound "kick snare kick snare kick snare clap"

d1 $ sound "[kick snare kick snare kick snare] clap"

d1 $ sound "bd sd sd sd bd [sd sd sd]"

-- Trying to make code as short as possible is called "golfing" for some reason.
-- It can be useful as a form of practice, but sometimes longer code
-- is actually much easier to understand and edit!

Next lesson:

27 Likes

I just realised I forgot to make a 'table of contents' for this and the previous video. I'll add this shortly (now done)

2 Likes

it's great! from a beginner's angle it's a lot.
yes, a table of contents could be nice for long videos. i was wishing to have a global summary in order to navigate back and forth between lessons/topics.

Ok I've added a table of contents, and sprinkled the same links through the worksheet. Will do the older video later..

Please take it easy, and I'd love to go through anything that's unclear.

Thanks, very useful. My mental model of how the * and / operators work was super wrong but after that explanation a bunch of stuff around them makes more sense.

2 Likes

This is super useful. I’d just like to clarify (for myself) some terminology/functionality, but it might be a bit lengthy.

“Speed up” and “slow down” are interesting ways of phrasing it. I’ve only watched about half of the video so apologies if this is covered later or irrelevant.

It seems as though the idea of cycles is kind of cascading or overlapping at each division of the parent/pattern cycle. From this perspective the cycles are operating like oscillators? So to “speed up” an oscillator would be to increase its frequency? I.e. 1Hz * 2 results in 2Hz or two events in the same time it used to take to have one event? This is to say that the event density is increased or the event duration is decreased. The inverse of that is to do 1Hz/2 would result in 0.5Hz and an increase in event duration or, put another way, a decrease in event density. All relative to ‘time’ though.

I’ve not tried it yet but I assume that x0.5 would work the same as x/2, but what about x(1/3)?

Anyway, so the speed up/slow down thing seems to suggest that each step induces a new cycle relative to the parent cycle. For example if setcps is 60 then in d1 $ s “bd bd” each bd would operate at a cps rate of 120, and if you had “[bd bd] [bd bd]” then those sub cycles are still running at 120 (or 0.5 Hz), so applying /2 to one of them changes the sub cycle rate to 60 (or 1Hz) offset by half the parent cycle?

Phew. I think I type that out how I meant it. Sorry it’s super technical but I think if I’m understanding it then this video gets at some fundamental technical stuff and one of the primary reasons why normal ‘musical’ language applies in strange and sometimes hard-to-translate ways?

Yes that seems a fair way of thinking about it. *0.5 is indeed the same as /2. In the mininotation, for one third you have to use 1%3, rather than 1/3. *1%3 is then the same as /3.

Often in programming it's not really possible to accurately represent a third, but because Tidal time is rational (i.e. represented by the ratio of two integers, rather than a floating point number), it is 100% accurate.

3 Likes

Awesome, thanks Alex. This is exciting because it allows for reaaaaaalllllyyyu flexible temporal structures. Like x*48%47.

There is one of the 'golfing' exercises in the worksheet that I just can't figure out!

d1 $ sound "kick snare kick snare kick snare clap"

… nope. Impossible. Don't tell me!

4 Likes

Yeah. I’m not able to solve this neither.

Same here!!! Got close, but not the same :persevere:

Yeah, me too. Almost, almost. But not right.

Oh dear, I'd say that's actually not possible to reduce further with what I've told you. The solution I had in mind doesn't work. Sorry!

I think we have to introduce another operator for this one! The @ operator, which changes the relative size of a step. For example to make a half step, you could do arpy@0.5.

11 Likes

Ah awesome. That gives me the solution then. So cool!

Whoa, whoa, whoa....is that a tool that visualizes what's going on in a TidalCycles cycle in real time (below the editor)? Or are those graphics that you edited in after the fact?

Bryan

1 Like

fantastic :slight_smile:

Hi, the diagram is generated live with the tidal-vis package: https://github.com/tidalcycles/tidal-vis

It requires the SDL libraries which might be a challenge to install on some platforms unfortunately. I have in mind to make a version that doesn't have this dependency that could then be part of the main tidal distribution though. In the next version of tidal there'll at least be an easy way to look at a pattern as a text-based diagram.

6 Likes

Phew. I was stuck on that one.

Answers to exercises..

d1 $ sound "kick snare snare"
Answer
d1 $ sound "kick snare !"
-- or
d1 $ sound "kick snare!2"
d1 $ sound "kick [snare snare]"
Answer
d1 $ sound "kick snare*2"
d1 $ sound "kick snare kick snare kick snare"
Answer
d1 $ sound "[kick snare]*3"
-- or
d1 $ sound "[kick snare]!3"
d1 $ n "0 [1 2 3]/3" # sound "cpu2"
Answer
d1 $ n "0 <1 2 3>" # sound "cpu2"
d1 $ n "[0 0 2] [4 5 6 7] [4 1] [0 3 0 3]" # sound "cpu2"
Answer
d1 $ n "0 0 2 . 4 5 6 7 . 4 1 . 0 3 0 3" # sound "cpu2"
d1 $ sound "kick snare kick snare kick snare clap"
Answer

-- sorry, needed the @ syntax for this one, will explain this next!

d1 $ sound "[kick snare]!3 clap@0.5"
d1 $ sound "[kick snare kick snare kick snare] clap"
Answer
d1 $ sound "[kick snare]*3 clap"
1 Like

Hi Alex

All going well, except I get no sounds for any of these inputs: sd mt ht.

I've had a look and cannot find the folders for them, however there are 808sd folders etc... Where can I download the sd mt ht folders?

Cheers

Tom