Thank you.
So this is going to be a very different talk in the last few in this room.
Definitely don't take my advice on anything about regulations or anything legal.
This is going to be about Essolangs as a hacker folk art.
So I approach this as an artist.
I have work which is more strictly visual art.
Oh, good.
Okay, it's still showing.
Good, good.
So for instance, oh, there we go.
For instance, this dither generator where you can create dithering patterns with different types of different shape pixels like triangles and hexagons.
And this is work that I also paint.
And then I have work like my straightened trees where I compulsively straighten trees in a way.
So it seems like I keep losing the video.
So you just have to imagine, oh, there it is again.
Some trees that are very straight.
And as you can see, it warps everything around it.
Both in the suburbs and the city taking on the opposite shape that the tree had.
And then I also make work as Essolangs.
For instance, this programming language where code is written as a labrant of folders and side of folders.
Where files are ignored.
And the names of folders are not considered apart from the alphabetical order in which they are read.
This is part of the hello world program.
So one of the nice things about folders is that in Windows.
Windows will tell you that folders take up no space on disk.
If you could see the screen, you would see a properties window that says that there are 352,449 folders.
And that they take up zero bytes on disk.
And of course, Windows is long to you, but this way you can pretend that you're storing all of your data and all of your programs as folders.
And that you have infinite file storage.
So for me, all this work is very connected.
The trees, the folders, all of it comes from the same place, from a way of exploring human rationality.
How we look at language and logic.
But for this last piece for folders, I'm not just building on work by artists that are sort of better known in the art community.
People like Yoko Ono who did instruction based work.
But of course, I'm also building on a whole history of Essolang programming languages.
In particular, when I made folders, I was thinking about the white space programming language, where we write code in tab space and return.
And I started with the idea of what is more empty than an empty appearing file.
And that would be a folder with nothing, it except for other empty folders.
And so I wanted to sort of explore the history of Essolang programming languages.
And I started a blog called Essolang Dark.co.
It looks really nice.
You'll just have to sort of imagine it because the video is cutting out.
But you can, there it is again, as Dark.co.
All right.
And so I began interviewing other people who make these languages back in 2011,
which eventually became this blog in 2014.
And I'm going to share a little bit of what I found about a few different genres of Essolang's.
And how we can think about them as its own sort of aesthetic history from outside the art world.
And then I'm going to show you a little bit more of my work if I leave myself enough time.
So we really need to begin with the turning tar pits.
Are people familiar with that term turning tar pit?
Is that something not familiar to anybody?
Not so many.
Okay.
Well, the name comes from that book, the Mythical Man Month, Frederick Brooks.
You know, he wrote this book that was very popular for a while.
And on the cover it had these, this picture of these creatures that eventually got trapped in the library.
Tar pits kind of struggling their way through.
And this was a term that started to become applied to some of the very early Essolang languages.
The first language that we can sort of properly call a turning tar pit was called false.
And with apologies to the Dutch speakers.
This was created by.
The Vuter von Orton-Merson.
Orton-Merson created this language as sort of a challenge to himself to create a fully functional programming language,
a fully featured programming language with a compiler of just one K.
For the Amiga.
And this is a language which.
It really looks like a right only language.
It has this very sort of dense vocabulary.
Almost everything is written with a single character.
It's a stock based language.
You can.
Which is sort of something that he chose because it's a way of keeping the language very small.
And one of the side effects was to make the compiler small.
It's impossible the commands are all one character long.
And this inspired a few other languages.
One of them is be funged by Chris Pressie.
Chris noticed that once you have characters that are one character.
Command that are one character.
You don't need to read them left to right.
You can have lines of code that start moving towards the right.
And then they turn up and they turn last and they turn down.
And they can flow in every direction.
And part of designing this was him thinking about designing a language.
So it would be the most difficult language to write a compiler for.
This also was for the Amiga and also 1993.
And then the other language that was inspired by false was BrainFuck.
Which.
Basically.
Urban Mueller said, OK, you've created a compiler that's one K.
I'm going to make one that's under 256 bytes.
And he did that by stripping down the code to the language.
The language to basically attorney machine.
And only has eight commands.
And what's interesting about BrainFuck is that all the commands individually are easy to understand and easy to read.
The whole cognitive gap between the text of code and his performance comes because of the complexity that builds up.
As you sort of write any sort of complex algorithm in BrainFuck.
And one way to sort of understand false BrainFuck and B.FUNs is by looking back.
To the 1950s.
We had a language called Flowmatic.
That was created in the late 50s.
And it was the first.
I believe it was the very first language that brought natural language into code.
It was created by Admiral Grace Hopper.
It looks like the code to the left.
It's what inspired Cobal and a bunch of other languages.
And what happened when this language was created.
Admiral Hopper wanted to create a language that would democratize code somewhat.
To make it sort of take it out of the hands of what John Beck is a foretran called the high priesthood of programmers.
The people who felt like they alone were sort of entitled to write code.
And they alone had the understanding of what was necessary.
It's our first sort of step towards democratizing code to make code available to more people.
To make the active programming available to more people.
But what happens with every time we try to democratize code is it also involves somewhat of deskilling.
It makes programming easier.
And there's always some push back to that.
And as back as described, some of the early programmers were not happy that all of a sudden this was sort of being taken away from them.
And there was a sense that this automatic was designed with the idea of turning managers into coders.
That we wouldn't really need dedicated programmers as much.
And we thought this happened over and over again since then.
I think it was the original idea behind visual basic.
And of course we're seeing it now with AI assisted coding.
That all these things are supposed to make it so business folks can write code with less help from programmers.
And that somehow it's going to solve the sort of underlying difficulty of writing code.
And of course it never really works.
But what happens instead is it creates a new kind of expertise.
The people who are experts in the new system.
And it's somewhat sidelines the expertise of the old system but that never really goes away.
And we see evidence of this in the essay the humble programmer by Dykestra.
Now this was written a bit later in the early 70s.
Based on thoughts that he had going back to the late 50s.
What Dykestra was concerned about is that there were programmers who still sort of wrote code in the old style.
And he thought it was very essential at this moment to professionalize programming.
He says, what opinion that he would run into a lot is that a really competent programmer should be puddleminded and very fond of clever tricks.
The other one was that programming was nothing more than optimizing the efficiency of the computational process.
And what he wanted was to get away from that type of thinking.
Now that computer cycles were cheaper we don't need to shave off a few of them.
We don't have to write more and more efficient code.
Instead we have to write code in neutral voice that other people can understand.
So that we can become widget makers that can fit with other people's widgets.
Everything should be written in neutral tone of voice.
We should not be trying to show off and everything should be sort of readable to other people.
Is it kind of corporatizing of coding.
One of the things he in particular did not like is the idea of the one liner.
The idea that a programmer places a one line program on the desk of another.
I'm proudly tells what it does and ask the question, can you code this in fewer symbols.
And you know the whole essay just sort of he sort of makes the same points over and over again.
And it's kind of typical dixtra where he's he's kind of bitchy and.
So by going back to the touring tar pits, these are languages that invite the exact kind of thinking that dixtra wanted us to get to get past.
So the idea of writing something in a neutral in a neutral voice or writing something with clarity as sort of the.
The ultimate aim because it's very difficult to write clear code and brain fuck.
So what I have here is five different ways to write the number 35 in brain fuck.
The only one I can read at the top one.
It is adding five to one memory cell moving to the right, adding seven moving to the left, subtracting one moving to the right,
subtract adding seven again.
It's basically this is how multiplication is done in brain fuck.
The others are all more complex.
They use wrapping, which means they go past 255 because in brain fuck a memory cell.
The other example is that we have here do the same thing in fewer characters.
So the first original example is 18 characters long, but the last one is only 14 and it does that by taking advantage of 12 different memory cells and moving back across them in different ways.
You can see what it looks like now at the bottom.
So Chris Pressie, the creator of BFUNGE, has described brain fuck as the 12 bar blues of SLX because there's so many variations of it.
There's so many people who sort of made their own version.
One of them that I like in particular is called body fuck.
It is really sort of an early interface for brain fuck where you have to sort of physically carry out the labor of programming.
And this was done before the connect.
So this is all using a webcam.
It's made by Nick Hunselman.
If you want to move to the left and memory, which is what he was doing just there, he has to sort of stand there for a while until it picks up that left motion has happened.
The next example is called TT type.
It is sort of a hypercapitalist version of brain fuck where each of the symbols has a different value in the market.
And they are constantly changing.
It's made by the Canadian developer Edith Vow.
And so you can start a program using a lot of plus signs because they're cheaper.
And then they can sort of go up and value and you have to sort of move towards obstructing it differently.
One of my favorite examples is the language Leninquidge.
Leninquidge asks, do we really need binary?
Can't be code in Unery using one symbol.
And this is the beginning of a hello world program.
So the thing about Leninquidge is, of course, the number of ones is itself a number and that can be broken down into a brain fuck program.
If you wanted to write hello world to the screen and you want to represent each one with a single atom,
but it would take more matters than exists in the universe to complete.
So those are some of the brain fuck variations.
I'm going to move now to one of the other sort of best known SLangs, the language peat.
Our people familiar with peat is something that people have seen before a few people.
So peat is a language which is,
it's represented by an image and it's the change in color from what are called codals,
which are basically just like it's sort of similar to a pixel that is represented as a box that is four or nine pixels or larger that you can draw the image bigger.
And it's sort of building on the idea of be fun.
You can write code that moves left to right and then turns up and then down and so on,
except now with peats we're doing the same thing but without characters we're doing it with the change of color.
So it goes through the red block it gets to the pink block and some of these colors are showing it to turn a different direction.
And you can see the left is a very early peat program.
The one to the right is actually a peat program, a peat interpreter written in peat.
This is what a computer generated one looks like.
And what's happened with peat over time is that individual programmers have sort of developed their own style in it.
Thomas Scotch created this program which prints peat to the screen.
It was used as a cover for the speaking code book.
And this is an example of a language that we call a multi-coding oscilling.
In that there's two different ways to read the code.
You can read it as what it will perform and it can read it as the image that it produces as code.
And these two different readings impact each other.
Basically the programmer is trying to create something or work and peat but usually they want to express something visually as well.
And this relates to other literary and artistic traditions.
Sort of the best known is probably Aleppo which is a group of mathematicians and writers based in Paris in the 50s and 60s who did constraint based writing.
They called themselves the rats who designed their own mazes.
They would create a constraint system and then create literary works within that system.
Probably the most famous example of this is the book by George Perek which in English is called Avoid.
And it is a book written by somebody who has four easiness name.
He's written an entire novel without using the letter E.
This is the first page.
And you can see he's honored in Paris with a pause George Perek which is written like that.
So you start to over time you start to have more peat programs that were influenced by the earlier pieces.
And then you had pieces that really took their own direction entirely.
This is a pie program by Richard Mitten.
And it calculates pie based on the size of this circle.
So the circle of the image actually represents a circle and code.
And the larger that you draw this program the more accurate it'll calculate pie.
Then you have people who write peat programs and hide them in other images.
So this was like an advent of code experiment.
This is the basic peat program to the right.
Here it is with the black characters that sort of box it in.
And then so is designed to look more and more like a Christmas tree.
And then it fills in with non-peat colors to the left to basically hide the code in the image.
And then finally my favorite example.
This is a peat ready made.
Someone saw a painting.
They thought it looked like a peat program.
They decided to recreate it and code to see if it would work as peat.
And it turns out it does.
It copies input to output.
So you can click characters and they'll print them out.
It was totally unintentional by the painter.
And somebody whose name actually happened to be peat saw this and thought that it had some potential.
So there are many other types of multi-coding oscillangs.
And some of them leave more room for expressiveness of the programmer than others.
One of the really famous ones is called Shakespeare.
It's not a great language.
It was sort of funny when it first came out.
But it's sort of lift on and oscilling listicles over the last 20 years and it keeps getting repeated.
You basically write code where you have these long lines of compliments or insults that add one or subtract one.
The reason I don't really love Shakespeare is that if you wrote a Shakespeare program and I wrote a Shakespeare program,
they would read pretty much the same way.
It's a very little room for expressiveness.
I think the joke kind of runs cold after a short time.
But the thing about Shakespeare is that it inspired a whole bunch of other programming languages that used haxt.
There's ash paper that tries to use aspects of poetry that people actually use, like capitalization in the middle of the word,
or how much things are invented and so on.
An inverse which produces visuals based on poetry.
But each program has its own word table.
So the vocabulary is specific to each poem.
So I'm going to talk about a third type of oscilling,
which are oscilling that are more directly critical of technology.
And the one that I'm going to pick on right now is the ones that deal with English,
the sort of hegemony of English.
So we didn't always have programming languages that were using so many English keywords.
We have APL.
They're also there were Soviet programming languages and languages in other countries that used keywords from other natural languages.
But right now we're sort of dominated by English.
And there are a number of programmers who sort of pushed back against that with creative projects.
One of them is called ALB.
This is created by Ramsey Nasser.
It's an Arabic list.
And this started out as not meaning to be an oscilling as much as a practical programming language.
But what he found was that a lot of the underlying technology that was supposed to be in different
to natural language didn't really work correctly with right to left languages.
Even though they said that they were all unicode compliant and they all sort of worked.
They should work with any language.
But there were also some other sort of cultural things that were a little bit difficult.
Because the programming language is not just the code that you write.
It's everything that's output as well.
And you have to consider what is the Arabic word for abstract proxy bean.
But ALB sort of started a little movement.
This is a language by Anuluwapay who was an Igerian programmer who works for mostly European companies.
He has to speak English all day and after hours he's like,
I want to be able to write code in Europe.
So he created this language for himself and his friends.
And all of it uses the Europe language and syntax.
And then there are some that are more explicitly creative pieces.
This is Wanyan Lang which is written in classical Chinese where you write code as poetry in the style of the various poets.
This is a 99 bottles program which is in the style of Levi who is apparently famous for his drinking habit.
And it's the person who translated this for me calls him the greatest poet in Chinese history.
Apparently nine numbers and wine number, wine and wine or homophones in Chinese.
There's a lot of sort of like textual play in it as well.
So going back to this idea of the constraint-based thinking that comes in Asalang's.
The Olympians, those mathematicians and writers ask questions like,
How small, how tight can you make a set of constraints and still produce literature that's interesting.
Can you for instance create a poem of a single letter?
Is there something that is different in feeling from the letter from the poem A and the poem B?
But eventually someone did do that.
Aaron Saroyan who is a minimalist poet.
Produced this poem and I'm with an extra arch.
And so bringing this to Asalang's, we can think about how programming languages can sort of play with constraints.
I created a programming language called past tense.
And this is a language where there are valid programs in the language but they do not run.
If a program runs in any language, it's not valid as past tense because past tense is only for programs we're never going to run again.
I created a converter so you can turn your existing code into past tense.
This is what it looks like for a C-sharp program.
Name's based, hello, world, public class programs.
Public static-voided means strong arcs.
System-consult, wrote lines, hello, world.
One of the great things about creating an Asalang or any kind of systems art is that other people will come to it and bring their own point of view.
That's sort of exciting about languages like Pete, David Morgan-Mar, who created Pete.
He didn't really know how far people would take the language.
I created a language called fatfinger.
It's a version of JavaScript where you can spell everything wrong and it still works.
Basically how it functions, you include the fatfinger library and then you create any script tag with JavaScript misspelled.
It says Java OScript and then you instead of varts, varts and document has a bunch of keys in it.
It just looks for the closest thing that it understands to what you typed.
The thing about putting this out in the world is people did not use it the way I was expecting.
For me it was really about compulsiveness and code which is sort of more what I'm interested in.
But there were some code poets who realized that you could intentionally use a different word in place of the expected word rather than the misspelling.
So this is a piece by Jeremy Douglas where he uses the variable who and then uses it also as what and when and why.
And he's able to use it interchangeably to create something that reads as English poetry but still functions as JavaScript.
And he created sort of a map called fat doctals of various words that most of the time will function in fatfinger as their equivalents in JavaScript.
I'm going to show my language.
This is a recent programming language.
I know we have some people in the audience from software heritage.
So I want to share that this language was shown at this exhibition UNESCO.
That's to be comparison which is a celebration of open source code.
Related to programming language that we write with these flowing lines.
It's actually written with box drawing characters.
Which are holdovers from systems like the one that I learned to program on the commoner 64 where you can draw user interfaces like the one on the left with these different corners and lines.
But in review, instead of creating boxes, we're creating these sort of flows called strands.
And each strand does something different.
It's a list based language.
In this case, all of these lines have these hooks sort of in a line.
So they're already into one list.
And what they're producing are the integers that correspond to the string hello world.
This is not my program but a piece by a programmer in London for review that.
And a lot of the sort of fun of writing in this language is that you might create one version of a program.
But then you'll find a denser way of saying the same thing that sort of looks better.
And so there's a lot of writing code and then sort of reworking it more and more to get it to function to sort of look better on the screen.
And one thing I was thinking about in designing this language is the way that maze is work and have similar that is to source code.
When we see a maze, usually we're not in in the maze like we might be to one on the left where we can't see the whole of it.
Usually we're looking at it from above where we can see all the different paths.
But that doesn't mean that it's entirely obvious how to get through the maze.
We still have to sort of run it in our heads to sort of find the way.
And of course it's very similar with code.
If we look at this kind of spaghetti code to the right, we have to sort of make sense of it by sort of running it running through it in our heads.
Just looking at it is not sort of enough.
When I put when this got to Hacker News, it created a lot of confusion.
This is one comment by a programmer who says, it's just what it feels like to learn to program as an adult.
I can brainfuck an APL with the best of them and this is the most alien language specification I've ever read.
Part of it is that each type of strands moves in a different way.
So some of them, so this is a complete Fibonacci program.
Each sort of unit here, it's sort of like a paragraph of code.
It's called a glyph.
It starts with these markers to the left and the upper left and the bottom right.
And it's the way that they move through the space that matters.
But if they have a little space at the end, it means they're pointing to a memory cell.
If they don't that it's the way that they move back and forth, you can see the line numbers restart for each glyph.
And we always skip line number four.
It's not that I hate the number four.
It's that it's all in successive prime numbers.
Now a lot of some people, the thing about it is that there's no particular reason it had to be prime numbers.
And I get asked sometimes, I can't explain why.
As if there needs to be a reason, the reason is because that's what I decided to do.
It needed to be numbers. It couldn't just be linear because it would be very hard to draw large numbers in this language.
And I didn't want it to be prime numbers sort of have like a nice sort of flow in the way that they increase.
And it feels like it has meaning, but it's very arbitrary.
And part of the thinking behind this language was I was imagining that this programming language had developed more like a natural language.
That it would have these arbitrary decisions that would become part of it over time.
And that sort of have an internal logic, but that don't are not really sort of explainable.
Because the basic type of strands adds and subtracts value by moving back and forth on each line.
There are many different ways to draw the same thing.
So this is three different ways to create one list with a zero and a one and another list with a live end.
And these we're going to use in the Fibonacci program and these are all equivalent.
This is a complete set of the the whole Fibonacci program written five different ways.
So this is a language which is right now very difficult for AI to make sense of.
I think AI is very bad at understanding code that.
Where the code flows vertically instead of just left to write.
But also of course it's not enough of it for it to make sense of.
But I like to think that all of these usalangs are a form of resistance to AI.
I mean, if we think about how mainstream languages have sort of.
You know, the sort of procedural multi paradigm languages that sort of adopt the same things every year.
It becomes very sort of planned over time.
And then we have AI sort of producing a sort of bland code.
And it's a stuff that would make dixtra happy because it's very well, sometimes it's readable.
It's it's it's definitely has a neutral style and reduces the sense of individual expression within the text of code.
That assoing's feel like a place of resistance against that.
Instead of having, you know, five programming languages to rule the world, we can all make languages of our own.
They might be languages that will only be understandable to a few other people.
But we have control over how it looks, how it functions, and what is possible to say in it.
I'm just going to share a couple more things.
How much more time do I have?
Like, I can go on.
Yeah.
Okay.
All right.
I have a lot more time than I thought.
I will show a few more languages.
So I showed you that finger.
That finger was actually inspired by an earlier language of mine called entropy.
So usually when we think about assoing's, we think of code that's very difficult to read.
But the code in entropy is actually very straightforward.
It's as very sort of bureaucratic code.
It looks like a mix of Pascal and C.
But the thing that's unusual about entropy is that the data decays the more that you use it.
So every time you access a variable, it'll be randomized very slightly.
So this is what the 99 bottles sounds like in entropy.
If I can get to start it.
So I have a little bit here.
18.0.
So you notice that the voice changed there.
That is the place where it's decided that it's no longer speaking English, that it's in German.
I did write Eliza in entropy.
It ended up becoming drunk Eliza.
This was sort of an interesting cultural experiment.
The more that you talk, she sort of crashes a lot.
But basically you could have a CRD crash.
You can have conversations with her.
And the thing that's sort of interesting is that her data bank sort of becomes more and more decayed.
The more that you talk with her.
And people's responses tend to be the same.
That the longer they communicated with her, the more they're sort of just hitting their keyboard.
One thing about entropy is that originally I wrote a C sharp compiler for this.
I guess that was in 2010.
And then a few years later, another developer Andrew Hoyer decided to create a JavaScript version.
Which is actually sort of now what I've built more recent versions of entropy on top of,
because this was a really smart idea that you could do visual work in entropy.
And you could sort of carry this into, you could do things that were sort of not very obvious before.
And I think that that's really sort of what's rich about doing assaling work is that it's always communication with other people.
Anything that you make, if there's interests from the rest of the community, people will,
like you don't really understand your language until other people bring their own vision to it and write programs in it.
If you're lucky enough, people will create their own interpreters for your language.
They'll expand what sort of possible to do in the language and they'll bring new insight into what it is that you've created.
So it's something that's always community based.
It's always collaborative.
And I think that that's why, to some extent, it's very indebted to the history of open source.
I don't think it really makes sense so much in other contexts.
And to some degree, it's always going to be a little bit outside the art world,
because I don't think that this is ever going to be really sellable.
Because who would want, like if someone made an NFT out of their assaling,
no one would want to contribute to it.
It would just sort of ruin the whole thing.
So it's not very commercially viable to be making these languages,
but it's something that I think is very rewarding and is the work that I'm really excited about.
So I do have a book of assalangs that just came out.
It's a little bit hard for me to recommend buying this book here,
because it's very expensive with the tariffs.
So I think you might have to wait for, you know, my country to unfuck itself.
And then by the book.
But I do have some copies here if people want to buy it without the tariffs.
And I want to mention that I am going to be speaking about the assalangs from the book
in Carl's Room next Friday at Zed Kayam.
So if you are in that area, or if you are friends who are in that area,
it would be great if you came out.
It would be more of a straightforward discussion of other languages from the book.
And since I still have a few minutes, I'm going to show the language that I showed
at last year's Faustam, which is called valence.
And if anyone was at my talk last year, no, okay, good.
So this won't be a repeat.
So valence is a programming language that sort of fills in something that's really sort of missing
in the world of programming, but that comes very easily to natural language.
So natural language, we can construct sentences like Billy saw the group at the telescope.
And if I say Billy saw the group at the telescope, there's two different ways to understand this.
It could be that Billy was looking through the telescope and saw the group or it could be that Billy saw the group
and the group had the telescope.
So these are two different ways that we can break down that sentence.
So what if we had code a programming language that allowed for that same thing?
So I decided to produce it and I would use only ancient Greek characters to represent it.
These are the eight characters that I used for that.
In the idea of the language is that every single, each of these characters are the eight variables you can use.
They're also, they also represent the eight octal digits that you can use.
Each one is a command and an expression and it takes either zero, one or two parameters.
If it takes one, it's prefix and if it takes two, it's in fix.
And so what happens when you write code is that every single possible interpretation of that code shows up.
So let's just give this a minute for the signal to come back.
There it is. Okay. Great. So I can just start typing and something will happen.
And you can see I already have nine interpretations for the more runnable.
The ones that are not runnable are because they are wild statements that do not have a closing bracket.
I can add the closing bracket and now but I have five runnable.
But the great thing about this is you can just sort of key mash with the left hands and you get a whole bunch of different programs coming out of it.
So I already have 81 different versions of this and I can run them and when the program runs it runs every single variation of this.
And then if you want to lock down the meaning somewhat more, you can put brackets around it which make it more specific because the brackets only go around parameters, not around the commands and this gives you a little bit more control.
So that's pretty much what I have and I am ready to open this up to your questions.
Let me put my contact info up here for you all.
That's for my mailing list, the big QR code.
Thanks everybody.
So we are super lucky because we have ten minutes left for questions and now you will torture me.
Please raise your hand.
I will try to run as fast as possible to you because we are unfucking it.
I start there.
Hello.
Thanks.
So have you or other.
Have you or other as a longer creator been contacted by video games developers?
Because there are some video games that try to hide secret languages in image in music.
Some are very creative like tunic that creates a language with a music and everything.
And that would be incredible.
If in the game there was hidden elements that were programming language, people would have their mind blown trying to figure out the syntax and finding it.
Okay, so I got parts of that question.
So I have not worked on video game systems but there is something very much.
The sort of puzzle nature of a lot of these languages does feel a lot like a kind of gaming.
I think a lot of it.
There's a big crossover between the sort of.
The sort of hacker play and SLangs and in video games.
And you said something about music.
There are a number of SLangs that use.
Images and that sort of thing to produce code.
I do have a programming language that you write with music.
Which.
If this comes back up.
So this is an asling of mine.
It's trying to load.
There goes.
That you write by whistling code to the computer.
So it's usually hard for me to whistle after talking for half an hour.
But I can I can try to see if I can produce some code here.
There we go.
I have the beginning of something happening here.
I see able to set the route.
I'm starting a.
That statement here.
Okay, syntax error.
Sorry.
Okay.
I'll leave that for you to try at home.
Next question, please.
Name and shame.
What real language would you classify as an SLang?
Real language.
I don't know, love you.
So I'm definitely not somebody to discourage people from using SLang's in production.
But so the question is really about language is that sort of cross that line between sort of why general use that feel asceteric.
I mean, the kind of famous example is Pearl.
A lot of people consider regular expressions in general and Pearl as asceteric.
But you know, for me, for me, it's really JavaScript.
You know, I think that like, you know, there's already dialects of JavaScript.
I don't know if people have heard of Jay as fuck.
This was created by Martin Clappy who realized that you could write valid JavaScript using just six punctuation signs.
And this is a way of this whole thing translates to overt one.
It really comes from basically creating truth values and adding to them to create numbers,
could bring them into strings and so on, that you can basically reproduce all of JavaScript this way.
And what was sort of amazing, so this is more of a asceteric dialects, I guess, of JavaScript.
I also have a couple of my own asceteric JavaScript dialects in the book.
But I think Jay as fuck is really one of the things about this language is that while he created it for sort of a kind of creative play.
For a little while people were using this to get around malware filters until they started checking for Jay as fuck.
So yeah, anyway, this is sort of, yeah, I would put JavaScript as the top of my list.
One, two, three. After this we just take another two questions.
How did you get so into this? How did you get so into this? How did I get into this?
Yeah, so basically I was working as a programmer.
The first thing that I saw that really drew me into this was when I read a paper that showed that mind sweeper was turning complete.
And I became very curious about that, and I started that I found Pete, and I made sort of an answer language to it, which was the original version of the loto, which is not involving whistling, but MIDI files, sort of a musical version of Pete, where you write code as notes.
And I was doing this for fun, then I went to art school for photography, and when I got there, I realized, oh wait a minute, this thing I've been doing for fun is we can think of this as an art context.
Maybe this is what I'm more excited about, and so that's when I started the interview series.
Do you notice that as these SL lines evolve, they've come from brain folk or something, and they eventually kind of fork off into their own dialects and things?
Do you find it similar to human linguistics, how these lines would just change over time, or how they kind of are built off one another?
Does somebody kind of repeat that question for me? I'm sorry, it's very hard to hear it down here.
Is something about linguistics?
Yeah, so do you see how these SL lines kind of evolve from one another? Does it kind of look similar to how human linguistics works, where languages kind of diverge and build on top one other?
So there's something about languages diverging and linguistics. So one thing I want to say, we have with AI prompting right now, right? We have this sort of weird collision of natural language and code.
But that's not the only way to bring those two things together, and there are a lot of SL lines that sort of explore the connection between natural language and code and try to bring it in other ways that sort of invite more ambiguity.
There is a language called Prasa, which uses a South Indian language. It doesn't use the language itself. You actually write it in English, but uses the rhythm of the Southern language and how it plays off that rhythm is the way that code is written.
And then there is a language called Love Language by a student at Carnegie Mellon where you can write sentences in English and the syntactic breakdown of the sentence. The syntax tree gets turned into brain fuck.
So it's actually using linguistics that way. So there's people are finding more sort of interesting ways to bring those two things together.
And it's something that I sort of explore quite a bit in the book, which is sort of interesting because the book kind of came out right before the AI prompting became such a huge thing. And in some ways feels like an answer to that, even though it was written sort of before a lot of that was happening.
So hopefully that answered your question.
So, and with that, thank you so much, Daniel. Give him another round of applause. Thanks.