Challenge: drops!

New challenge time - drops!

Live coding often comes with certain aesthetic - slow build ups in complexity. Live coders are good at this, because it's the natural arc of gradually developing some code.. Sudden transitions come a bit less naturally, but are core to a lot of musics.. For example some techno is all about slowly building up anticipation for a sudden change - the drop.

There are probably a lot of approaches to cracking this one. One thing you could try: slowly increase djf on a pattern from 0.5 to around 0.85 or so. Then remove the djf, and before running the result, add something like # shape 0.8. This should feel like building up anticipation and then a drop. Experiment with dropping into different impactful effects, like reverb.

The flip side to this is the possilbility play with confounding expectations, for example ‘dropping’ into a randomisation, or transformation of time. This can make the listener feel extremely frustrated. Can you make the most annoying non-drop ever?

Maybe a good place to start is by listening to some interesting 'drops'. Anyone have some classic and stranger examples? Then we can try working out some techniques and sharing the results as code and/or sound.

4 Likes

Big fan of the intro to this track - slowly builds into something really groovy and uses silence quite well!

2 Likes

ah! This is another topic I've been wanting to cover - the core of the drop is that is comes on the 1 after a buildup of n x 4 bars, and it's also generally in the start of a new section of 8 or 16 bars. So, for an example, a drop could come on the 1 of the 33rd bar or the 1 of the 65th bar. Additionally, the new section typically has some sort of drastic change, whether that's pulling drums out and introducing a new melody, or changing the tempo, or doing a key change, or doing anything else drastic that modifies the energy of a track.

You could use the seqPLoop function for this, but that's boring and for composed pieces. To solve this, I would want to know:

  1. Is there a way to know what bar you are on ?
    1.a) Is there a way to know what bar you started evaluation of this piece ?
  2. is there a way to schedule synth evaluation ?

if you could do this, you could ensure that your drop comes in on time and successfully falls on the 1 of the appropriate bar.

(this also brings up a concept of 'mixing' - perhaps there could be some sort of solution where different dirt channels evaluate on different actual audio outs, and we can mix between them like we do when we actually DJ.)

4 Likes


'bass is maternal
when it's loud I feel safer

1 Like

@John_Murphy Regarding knowing what bar you're on, I use a combination of risers/falls/fills at various metric levels and background visuals to keep track of this. You can see an example of this in my performance last year. Each "cycle" in the visuals corresponds to some power-of-two multiple of a beat.

I've not included the samples used, but the code (which uses TidalCycles+SuperDirt+VEDA) is up on my github here if you're interested.

3 Likes

Awesome - thanks - I took a look and I really like how that piece moves - that's a great way of managing it!

1 Like

It would be useful to have a function that you pass a pattern and that plays once – probably there is one? So something like: once (slow 2) pattern and another one that could be written as once (slow 2) pattern1 then pattern2

1 Like

this is probably my favourite strange drop to bring up
well, see (or rather hear) for yourself

I'm surprised there's so much left to explore in drum&bass yet people still mostly stick to making overengineered boring rollers :confounded:

4 Likes

@szalwiarz This is really great, and reminded me of some DnB tracks by Buunshin that have really creative drops and transitions. The first is a bit more accessible and the second is consistently weird throughout.

1 Like

The idea of the 'drop' within different forms of dance music is fascinating, and it's also interesting to see common uses of drops within live coding practices. I've got a question here that I'm curious about. Are there any examples of live coders who approach the drop in a mannerism influenced by other genres of music?

For example, I've been revisiting the usage of 'feedback' in grunge music, which is something I enjoyed in my teenage years about twenty years ago. Thinking back over how someone like Kurt Cobain of Nirvana used feedback (and distortion) within their music, often to end songs but sometimes as a sort of sonic carrier from one part of a song to another, I wonder if this is a kind of drop.

One example that I keep thinking about is "You Know You're Right", in which there are some points that have feedback at the tail-end of a chorus and just before the following verse. For example, this happens at around the 01:26 minute marker in this video:

