Notes From BOB2019 Konferenz

Programming, Conference Notes

On Friday I spent the day at BOB2019, a conference on 'technologies beyond the mainstream' with a heavy emphasis on functional programming. Functional Programming is one of those subjects that, despite spending time with Haskell, I feel constantly intimidated by. I blame the Leucochloridium Objectum parasite that I picked up in University and have found difficult to shake off.

Given this, however, I found the conference remarkably unintimidating! The atmosphere was really welcoming to people unfamiliar with the technologies being discussed and I found the balance between technical depth and general overview pretty much spot on. There were a couple of talks that I went to that really stuck in my head, so I thought I'd write my notes up on them.

Checking Musical Correctness

This talk, given by Chris Ford, was a fascinating talk on musical notation, type systems and the statistical structure of music. Jumping off from Huron's Sweet Anticipation, Chris demonstrated representing states within music (and the difference between descriptivist notions of rarity and prescriptivist notions of incorrectness in different musical domains), while demonstrating what can be done with musical autogeneration given the parameters of pitch and timing.

During one section of the talk, Chris demonstrated musical generation using higher-than-normal randomness (or entropy) for either the pitch or the timing of musical composition. The result was so weird sounding that I wonder if there would be a fun link between the unheimlich and randomness - between what Mark Fisher's description of the weird as the 'overabundance of presence' and an overabundance of entropy. Probably not, but it feels like it would be a fun concept to play around with. A kind of Mathematical Theory of the Weird.

Programmation en Logique

This talk, given by Lars Hupel, was a super fun look at Prolog, a logical programming language developed in the 70s. Prolog has a neat (and to modern developers, pretty unusual) structure - it's more of a query language over logical domains than a programming language in the sense of, say, Javascript. For example, we can state a domain of logical facts, like:

culture_ship(gcu_arbitrary).
culture_ship(ou_mistake_not).
culture_ship(gsv_zero_gravitas).
liseiden_ship(gellemtyan_asool_anafawaya).
culture_orbital(masaq).

human(diziet_sma).
chelgrian(mahrai_ziller).
chelgrian(quilan).

inhabits(diziet_sma, gcu_arbitrary).
inhabits(mahrai_ziller, masaq).

in_the_culture(X) :- inhabits(X,Y),(culture_ship(Y);culture_orbital(Y)).

Here we've defined a logical domain entities and a single clause that states that something is an inhabitant of the culture if it inhabits something, and that something is either a culture ship or a culture orbital. We can test whether those rules hold for certain inputs, such as checking as to whether mahrai_ziller is a chelgrian and an inhabitant of masaq:

?- chelgrian(mahrai_ziller).
true.

?- inhabits(mahrai_ziller, masaq).
true.

But we can also ask Prolog to return everything that satisfies a predicate, using an upper case variable:

?- chelgrian(X).
X = mahrai_ziller ;
X = quilan.

?- culture_ship(X).
X = gcu_arbitrary ;
X = ou_mistake_not ;
X = gsv_zero_gravitas.

We can even ask it for all culture inhabitants that are Chelgrians:

?- in_the_culture(X),chelgrian(X).
X = mahrai_ziller.

It's a very simple example, but you can build up these logical domains and rules and use features like backtracking to build up really complex logical queries (in University, I modelled a system to determine whether, given an input of flight paths, whether the flight paths were safe or whether they intersected or came to close).

Lars did a really great job of demonstrating Prolog's uniqueness! It's such a fun, interesting language and I wish I had more call to use it in my day-to-day life.

The Way of APL

This live-coding/chaos magick summoning session, given by Aaron Hsu, was a demonstration of a programming paradigm/language I'd heard of but never seen before called array programming. The most immediately striking thing about APL is that it forgos function names for a set of symbols, leading to the following code that finds all prime numbers between 1 and R:

(~R∊R∘.×R)/R←1↓ιR

Yeah.

Though I can't claim to have understood entirely what Aaron was during the coding demonstration (apart from, I think, causing us to descend into R'lyeh)...

... it definitely piqued my interest in an unusual but interesting paradigm and language.

BOB2019 Konferenz was really fun, and exposure to paradigms, languages and topics that I would not have otherwise encountered was really stimulating. Looking forward to shuffling along to future BOB Konfs!