Composition

Lately I’ve been pondering about composition - in the sense of the longer scale changes that happen throughout a piece or performance.

Mostly live code happens at the interval of a loop, bar or cycle - typically a couple of seconds or less repeated (with changes) over time. Larger time scales could involve chord progressions or rhythmic variations happening over multiple of the shorter cycles.
This can be summed up in Strudel notation like so:

n("0 1 2 3".add("<0 1 0 3>"))

You will need to add a scale for that to do anything, the things to notice are the first pattern (in quotes) goes over one cycle and the second over four of those cycles (due to the angle brackets).

What I’ve been thinking about is what happens beyond that in terms of larger time structures. My impression is that most artists (including imposters as always) develop their code over time manually¹, myself included. So over timescales the amount that code is performed by the machine differs from automated (shorter time) to human-led (longer time). As always I find myself asking, does this always need to be the case?

Well, if a performance was entirely set out beforehand then it would be a generative piece. And while that is also cool, it makes for a less fun experience for artist and audience. Note that this doesn’t mean every note is decided in advance - the patterns and changes can be emergent, say from the interplay of different elements evolving over different (or non-commensurate) frequencies.
A recent example of a generative piece is Wreckage Systems by 65daysofstatic.
And we can hardly expect coders to type in very short time frames, so it’s natural to let the computer do the small stuff.

but still

While I don’t really want to perform generative pieces - although it is fun to make them - I’ve still been seeking ways to create variation over time.
One thing that I’ve suffered with since like forever is getting stuck in one or four bar loops and finding it hard to break out. It’s surprised me that this still happens in live coding as Syntə doesn’t inherently have any kind of loop/cycle-ness. However, you can create synced structures (by convention using the sync signal and /b, /s functions). This was something I added much later in my exploration of the language, probably because I knew it could get me stuck. An earlier iteration (which is still available) comprises the >sync operator and posc function. Which I should probably use more.

syncing feeling

What’s all this about sync?
Well, having things that play together in time seems to lead to loops forming. Or does it always?
Either way, it’s possible to not synchronise anything and have free running wave patterns interplay between each other. Which is great, but when you make a change it could disrupt the cycles in a less appealing way. So sync can be used to periodically reset the phase of things to avoid too much ‘mush’ (which is not always desirable). It also enables resetting things in atypical ways to create strange beats.

so anyway

I’ve been thinking about larger structures and how we can make them, or should everything be done by hand?
I guess as always it’s about a mixture of approaches. Some of which I have already alluded to.
Here’s a list:

• free running oscillators/waves at different frequencies that produce variation among more regular elements
• using posc to keep things occasionally in sync
• making patterns/shapes over longer time scales than four or eight bars, while keeping room for human interaction
• elements that only happen every so often

that is all

I’ve been reading Human Kind by Rutger Bregman which reminds of how toxic and bad for your health ’the news’ is.
Yes, you might want to know about <bad things> so you can do something about it, but there are ways round that - certain podcasts, longer form media etc.
Certainly limit your intake.
Maybe I should post about this in more depth?

---

also

Reading about musical serialism. Here’s a generative Syntə piece that’s loosely inspired by that for you to try out:

in 32hz, out f, / 12, mul Phi, osc, push, flip, exb 4, smooth, out vca
pop, lt 0.5, dirac, out gt
in f, mul 9, osc, lpf gt, 8bit 12, base 2, mul 440hz, sino, mul vca, + c, push, tape 70ms, 4lp, alp1 125ms,0.5, mul 0.4, lpf 12khz, out c, pop, mix

play around with the number 9, a value of one here will give a more serialist vibe for example.
Everything after mul vca is a basic reverb for niceness. The amplitude (loudness over time) of the sine oscillator sino is shaped via vca by exb 4, so that the envelope follows the pitch steps made by the first osc which uses lpf to sample and hold the second osc.
base 2, mul 440hz converts the discrete steps from 8bit 12 (a quantizer) into pitches.
This could be written more cleanly, like most of my code - but we said bad code only, right? :)
To type it in, the commas are optional (apart from the one after alp1 which is required to separate the arguments with no spaces). I usually press the enter key instead of comma but it made more sense to write it like this for a blog post.

---

Nb. this post contains various ‘words’. If you’re not sure what any of them mean then I invite you to search for them on the internet or if you have one, a dictionary. Which can be a fun adventure.
That is to say I deliberately haven’t explained everything here, independently seeking out cool knowledge is what we’re all about, right?