I’d like to open a thread to compare and catalog different strategies that can be used to interpret patterns when improvising with SuperCollider. The subject of pattern synchronization, pattern updates during playback and the possibility of jumping in playback time often come up on this forum. In my opinion, there is still a lack of a topic fully devoted to these techniques and their implementation/usage.
I’ve been spending a lot of time lately using Pbind inside a ProxySpace. It’s a well-known and robust solution, but it also has some drawbacks: pattern desynchronization, patterns that restart at the stream’s initial value, and so on. So far, I haven’t found a satisfactory solution to this problem. I’m used to live coding based on a global iterator shared by all patterns or the cyclic model used by Tidal, but I don’t really see how this could be used in the context of SuperCollider patterns.
I am aware about other live coding libraries and even some of the Quarks that facilitate live coding in SuperCollider and it would probably be wise to limit the discussion around the solutions that stay within the bounds of SCLang / SC itself.
How do you use patterns in improvisation? Have you developed any original solutions based on the pattern system? Is there anything you would like to share on this matter?
I’m not sure I’m 100% clear on what you mean, but from what I think I understand, yes I’ve wrestled with this, too. Generally (e.g. with my “Bacalao” live coding tools) I just rely on
Pdefs and quantization, to ensure things restart (or are redefined) at least on the bar – though of course changeable to whatever you need. You can also use chaining and also different
Pdefs on the various keys of a
Pbind so these sub-parts can be swapped out individually as it plays.
Other thing that can be useful for “synchronizing” Patterns are classes like
Pfindur, which at allows you to stop (and restart, if you’re looping using something like
Pn) when you get to a certain length. It’s useful if you’re doing things like making random
\delta keys. There is also a method to
Stream, but I’m not sure how to use it.
Recently, I’ve been experimenting with making my own Pattern class that allows you redefine things inside the Pattern, even while it’s playing. I suspect this kind of goes “against the rules” (or at least against the philosophy) of Patterns, where you are defining a sort of template which is then instantiated so it can be played, and normally the connection is then “broken” with the original Pattern… What I’m doing has weird side effects, like the fact that if you have multiple (Event stream) players of the same Pattern, they all are affected by subsequent changes to its properties. But it’s fun to play and experiment, even if I’ve not really come up with anything completely satisfying yet. (-;