Pattern Salon: Day 1 Thoughts
11/23/2023
=============================

So today I woke up at Way Too Early in the morning my time so that I
could be awake for very early afternoon Barcelona time for the first
Algorithmic Pattern Salon, an event put on by some of the coolest
people working in the intersection of computation and art right now.

It was a good first day! You can find the schedule here with links to
the papers (when available):
https://salon.algorithmicpattern.org/schedule/

I'm not going to try and summarize the talks tonight because there's a
lot in my head and I think I want to read the papers again before I
try to digest it but I'll talk about one thing that was in my head a
lot while I watched this rapidfire series of short talks over a couple
hours: computing in context.

So one of the talks was from Kadi Pajupuu about a (family) of
techniques she called MultiWeave. I had asked a question in the talk
about whether MultiWeave was predictable when attempting to design
patterns, how likely were you to be surprised. This is always a
question on my mind because one of the things that makes livecoding
really interesting is that when you're writing down patterns you can't
always predict what will happen when all the different complicated
periods and rhythms interact, there's a lot of capacity for
surprise. That's also something I like about procedural generation
generally: you create a thing that creates things and this leads to
you being surprised by the interactions of small rules and patterns to
create larger things.

Anyway, Kadi basically said something to the effect of "no, it's very
predictable, but only once you have experience with the material and
the tension to use &c." and then that got me thinking about how
there's always these things in the arts that are
contexts/contingencies that make attempts to follow the exact same set
of instructions different each time.

This is, from a computational perspective, anti-thetical to pretty
much everything you want out of a program. I come from the programming
languages research side of things, especially the very categorical
logic/semantics oriented part of it, where ideas like referential
transparency and compositional semantics are sort of the ideal. The
most "natural" and mathematically pleasing kind of semantics is when a
computation represents a mathematical function, one that is
contextless and takes in arguments and returns a result.

Now, you might argue, doesn't the pretty much the entire existence of
I/O invalidate that perspective and the answer is well yes but
actually no. For decades we've been pretty good about knowing how to
still model I/O in a way that kind of contains and puts rules around
it: Moggi's work on effectful semantics with monads, Plotkin &al's
work on algebraic effects in the late 00s early 10s, &c. &c.

But those things don't entirely capture what I'm thinking of here in
terms of *context*, in terms of the possibility of a computation being
a situated (family of) things.

In other words, computation as something that is very explicitly a
function of its environment and the moment in time it runs. This is,
maybe, more like a comonad where a computation is a thing you pull out
of a context rather than you returning a new state of the world when
you run your computation, which is more like the moggi style monad
semantics that Haskell and such have been using for ages. For example,
you can use comonads to model computation in a cellular automata where
what a cell does is dependent on its neighbors.

One of the other things that's in my head is, a long time ago, there
was a notion of "context oriented programming"
(https://github.com/pcostanza/contextl) that always seemed really cool
but I never really got to touch.

I know this is getting a little rambly but it's hard to get try and
put into words the pictures I see in my head here, because what I'm
trying to convey is that I think there's a big possibility space of
language design that would make computation explicitly not implicitly
dependent on its environment, intentionally dependent on contingencies
rather than an attempt to abstract all the contingencies away.

Let me leave it on this provocative question: what's the computational
equivalent of 4'33"?