[rk in conversation 12-Jan-2018]
In the context of SuperCollider the patterns library represents a kind of full functional model. In many ways it is a functional model: a pattern is an abstraction that is like a little entity of algorithmic score. It can be a particular score or not and it can be freely reused. Well ok, to talk about this I have to drill down a little bit and kind of get technical. So what a pattern is: it is such an object that you say: “Ok, be a stream!”. And it creates a stream for you. So a pattern is a little bit like a class that creates instances. But there’s this very specific, special doubling or duality which is: as a stream it might act one way, but contributing to the definition of a stream it can act differently. So, in particular a number as a stream just returns itself infinitely. But embedded in the definition of another stream it returns itself once. And so this is completely the trick, the fundamental trick, that makes you have an easy framework where I can replace a single value with a subsequence of values. So that’s a kind of interesting thing. What I found with it is: it ends up much easier if you can also kind of go into an imperative mode in creating sequences of patterns over long time, particularly for the installation. And in a way there’s kind of a deep connection, you can think of it as the difference between writing a score and conducting it or interpreting it. So, writing a score is totally non-causal you know, you can do all these things. But when it comes to actually perform it in time it’s one thing after another, and the rule of time enters in. So, the functional style is fantastic, because it’s very very expressive. But when it comes to the gig, you want to say: “Now!”. And that’s much harder to do. So that’s kind of a deep issue. And so what’s really interesting about Scala is that’s designed to kind of work in this cross-relations and Hanns and I have been talking about that and how the patterns library, or a version of it, could be added to Mellite. And in the context of SuperCollider I had a strong bias, which is like: “Ah. I want processes!”. Because there are lots of things that are easy to write that way. And then the interesting thing is in Scala processes are really an issue, but it has a much more robust kind of functional library. Well ok, so how far can we go without that?