Algorave: Algorithmic Dance Culture

I had some fun giving a talk at TEDxHull about algorave and things, the video just went up, here it is:

Coding with knots

My first Quipu attempt

Being inspired by Quipu, and also Dave and Julian‘s work on visualising and sonifying Quipu data (their “coding with knots” paper is here, will link to preprint soon..), I thought I’d have a go at making some. Quipu seem to be ancient databases, used to archive and communicate information. They were in use by Andean people over hundreds of years. The goal is to encode Tidal patterns in a similar manner, which I think was also Dave’s idea. So far, I think this should work very well.. Some initial (and of course, naive) thoughts about trying to make Quipu are below.

Representation of a real Quipu (Meyers Konversations-Lexikon, 1888)

I started with four-ply 100% cotton handknit yarn, which was less fluffy and easier to work with than sheep’s wool. It did cross my mind to try to find Alpaca wool for authenticity, but it was not very easy to find, and I read that cotton was used in the Quipu too. After a bit of knotting things weren’t going too well, due to the stretchiness of the yarn it was difficult to get the knots close together, and it was all a bit fiddly.. Especially for the ‘end knot’ in a number which requires you to pass the yarn through its own loop up to nine times, securing itself in neat spiral. I wondered whether this yarn had the right structure for the task..

Looking closer at the diagrams and photographs of Quipu on-line though, it became clear that the Quipu yarn was ‘doubled’ – folded in half and twisted together to create a loop at one end, which could then be used to attach to another piece of yarn with a ‘cow hitch’. I found I could double small pieces of wool quite easily by hand, by twisting it with the direction of the existing twist until I met resistance, folding the yarn in half, and letting it twist together. Happily, the result was a yarn which was not only easy to hitch (and un-hitch) from another piece, but also was much easier to work with, in terms of tying the knots and getting them to sit in the right place, with a little help from a 20mm crochet hook.

It seemed important to start knotting at the bottom of the doubled yarn, otherwise it would start to unravel back to its original 4-ply. In terms of the Quipu representation of natural numbers (which handily, is base ten), this meant starting by knotting the unit, and then the tens, and so on. Once attached, the threads were easy to move along the thread they were attached to, and un-hitch if necessary.

I’ll need a lot more practice to make the knots more ‘readable’. Yarn is twisted in a particular direction – in this case the ‘Z’ rather than ‘S’ direction, so perhaps the knots have to match in terms of whether they’re right or left handed. There is a suggestion that the direction of twist and handedness of the knot is significant in terms of information storage, I’m a bit sceptical about this, as least they appear to be dependent on one another. For now I’m putting a little bit of twist into the yarn as I tie the knot to make sure the ply doesn’t ‘open up’.

Anyway, I think I have some grasp of how this can work now. The next task is to try to notate Tidal patterns. The ability to hitch threads to the side of others should make knotting together the parse tree of a TidalCycles pattern fairly straightforward. I’d also like to use beads to represent things which aren’t directly numerical, such as sound samples — Hama beads look perfect for this, the right size, available in bulk in a wide range of colours, and cheap! Hopefully I’ll have something to show at my lunchtime talk at the ODI this Friday.

*Update* I did indeed manage to transliterate some Tidal code into knots and beads, in particular taking this by Kindohm:

jux (|*| speed "1.5") $ foldEvery [3,4] (0.25 <~) $ stack [
  s "less:2([3 5]/2,8)" # unit "c" # speed "4",
  s "less(3,8)" # cut "1" # up "{0 -3 1}%32",
  s "{~ [~ cp] ~ less:3/2 ~}%4",
  s "[less:1*2 less:1]*2"]

I created this:

I’ll post again with more explanatory detail, but from my notes..

  • Knots are numbers, including a slightly awkward attempt at representing rational numbers
  • Values which are not directly numerical are represented with beads. Samples are yellow for cp and purple for feel (the sample number is a number, so is a knot). As an exception, single letters of the alphabet are treated as ordinal numbers and so represented with knots, e.g. c = 3.
  • Function names are a bead followed by a brown bead. In particular, red brown for jux, pink brown for foldEvery, blue brown for ~>
  • Subpatterns and functions-as-parameters are separate strings tied on to the side (currying works out fine)
  • Parameter names are a bead followed by a black bead. red black for sound, green black for cut, blue black for up, pink black for speed.