Could the usage of feedback+distortion within something like TidalCycles be seen as a sort of 'riser' for a drop? Could the perceived loudness/noisiness/harshness and the contrasting sound that follows be a type of a drop? Are there any live coders who take this approach in their performances?

@hujairi I love this and I definitely use "drop" to more generally refer to a combination of transitionary elements that come before and after a metric boundary. I've found some similarities in Johnny Greenwood's work in Radiohead and a lot of music by The Pillows where short riffs, whammys, weird bends, and feedback are used to interrupt rhythm guitar and signal the end of a measure or a new musical section. It adds a lot of interest and seems to me to serve a very similar purpose.

Your post reminded me of the intro to Blue Swede's "Hooked on a Feeling" where everything drops out but vocals, then there's the THUMP-THUMP of the drums and then a bass slide that leads into the first instance of the chorus. It is my go-to for an example of a "drop" in non-EDM music.

1 Like

probably everybody knows this, but I couldn't find it – how would you make a pattern that plays only once?

There's a once command that you use instead of d1 etc

once $ sound "airhorn"

1 Like

ah now I understand the type signature.

I would want to use it as a component of other patterns, however. The signature should be something like Pattern a -> Pattern a. The first cycle after it has been touched it should disappear or be replaced by something else that remains.

Wow, it's taken me a long time to get to this but I'm surprised (and slightly nervous) about being the first submission!

This is not (nor was intended) to be trad edm drop - just managing the sequence of cycles was tricky enough for me at this point. I like @yaxu's suggestions to expand beyond this though, now that I've got some handle on the consistency of execution...

So let me present, the very underwhelmingly titled piece:

Challenge 4 drop

No accompanying video I'm afraid, but here's the guts of it:

do  resetCycles;
    d2 $ almostNever (jux (# squiz (sine + 1 ))) $ stut 4 0.5 0.2 $ slow 4 $ note (scale "ionian" "{ ~ ~ ~ ~, ~ [1 8] [ ~ 2 3 4] 0 }") 
        |+ note "<0!8 5!8>" # sound "supervibe"
        # sustain 2
        # octave 6
    
-- bass 
d3 $ slow 4 $ struct "~ . ~ . ~ . t " $ n "0"
    |+ n "<9!8 0!8>" 
    # s "pluck"

d5 $ slow 2 $ note (arp "down" "<[c'min7 ~!7] [c'dom7'ii ~!7] [c'maj9 ~!7 ][ c'm9'ii ~!7]> ") |+ note "<1 4 0 5 >"
    |+ note "<0!8 5!8>"
    # s "supermandolin"
    # sustain 3

d6 $ off 0.125 (# pan 0) $ slice 8 "1*4 6 7 8" $ every 4 (# gain 1) $ s "ade:2"
    # octave (irand 2 + 6)
    # gain 0

-- perc light
do  resetCycles;
    d4 $ loopAt 2 $ s "break:9" # djf 0.9

-- body
do  d4 $ qtrigger 1 $ stack [
        loopAt 2 $ s "break:9",
        s "wobble [snare:28 wobble] [~ snare:28] [snare:28]" # room 0.3 # sz 0.3,
        slow 2 $ note (arp "down" "<[c'min7 ~!7] [c'dom7'ii ~!7] [c'maj9 ~!7 ][ c'm9'ii ~!7]> ") |+ note "<1 4 0 5 >" |+ note "<0!8 5!8>" # s "supermandolin" # sustain 3,
        almostNever (jux (# squiz (sine + 1 ))) $ stut 4 0.5 0.2 $ slow 4 $ note (scale "ionian" "{ ~ ~ ~ ~, ~ [1 8] [ ~ 2 3 4] 0 }") |+ note "<0!8 5!8>" # sound "supervibe" # sustain 2 # octave 6,
        off 0.125 (# pan 0) $ slice 8 "1*4 6 7 8" $ every 4 (# gain 1) $ s "ade:2" # octave (irand 2 + 6) # gain 0
        ]
1 Like