The parse tree comes out rather nicely I think, and is almost a complete representation of the original pattern (I decided to overlook the difference between # and |*| for this first attempt). I’m trying to minimise the use of beads, treating colours as logograms feels like cheating, simply making a text out of an alphabet of colour. The branching structure is what takes it away from one dimensional text though, and into something which is much closer to that of a running computer program (particularly a pure functional one like a Tidal pattern).

The next step is to try to compose a new pattern directly as string, to explore its affordances.. Maybe this could inspire a breakthrough in usability for my Texture interface for Tidal..

Algorave Leeds

Had a fun time in Leeds last night, here’s the recording of my live code improv:

Stream to Algorave Montréal

A recording of a stream I did to Algorave Montréal this morning

65dos on TidalCycles

Pretty chuffed that 65daysofstatic, who are the best band, have been exploring TidalCycles while making the soundtrack to no man’s sky, and  happy that I can finally share this with you:

They’re using it in the first track, to control ebows on their guitars as well as triggering sample patterns. True to form, it’s a huge song. Here’s an article with a bit more info.

Are Algorithms In Tune With Music?

I spoke to DJ Semtex about algorithms last month:

You can read the full article here.

TEDx Hull

Looking forward to talking about Algorave, live coding, TidalCycles and a cultural grounding for it all in pattern at TEDx Hull tomorrow. I have been a bit unsure whether the showbiz 15 minute talk was for me but preparing for it has been a nice exercise in organising my thoughts, and I am now really looking forward to it. I’ll do some semi-improvised live coding, hopefully won’t crash and burn.. The rest of the line-up is really interesting too.

Spring things

Things coming up in 2017..

  • Running Tidalclub Sheffield with Lucy Cheesman – every third Thursday of the month, the third edition this 16th March
  • 17th Mar – Algorave wearefive – celebratory online stream with 48 performances beaming from round the world + clock
  • 23 Mar – Algorave Berlin – a really nice line-up, I’ll be playing solo
  • 31 Mar – TEDx Hull – a talk about algorave, and algorithmic dance culture
  • 22 Apr – Eulerroom 6 – haven’t done one of these for a while.. Hosted by Tidal Club, I’ll be organising with Lucy but not actually playing.
  • 28 Apr – Algorave Leeds – another huge line-up, live coding solo again
  • 16 May – Taking part in a panel session at Thinking Digital Arts, Gateshead
  • 26/27 May – Running a two-day TidalCycles workshop with the multi-channel system at Call&Response in South London
  • 2 Jun – Back to the Open Data Institute in London, launching the outcomes of my residency there
  • 7 Jun – An evening TidalCycles workshop at London Music Hackspace, Somerset House
  • 9 Jun – Algorave activity as part of No Bounds festival, Hope Works Sheffield, I’ll be performing with Joanne
  • 23 Jun – Talk and probable algorave activity at Bump festival, Brussels
  • 9 Jul – Canute performance at the Bluedot festival algorave, Jodrell Bank
  • 18-20 Aug – Another collab with Joanne at the Green Man festival algorave in Einstein’s Garden
  • 9 Sep – Organising evening performances at FARM Workshop 2017, Oxford
  • 8-12 Nov – Organising Algomech festival in Sheffield again

More TBA

PENELOPE

I’ve just realised that I haven’t posted here about my new job. I have left my post as research/teaching fellow in the University of Leeds, and since February 2017 have started work for a Museum, in particular the Research Institute of the Deutsches Museum, an incredible science museum in Munich — although I am still based in Sheffield UK. I’ll be working part time over the next five years on the PENELOPE research project lead by Ellen Harlizius-Klück, following our previous project Weaving Codes, Coding Weaves.

“Our aim is to integrate ancient weaving into the history of science and technology, especially digital technology. The project encompasses the investigation of ancient sources as well as practices and technological principles of ancient weaving. We set up a PENELOPEan laboratory where we detect the models and topologies of weaves and develop codes to make them virtually explorable.”
It’s a great privilege to have this huge chunk of time to really get to the bottom of something, an experience I haven’t had since my PhD. The project has much deeper connection to the world of live coding than it might first appear, being all about computational pattern, and the sharing of thought — but taking a much longer view of live coding than is usual. You can read more on the project website, including a brief exploration of making music from ‘tabby’ weaves.

Patterns are the time of numbers

Ok this post is going to look quite dry, but is actually very exciting, at least for users of TidalCycles. So first here’s a video demonstrating the simplified syntax the below blurb will allow in a future version (version 1.0, which will probably be released soon after the upcoming 0.9).

If you want to see more videos like this check the playlists on the TidalCycles youtube channel.

Anyway.. Something I’ve noticed at Tidal workshops is that beginners have problems with this sort of code:
density 2 "1 2 3 4"
There’s the pattern 1 2 3 4, denoted by quotes, and the number 2 without quotes. This says ‘make the pattern twice as dense’, so you end up with this every cycle: 1 2 3 4 1 2 3 4.

Fairly straightforward, but why is the 2 a number, not a pattern? With more complicated, higher-order patterns this becomes increasingly unclear. There are ways to treat that number like a pattern:

spread' (density) "2 5" $ "1 2 3 4"
or ..
do n <- "2 5"
   density n "1 2 3 4"

… but now you’re converting between numbers and patterns of numbers instead of engaging with the music you’re making.

So I asked about this on haskell-art, in particular how to make it so a function like density could take either a number, or a pattern of numbers. One suggestion from Henning Thielemann was surprising – that Tidal’s Pattern type could be defined as a Haskell Number.

To cut this short it turned out that simply by evaluating a small amount of very simple code[1], Tidal’s syntax suddenly becomes far more expressive.

Instead of:
d1 $ sound "bass3" # speed "1.2"

you can just do
d1 $ sound "bass3" # speed 1.2

instead of
d1 $ sound "bass3*4" # speed (scale 1.2 3.2 $ ((+) <$> (slow 4 tri1) <*> sine1))
you can just do:
d1 $ sound "bass3*4" # speed ((slow 4 tri1) + sine1 * 2 + 1.2)

instead of
d1 $ up (every 3 ((+12) <$>) "1 8 [7 ~ 4]") # sound "bd"
it’s simply:
d1 $ up (every 3 (+12) "1 8 [7 ~ 4]") # sound "bd"
and with a quick re-jig of the definition of functions like density:

instead of
d1 $ n ((+) <$> ((+) <$> "1 2 3" <*> slow 3 "0 1") <*> slow 2 "3 1") # sound "voodoo"
it’s:
d1 $ n ("1 2 3" + slow 3 "0 1" + slow 2 "3 1") # sound "voodoo"

and much more…

By redefining density and friends, e.g.:

let density tp p = unwrap $ (\tv -> withResultTime (/ tv) $ withQueryTime (* tv) p) <$> tp

It’s then possible to fulfil my original aim:

d1 $ density "1 [2 3] [1 3]/2" $ sound "bd [sn:2 mt]/2"
while still supporting the original syntax:
d1 $ density 1.5 $ sound "bd [sn:2 mt]/2"

Basically, it turns out that if you let Haskell treat patterns of numbers as numbers, it provides extremely expressive means for working with them. This makes sense — patterns of numbers are numbers, just numbers which are polyphonic, and vary over (rational) time.

Lovely. This is a huge and unexpected win, which greatly simplifies pattern combination and manipulation, in the process greatly extending the possibilities that are within reach of a few keystrokes. This renews my suspicion that Haskell is full of much wondrous stuff just waiting to be discovered..

[1] Here’s that ‘small amount of very simple code’, if you want to try this at home:

instance Num a => Num (Pattern a) where
negate = fmap negate
(+) = liftA2 (+)
(*) = liftA2 (*)
fromInteger = pure . fromInteger
abs = fmap abs
signum = fmap signum

instance (Fractional a) => Fractional (Pattern a) where
fromRational = pure . fromRational
(/) = liftA2 (/)