On tokens & vocabulary: AAAAAAAAAAAAAA!!!! vs Ook!

image

The languages AAAAAAAAAAAAAA!!!! (Zzo38, 2006) and Ook! (David Morgan-Mar, 2001) may both appear as blathering, undifferentiated yelling (and/or grunting). But these are programming language, meaning the string of exclamations are actually executable code — these lines are far more considered than they appear.

Underneath, the two languages are very different. Just looking at these sample programs gives this away; Ook! source code has a rhythm to it, while AAAAAAAAAAAAAA!!!! appears random and jagged:

Beginning of Hello, World! in Ook!: 

Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook! Ook! Ook? Ook! Ook? Ook. Ook! Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook? Ook. Ook. Ook. 

He in AAAAAAAAAAAAAA!!!! (there doesn’t seem to be a complete Hello, World! out there):

AA AAA AA AA, AAA, AAA, AA A AAA, AA A AA A AA A AAA, AA A AA A! AA AAA AA A, AAA AAAAA A AAAA, AAA! AA AAAA AA! AAA A AAA AAAA! AAA A AA AAAA AAA, AA A, AAA AAA, AA A AA A AA A, AAA AAA, AA A AA A! AAAA A AAA!

Ook! is another brainfuck equivalent (we looked at an example of this recently — well, sorta recently — with VerboseFuck). This means Ook! is brainfuck in an (orangutan) outfit. AAAAAAAAAAAAAA!!!! has a more developed command set. This is not to say that it is capable of doing more than Ook! — in fact, Ook! is Turing complete (meaning any basic program can be written in it), while AAAAAAAAAAAAAA!!!! might not qualify — its computational class is not yet determined. 

image

Since Ook! is brainfuck-equivalent, we can map the commands (Here are three — the whole list can be read here on esolangs.org):  

bf    Ook          Ook w/o the Ook
>     Ook. Ook?    .?
<     Ook? Ook.    ?.
-     Ook! Ook!    !!

Now the pattern becomes clear; if we take the Ooks out of Ook!, we’re left with a translation from one punctuation mark (bf) into two (ook). The basic unit of meaning in a programming language is the token (like a word in spoken language). There are only three symbols that matter in Ook!: the comma, exclamation mark and question mark, which define tokens when paired. The word is “Ook” might be necessary, but it does not contribute to the meaning of the token, it is just a placeholder between symbols, the equivalent of a single space between words. 

There’s a simplicity and minimalism to Ook!, which, like brainfuck itself, unfolds into great complexity in the programs actually written in it. Ook! uses three sumbols (period, exclamation and question mark) — but this is plenty; we know we only need two symbols to express all data: 1 and 0. There are even esolangs that use only two symbols, such as Iota, based on combinatory logic. But using three symbols means you need a lot of them to get anything done. The resulting programs are long, but the pattern of the Ook syllable is constant — all expression in this language is through punctuation showing how the Ooks are expressed. Our imaginary orangutan gets her ideas across through the inflection of her ooks. This emphasizes nuance and gesture, the very things that ordinarily carry no meaning in programming.

But with AAAAAAAAAAAAAA!!!!, the A’s themselves are not placeholders — the pattern of As actually matters. This allows for a much larger vocabulary but makes AAAAAAAAAAAAAA!!!! a particularly nasty language to code, creating complex, seemingly crazy patterns.

image

To make this more clear, here are a few commands in AAAAAAAAAAAAAA!!!!:

  • AA AAA n! Outputs number as a character
  • AAA AAAA AA n! Input a character store to index n
  • AAA AA n! Go to label n
  • AAAAA n! Define a label n
  • AAA AAAA AAA n! Skip n commands
  • AAAA AA n! Shift indexes n backwards
  • AAAA AAAA n! Shift indexes n forwards
  • AA AAAA AA! End program
  • AAAA, AAAA n! Forget n entries from subroutine stack
  • AAAA AAA n! Increment value at index n
  • AAAA AAA, n! Decrement value at index n unless value is zero

NOTE: This is only about HALF the list of commands (the complete list can be found at http://esolangs.org/wiki/AAAAAAAAAAAAAA!!!!).

Only a few numbers can be represented directly (0 through 4). AAAA is zero, AAA is one, but then a single A is two — so there is no obvious logic to the ordering. Numbers above four have to be created arithmetically, similar to how brainfuck deals with numbers.

The “n” in the commands refers to another group of AAAs, marking the name of a label or variable. So the actual pattern of AAAAAAAAAAAAAA!!!!; follows this structure:

[command] [expressions] !
In AAAAAAAAAAAAAA!!!!, what is a token? Would ”AAA” qualify? The command “AA AAA n!” only works with those first two breaks in the right place; the command is made up of “AA AAA.” “AA” by itself is meaningless, as is “AAA” (except as part of an expression where — SOMETIMES — it refers to the number one). “AA AAA” can be thought of as a single word that just happens to need a space in the middle of it. There are many other situations that we see three As together, like in the “AAA AAAA AA n!” command, which inputs a character. AAA is like a phoneme in speech, a building block of a word, but devoid of any meaning on its own, except in very specific contexts.
image

Other languages may use words differently in different contexts, but the contexts are still clear. For the most part, programming languages don’t allow a line of code to hold a multiplicity of meaning; even if the symbols are confusing to us, the compiler has reads it consistently. These two languages create confusion for the user not by creating a truly ambiguous system, but simply by defining a symbol in a way that implies ambiguity. In the end, each language is still a set of strictly enforced rules.

(NOTE: all AAAAAAAAAAAAAA!!!! images from Uncyclopedia, Ook image is based on a public domain Wikimedia Commons image)

Someone wrote a book on creating esolangs! Available in Japanese only. Google translates the title to &#8220;How to make of the strange language programming language ~ sides to make with Ruby&#8221;

Someone wrote a book on creating esolangs! Available in Japanese only. Google translates the title to “How to make of the strange language programming language ~ sides to make with Ruby”

My esolang Light Pattern will be featured in this 2-person show opening Sat night. Light Pattern uses photographs in the place of text source code &#8212; one communicates with the machine through images. See more on the website or come on out and see it Saturday
Show info:

Language &amp; Code
Transfer Gallery
1030 Metropolitan Ave, Brooklyn
Aug 9, 2014, starting 7pm

My esolang Light Pattern will be featured in this 2-person show opening Sat night. Light Pattern uses photographs in the place of text source code — one communicates with the machine through images. See more on the website or come on out and see it Saturday

Show info:

Language & Code

Transfer Gallery

1030 Metropolitan Ave, Brooklyn

Aug 9, 2014, starting 7pm

All the links from my talk at BHQFU

vanadasd asked:

I have been looking at Velato and I find it really interesting. I have been using it to print characters like your hello world application, but I have been having no luck with the if and while loops. Is there any chance that you have any examples of that or can confirm that they're working how you would expect?

rottytooth:

Hey, awesome you’re trying out Velato!

For people unfamiliar with the language, it uses music (as a MIDI file) as source code. You can find out more about the language here.

Here’s a test program using an if statement to show it functioning. I created it using the GUIDO system (specifically the gmn2midi tool), which basically lets me type in the notes I want and generate a MIDI file. You can find it here.

This is my program:

[
c a& a& d (* declare variable a& *)
c e& a& e& g d g (* set a& to 1 *)

c e g e& d a& d d e& g d g (* if a& == 1 *)
c a g e& d a& (* print the value of a& *)
c e b (* end if *)
]

It sets the value of Ab (written as a& in GUIDO) to 1 and then tests that it’s 1. You can make sure it works by changing the third line to this:

c e g e& d a& d d e& g e g (* if a& == 2 *)

(D is 1, since we’re starting in the key of C)

It’s important to remember that every command starts with C, unless we explicitly change the root note.

Interview with Keymaker

image
The 574 cycles of 010001011011

Interview with Keymaker
(January 2011)

Keymaker created languages such as Clue, Unnecessary, and Wheat. He (Keymaker is anonymous but identifies as male) has also developed a host of programs written in brainfuck — one of the most popular esolangs and inspiration for many esolangers — including a brainfuck interpreter written in brainfuck itself. Keymaker maintains a site devoted to brainfuck at http://www.bf-hacks.org and a site for his own esolangs at http://yiap.nfshost.com.

As has come out in this interview, Keymaker is self-taught, and shows how sophisticated esolanguages can be designed and built by dedicated non-programmers.

Do you remember how you first found out about esolangs?

Somewhere I came across brainfuck shown, I think, as a joke or something obscure toy that no “serious programmer” would/should use for anything. At once I knew I had found something that differed from all the traditional languages that I had no interest for at all. It was the best language I had ever seen.

What drew you to create your own languages?

Brainfuck, essentially. Before seeing it I had thought that you have to be very intelligent or an able mathematician to create a programming language. I was totally clueless of course. I didn’t know anything about computational science, and what I knew of programming and programming languages I wouldn’t even call knowledge now. But one thing was sure; I didn’t like the ‘normal’ languages I was seeing. I still don’t like languages like PHP or C or Java. But with brainfuck I began to see what computation was all about, and after finding more esolangs and programming in them I started to understand that it’s possible for the everyman to create languages that are not only as powerful as the old giants that everybody is telling you to learn and use but far better looking, far more usable (in certain tasks at least), far cooler. Languages where the programs themselves are visual art.

The thought process behind working in C is very different than that of Java, let alone Prolog or SQL. Some esolangs seem to be almost entirely about shaping a particular thought process for the programmer using them. Is the point-of-view of the language something you consider early on, or does it evolve as you build the language?

It may change, especially if the design process takes a long time (like usually). At times it’s clearer from the beginning and I maintain it till the end, and in those cases the language tends to become completed in a shorter time.

Perhaps you could explain a bit more about why you don’t like PHP, Java, etc — is it because of what they hide from the programmer? Are there high-level languages which you do like?

It’s difficult to explain why and even I’m not entirely sure of the reasons! It’d seem like I don’t like they way a program works in them, the way it looks like (Java especially is a nightmare). I don’t like binding, if that’s the correct term, memory with variable names. Mostly I use only one-letter variable names if I write in such languages. I hate giving functions and whatever elements an identifying name. Perhaps I’m too sensitive!

And then there’s the simple fact that I don’t think those languages are very easy or simple at all. More often than not they tend to make a simple task unnecessarily complex. I’m not sure there can be a programming language that’s not difficult to use to some degree since the tasks the languages are used for are not simple. But there could be something easier-to-use and every time I write something I’m asking myself why can’t they have this or that feature that would make things so much easier. Maybe I should try to make a non-esoteric language myself.

As for good high-level languages… Perhaps there are some that I’d like but I just haven’t found them. The best I’ve used is Python which I use for writing most of my esolang interpreters. It makes many things uncomplicated even if it has its shortcomings.

Do you work as a programmer? If so, have you ever snuck in production code written in an esolang?

I’m no programmer, no. If I were I might well do that but more likely my approach to the program and its inner logic would be “esoteric” already and the code be something nobody (including me a day later) could decipher.

Could you talk a bit about your process in language design? Has it been very different between different languages?

Yes, it has been different for every language but I haven’t always paid as much attention to it as I do nowadays. Generally I’m trying to make much better languages than I’ve done before, although I’ve always tried to make my languages as good as I’ve been able to.

Well, obviously all things begin with an idea of some sort. It may be an idea of just an unusual command, a gimmick with the control flow, some weirdness with the syntax, anything.

Most of the time I start then thinking what other features the language needs to be Turing-complete. That’s often a kind of benchmark. I haven’t always tried for it but lately I find it difficult not to. But as said, things go differently with every language. I would say it’s much like any other artistic work, the artist looks at things differently as time goes on and wants to work differently. I guess the same goes for any creative work. Anyway, when I have that one idea, the things I add to it should somehow fit with it. I don’t think I could reason what then goes on in my mind. I imagine it’s much what a painter does when choosing the fitting paints and how they’re placed on the canvas — although I may spend a considerably longer time on it. Often a fitting idea comes out of nowhere and when I’m not actively thinking of the language, I may have forgotten I was planning it in the first place.

What is the design process like for purely conceptual languages like Unnecessary? With that language, there’s no working compiler at all… is it freeing to work in a space where the mechanics of the language are not the focus?

Unnecessary is the only purely conceptual language I’ve done. It was a quick one to do; I simply got the idea and shaped it all together as I wrote the specs. I guess such a language might be freeing to do every now and then but I haven’t really focused on such languages and Unnecessary was my first language, too, so I did not feel any particular freedom from conventions as I had no previous experience in esolang design.

You mentioned your favorite program type is the quine. Was creating a language where all programs are quines part of the initial idea for Unnecessary?

Partly. The main idea was that the language could not have programs, other than the kind that don’t exist. (Can it have those then if they don’t exist?) Then I noticed that every valid program (whatever that is) is a/the null-quine but that was more of a by-product of the main idea. Fitting nonetheless!

Clue is fascinating in how it exposes its execution. Was it inspired by Conway’s Game of Life or other cellular automata? Where did the title Come from?

Technically speaking Clue has no I/O but it’s useful (obviously!) to see what’s going on, and that’s why the interpreter prints out the current program/memory on every cycle. Making this distinction is a bit useless since I’ve never ran a Clue program without viewing the “output” but here it is… And the language was certainly designed with the visual aspects on mind. While I might have been inspired by one-dimensional cellular automata and I had been well exposed to Bitwise Cyclic Tag and a cyclic tag system by making interpreters for them in various esolanguages, I’ve never consciously taken from other things.

The idea that started Clue was that I thought that what if I made a simple two-instruction system where the data string is both the program and the memory. I wanted every string of 0s and 1s to be a valid program. I tried different instructions but the ones the language ended up using I found the best.

No idea where the title came from. Mostly a fitting name just appears. I also keep a list of “reserved words” that are waiting for the right languages to be made and attached to them!

How much of a surprise was the look of the Clue images? They remind me of ripple marks in rock.

It was a huge surprise. I had the feeling I was looking at something natural or organic. The surface of a rock or a seashell. The shape of the programs also made me think of the growth that happens in nature, like the growing of trees; uneven and alternating. Who knows if it exhibits something mechanism that’s found in nature…

How did you learn compiler design? What tools do you use to create languages?

I’ve actually never made a compiler, unless the word can be used for interpreters also. The answer is, nonetheless, the same: on my own.

The languages I’ve done haven’t been overtly complex to implement, luckily, and I’ve always been able to imagine the processes the interpreter has to do. And now when I think about it, I’ve also designed esolangs that require more complex interpreters as my interpreter programming skills have bettered. Although their betterment is due my programming in esolangs, paradoxically…

Most of the design happens in the mind but I tend to use a notepad program to write down the best ideas and run simple executions of designs under work, testing the languages’ powers that way. That’s about it; writing the programs, specifications, and interpreters for a language all happen in the same notepad program.

Any esolangs by other designers you like to program in (apart from brainfuck of course)?

I have a few favourites; Thue and Underload are big. Then there are many others in which I may program one or two programs and never return to them even if I like the languages. (There’s simply no time for everything.)

Any tips for people starting out in language design?

Quality over quantity, always. Think hard, don’t start publishing the language before you have thought out all of its features. Don’t have too many features. No more brainfuck variants, there are more than enough! Write a few programs in your language, too, to showcase it and to really see how it works. I guess that’s the best advice I can give. :)

VerboseFuck

VerboseFuck

It’s common for new esolangers to start off making a language whose commands map directly to brainfuck; what we call a brainfuck equivalent. It’s an easy way to get started in esolanging, as brainfuck interpreters can just be modified to take the new symbols. This is sometimes criticized as undermining what’s actually interesting in esolangs, since ordinarily we look at the logic and behavior that arise from a set of rules as the aesthetic of the language; if we think of the language as a rule set, they basically have the same rules. In ais523’s interview, he discouraged esolangers from churning out another “brainfuck-variant-of-the-week”). This is simlar to complaints from the beginnings of .NET, when Visual Basic.NET was accused of being C# in drag, C# for people who like typing more than they need to. Amazingly, VB.NET is currently the 10th most popular programming language in the world (perhaps used by people transitioning from the old Visual Basic? I have no idea).

But, back on topic; let’s not be too hasty in dismissing brainfuck equivalents. Brainfuck is the most well-known of esolangs, and can serve as a blank slate. Some languages take the familiar brainfuck logic and refocus attention on the symbols themselves; VerboseFuck is one of these.

Part of what makes brainfuck so recognizable is its unusual vocabulary, using all punctuation marks. This creates a sense of mystery around how commands function. VerboseFuck clearly spells out each of these commands, but does this in a way that reduces none of the complexity of using the language. By spelling out each command, VerboseFuck also rids brainfuck of its conciseness, making wordy programs. 

In brainfuck, we use < to move the pointer one memory space to the left. In VerboseFuck, we replace it with:

math.equation(pointer = pointer - void(1));

Likewise, moving a pointer to the right right ( > ) is:

math.equation(pointer = pointer + void(1));

First, math.equation() is ridiculous, it creates the impression that it does nothing but cause its argument (in this case “pointer = pointer - void(1)”) to be executed (the equivalent of “let” in some prehistoric languages, as in “let pointer = pointer + void(1)”). But it sounds totally valid, something that could exist, even if it has no reason to. It’s remiscent of a story told by a young child; syntactically correct, but including every detail and logical step, no matter how redundant.

But the reality is that this “command” does even less than it appears. Actually, math.equation does absolutely nothing on its own, it’s not a command or an expression. It just happens to be some of the characters required to write the command of “math.equation(pointer = pointer - void(1));”

We can see this in the way that the following line would not work:

math.equation(pointer = pointer + void(2));

The number 1 cannot be replaced with 2 because neither 1 nor 2 have any meaning in VerboseFuck. If you want to move the pointer two places to the left, this is the only way. Write the command twice:

math.equation(pointer = pointer - void(1));

math.equation(pointer = pointer - void(1));

This is VerboseFuck’s equivalent of brainfuck’s “[” (which starts a loop) in its full glory:

conditional(block.if, boolean.inequality(deref(pointer), byte(0))) { program.flow.labeledjump(defines.label.last()); };

undefine(defines.label, defines.label.last());

Again, we have VerboseFuck’s logorrhea, every step spelled out: we’re making a conditional around a boolean referenced by the pointer one to the left of the command etc etc. Although it looks complicated, most programmers can look at this and figure out what it’s probably doing, if not why someone would write it in such redundant detail.

But VerboseFuck is not only verbose in each individual command (remember, those two lines above are always written exactly the same way and mean exactly the same thing), it maintains the verbosity of brainfuck, in that it requires a great many commands to do anything. The full Hello, World program for VerboseFuck (which can be read here) is 213 lines (something many languages can do in one). 

Even though each command implies a great many alternatives we can’t really use (like the example of passing 2 instead of 1), this language does not restrict us from doing these things, it just forces us to take a verbose path to get to the same result. We know this because it’s a full brainfuck equivalent, meaning that, like brainfuck, it’s Turing Complete — it can be used to write any general purpose program. We could write a game (maybe Hunt The Wumpus), or if we wanted to devote years to it, a perfectly useless yet fully functional web server. 

Interview with ais523

This is an interview I did (holy shit) over three years ago with esolanger ais523…

Interview with ais523 (Feb 28, 2011)

In my second in a series of interviews with esolang developers, I speak with ais523. He provides an insider’s view of the esolang community, as an administrator of esolangs.org, and explores what makes esolangs interesting and challenging vs thematic and gimmicky. ais523 has created languages such as Underload and BackFlip and currently maintains C-INTERCAL, an implementation of the language that started it all.

Do you remember how you first found out about esolangs?

It was via 99-bottles-of-beer.net, which a friend of mine linked me to, knowing I was interested in programming. It’s a sort-of precursor to Rosetta Code, just featuring one program rather than many; and among the many “real languages” it has, there are also many esolangs. The site inspired me to find out more, so I looked up a few esolangs, and found first the entries on Wikipedia (specifically INTERCAL), and then to Esolang.

What drew you to create your own languages?

I’m not too sure, actually, although I think I was an esoprogrammer (that is, writing programs in esolangs and implementing existing esolangs) before I designed languages myself. To answer a related but slightly different question, which might go some way towards answering that one: the whole notion of concepts of programming interests me; some of my own languages are attempts to explore that (particularly Underload). There are only a few paradigms generally used in real languages (imperative, functional, object-oriented, and a few which are rarely used); but are there any others? That’s the really interesting question that I think make come out of esolang research.

How did you first get involved with esolangs.org?

I discovered it pretty much as soon as I discovered esolangs, and read it for a while; it was natural that I would help to update it as it made discoveries. My first edit there is this one, helping to fill in the article about INTERCAL; I think I was already maintaining C-INTERCAL at that point (although I’m not too sure on the dates around that period, I released C-INTERCAL 0.25 less than a month later, and I doubt I got it ready in under a month). I became an admin there rather later, because I was checking it regularly and more admins were needed to help deal with the spam problem. Esolang still gets a surprising amount of spam considering how small it is relative to most other wikis, but it isn’t particularly onerous cleaning it up.

I’m interested in your comment about esolangs addressing alternate paradigms of programming. Could you speak a bit about the approach that Underload takes? What is its paradigm?

It’s based on manipulating code the same way it manipulates data; instead of having separate flow control instructions like most languages do, instead fragments of program are constructed at runtime on the stack and converted into code to run. The paradigm’s used by some non-esoteric languages like Joy, but is hardly mainstream; it’s sometimes called “concatenative,” but that’s a more general term than the usage in Joy and Underload (referring to a particular property of program notation). It turns out that this is enough for a programming language by itself, providing enough power to construct things like arithmetic; I always like it when things like numbers can be constructed in a language from scratch rather than having to be added to it separately.

Are there other languages in particular that you feel present a really new approach to or perspective on programming?

Not very many; partly because new paradigms are hard to create, and partly because the ones that haven’t been explored yet are mostly completely awful to use. Sometimes a new niche can be found within an existing paradigm; Unlambda famously demonstrated that lambda calculus doesn’t actually need the lambdas, and the combinator-based style it represents is useful in some other languages too (Unlambda fails for practical use itself mostly due to lacking syntactic sugar and being deliberately insane, but some of the ideas are commonly used in, say, Haskell, although it’s unlikely to have picked them up from there!).

Some very simple Turing-complete languages are also interesting in the approach they take; cyclic tag, for instance (e.g. as expressed by the esolang Bitwise Cyclic Tag) is a very neat back-to-basics approach. It’s useful not for its power (or rather lack of it; it’s difficult to write in and slow to do calculations), but in that it is comparatively easy to implement in languages that would seem to be hopeless for implementing anything else.

Having been involved with esolangs for a while, and especially as an admin on esolangs.org, what is the activity like for esolang developers? Have you seen waves of interest in esolangs (and what do they seem to be in response to mostly), or is it pretty steady?

There are two main things that drive trends. One is people discovering esolangs from outside the community, and sharing them somehow (most commonly, finding esolangs.org, generally from Wikipedia which encourages people to post there in order to avoid cluttering Wikipedia itself up with useless pages on languages which only one person uses). People tend to explore from there, and will often see other languages in a newcomer’s light, often sparking interesting discussion. The other thing that happens is that sufficiently many people will get interested in an esolang simultaneously that discussion takes off and dominates a channel for days, weeks, or months; this is responsible for many of the long-term waves, as far as I can tell. Often, this happens as a result of someone starting a project, or sometimes as a result of a new person joining as explained before. Just general activity occurring increases the esolang activity even for unrelated projects, because it has a side-effect of increasing the proportion of the time #esoteric is on topic.

There’s an example going on at the moment, in fact; a revival of interest in BF Joust happened due to Lymia (a relatively new esoteric programmer) joining #esoteric on Freenode in order to test out FukYorBrane programs, prompting me to finally get around to fixing my demonstration that FukYorBrane was utterly broken (possibly an incorrect one, as Lymia had found a loophole in the @ instruction I hadn’t…), reviving interest in competitive esoteric programming and eventually leading people to start competing the similar language BF Joust again. (It’s interesting to see the current leaderboard; some programs have been there over a year, others were added in the past week and seem to be doing fine.) That bump will likely be relatively small, and continue for just a few days before settling down again, but it’s already crowded out most of the offtopic discussion in #esoteric, leaving it mostly with BF Joust discussion, and people discussing their own esoprojects (at the moment, elliott with Shiro, a Funge-98 interpreter in Haskell, and me trying to improve my 1cnis interpreter). I think there’s something of a tendency to want to work on esolanging when everyone else is.

I was actually unaware of BF Joust. But looking at it now, it’s interesting how it is like brainfuck itself: a set of very simple rules that demand complex strategies. Do you see this type of clean minimalism as a design goal of your esolangs? Your languages often have very few commands (BackFlip, for example, with just two).

It’s not the only thing that inspires esolangs for me, but it’s common for me to make esolangs on that basis, and one of my favourite things to try to achieve. I suppose it’s more an issue of trying to find new ways to think about programming; and paring a language down to its minimums can help make it easier to think about, and to see how it differs from other conceptual models. (BackFlip itself was based on an idea on the now-defunct mailing list for adding procedures in a simple way to Befunge; it turns out that the procedure call mechanism itself was capable of lots of other interesting things too, like threading, and I decided to see just how far it could go.)

Minimizing languages only helps make them clearer up to a point, though. For instance, Unlambda has an i combinator that’s equivalent to ``skk, but the language is much mathematically neater with it included, and it feels like it should be part of the language. Something similar is true with many other esolangs; oerjan recently demonstrated that Underload is still Turing-complete without a, *, or !, which is an interesting result in its own right, but effectively a completely different language.

It also got me thinking about collaboration in esolangs, and this process of people building on others’ work to expand ideas in new directions. Esolangs are inherently collaborative (since to create one is to ask esoprogrammers to use it). Has this had a community-building effect (apart from the occasional waves of interest from others that you mentioned earlier)?

It helps to some extent, but I’m not sure if it’s as strong as an effect as I’d really like it to be. There are certainly interesting results that arise from people studying each other’s esolangs, but it tends to happen more in a vacuum, rather than with explicit communication involved; you normally get a language published online, then a few weeks or months later a result on the wiki, or an IRC comment, giving new information about the language, and often something that the original author hadn’t thought of. (For instance, this often happens with computational class proofs, especially as one of my hobbies is trying to gauge the computational class of new esolangs posted on the wiki. Normally it’s trivial, but sometimes it can be very interesting.) Another common situation is when people write interpreters for each other’s languages, but again there’s rarely collaboration between the author of the language and the people implementing it; in fact, you sometimes get the opposite, with the implementors trying to determine what the specification literally says, regardless of what the author actually meant! (This happens quite a lot with Funge-98, and has also happened somewhat with INTERCAL.)

It seems that brainfuck was an inspiration for many to first start exploring esolangs. Any opinion on what about brainfuck is responsible for this? Are there other languages that have also had a huge impact?

Brainfuck is interesting in that like Underload or Unlambda, it’s a distillation of a programming paradigm in a sense; but brainfuck is based on imperative programming, one of the most popular paradigms in “normal” computer use today. So not only is it low-level, but it’s low-level in a way that’s similar to what programmers are used to already, thus making it a rather accessible esolang. (Just compare the length of a typical brainfuck interpreter in C, to the length of a typical Unlambda interpreter in C, for an example of what I mean.) Likewise, it benefits from being reasonably close to machine code. It’s also the best kind of tarpit, having just a few instructions which are relatively simple rather than contrived to bring the instruction count down, or bloated to the extent of a practical programming language. This both makes it interesting to people not used to esolangs, and easy to memorise the “rules” (if not trivial to write), thus making for an interesting puzzle. So it combines three real strengths in an esoteric language in terms of accessibility to non-esotericers: interesting computational behaviour (close to minimal imperative programming), a useful tarpit-like nature, and ease of implementation (leading to the spam of uninteresting “brainfuck derivative” languages that people tend to make as their first esolangs).

We were having a discussion about the most impactful esoteric languages on #esoteric recently, in fact. elliott’s list was (I’ve alphabetised it because I can’t remember the order) Befunge, brainfuck, INTERCAL, Underload, Unlambda, and I think I mostly agree with that list. I’ve discussed the tarpits there (brainfuck, Underload, Unlambda) already, and they’re impactful for similar reasons (Underload and Unlambda maybe less so due to using paradigms that will be unfamiliar to many programmers, and being generally harder to implement).

Befunge is interesting in that it’s easily the most practical of esoteric languages; Funge-98 in particular is strikingly short on features designed to make programming difficult (IMO a good thing, but rare in esolangs), and has a lot of library support (almost unheard of in esolangs). However, its appeal probably comes more from the fact that the programming model is intuitively a very nice and interesting one; stack-based reverse-Polish is a relatively simple and understandable model also used by some non-esolangs like FORTH, and you can create loops in the program by drawing literal loops in the code, flowchart-style, which is quite nicely aesthetic. INTERCAL is mentioned mostly for its existing place in programming culture, predating most other esolangs by decades; I don’t think it’s inspired many people to become esoprogrammers (few people willingly read or write INTERCAL programs, although I admit I’m one of them), but on the other hand many programmers are aware of it and its general insanity, and get most of the jokes in the original manual.

I should also mention LOLcode, which has become pretty relevant as an esolang in the non-esolang community recently, much to the annoyance of most actual esolangers. It doesn’t have much intrinsic interest for most of the reasons people are interested in esolangs, being mostly a simple imperative language derivative with the keywords swapped out, just like there are a whole range of brainfuck derivatives too. However, it appeals for things like its visual appearance and general attitude, which although are IMO the least important aspect of an esolang, are one of the most immediately noticeable. (Having an amusing name helps too; I genuinely think that this helped out brainfuck, even if the swearword that makes up the name is unfortunate for various reasons.)

In addition to the joke languages (like LOLCode), it seems like puzzle languages also get a good amount of attention, which makes sense since enthusiasm for puzzle-solving is pretty common to programmers. But one thing joke languages and puzzle languages have in common is that they’re both fast to “get”: even if the puzzle takes a while to solve, it doesn’t really introduce a way of thinking that can’t be easily mapped to an existing one (a different paradigm, as you put it). Would you say you’re interested most in languages that are slow to experience (the way Underload is — I’m still trying to figure it out)? Is part of the value of these languages the way that they force us to reconsider existing paradigms even if the alternatives they offer aren’t necessarily practical?

Yep, to me languages are a lot more valuable if they require thought, rather than being just another synonym for simple imperative structures that programmers know so well already. Languages can be an interesting diversion if they just provide a weird set of primitives that can be mapped onto more “standard” ways of doing things with some thought; but it’s much more interesting if the point of view of the language is one that you can think in independently. I find this happens mostly to me with Underload and to some extent INTERCAL (which I think would be a really interesting language from a computational point of view if it added some more typical arithmetic and a goto statement, although that would obviously defeat the original point of the language); other people have reported it happening with brainfuck, which is a great language in a huge many ways. And yes, I don’t care too much about something like practicality, generally speaking, as it tends to get in the way of many of the things that make esolangs interesting; and it’s something that can often be “retrofitted” to a language afterwards, after the ideas are worked out.

Wiki Cyclic Tag reminds me of other types of translations from one system into another, in the way it repurposes MediaWiki software in a surprising way. In that way it resembles Piet (translating images into code) or even the P=NP problem translated into Minesweeper. Any thoughts on esolangs as interplay between systems? Is WikiCyclicTag about MediaWiki, or was that just the initial inspiration?

I suppose it’s just trying to make a point. Proving things that weren’t designed as programming languages to nonetheless be useful for programming was something I tried to do before I even discovered esolangs, and one of the best such demonstrations is to actually design a programming language around it. (Wiki Cyclic Tag is definitely “about” MediaWiki in that the syntax is deliberately aimed at getting MediaWiki to be able to parse it.) I don’t think most esolangs have this sort of system-dependency, with some of the most interesting ones living “in the abstract” (I tend to feel that syntax is mostly irrelevant except to give a way to feed a language to an interpreter), but it’s often interesting to see the occasional one that is. (On another note, cyclic tag seems to be by far the easiest computational model to implement in things that are naturally bad at computation; Minsky machines work well too, but only in systems that naturally have unbounded arithmetic.)

Do you have a programming background? Do you work as a programmer?

I was actually mostly a mathematician while at school (I was a reserve on the UK olympic maths team), and my degree was in electronic engineering. I’ve been interested in programming all that time, though; I think part of the reason I did electronic engineering rather than computer science was that the latter is much cheaper to study in your own time without university equipment to back you up. Nowadays, I have two jobs; teaching programming (mostly Java, which IMO is an awful first language to start learning programming with, but is what I’ve been told to teach, and picking up new languages is pretty easy for an experienced programmer…), and doing research for a computer science department.

(It’s esolang-related itself in a way; I’m studying the automatic generation of hardware from software, in a way combining my interests, and electronics can easily be considered an esolang in its own right.)

Has anyone figured out your Burn language? I love the challenge of reverse-engineering a language.

No, although I don’t think many people have tried. (Esolangs can be notoriously difficult to reverse-engineer from nothing but source code; I imagine it would be near-impossible for most of my languages except for maybe Forte, where the apparent obviousness of what’s going on is part of the joke.) I probably could figure it out with a few hours or maybe days of staring at it (having the advantage of having written the language in the first place, and perhaps remembering more details), but I haven’t really used what free time I have for that, with other esolanging projects having higher priority. (Perhaps it’s for the best that it’s left as a puzzle for others.)

Any advice for esolang developers first starting out?

Making new languages is fun, but it can help to implement existing languages and write programs in them in order to get practice and start thinking like an esoprogrammer (and I find that writing esoprograms is often more rewarding than creating languages, in fact). Don’t get hung up on syntax; what a language looks like is trivial to change simply with a find-and-replace, and it’s more important to have an interesting computational model. (If you do use an unusual syntax or appearance as your “gimmick”, a so-called “thematic” language, try tying it into the semantics of the language somehow; languages like Taxi and Haifu are good examples of this, and are much more interesting than thematic languages like LOLCode or the brainfuck-variant-of-the-week.) When implementing languages, don’t worry about implementing a language efficiently until after you’ve got an implementation working at all; and bear in mind that esolangs are typically easier to parse than ordinary languages, and so parsing libraries often aren’t really necessary (and the esolangs that this advice doesn’t apply to are generally so hard to parse that libraries can’t deal with them, I’m looking at you INTERCAL).

Interpreters are typically easier to write than compilers; for languages which are inherently easier to compile than interpret, target C or maybe a high-level language with the right sort of paradigm (such as Scheme for functional esolangs) rather than machine code and you’ll save yourself a lot of work.

Brainfuck Programming: How to write the number 36 (Part 1)

In some languages, if you want to assign the number 10 to the variable x, you might write something like:

x = 10

This doesn’t work in brainfuck, as “x”, “10”, “=”, and the spaces between them are all ignored, they’re not part of brainfuck’s vocabulary. And there’s no special punctuation mark that stands for ten. What was once a given, a constant, now requires a programmatic strategy, and one with stylistic concerns. I can make an easy 36 or a clever 36 or a truly brainfucky 36 that’s short, elegant, and a challenge for anyone else to understand.

Let’s look at examples to make this more clear:

The easy way:

++++++++++++++++++++++++++++++++++++

When you start a brainfuck program, the memory space is all full of zeroes. Instead of x, there’s a byte you can think of as x and which you can get to by moving back and forth (you do that with > and < ). Once we’re at a place in memory we like, we can simply write out 36 plus signs, and there we have it.

Version 2:

++++++[>++++++<-]>

This is multiplying six by six. Here’s how it works:

image

A loop begins with [ and ends with ] and when the byte referred to just before the loop becomes zero, it ends. So we add six, jump to the right, add six, jump to the left, subtract one, then do this again and again until the left number counts down to zero, leaving us with six plus-signs executed six times (6 x 6) in the right number. 

However, there are other, more clever ways to get to 36. 

A byte can only hold a number from zero to 255. So another way of writing 36 is with 256 + 36 plus signs: 

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

This is called wrapping. You could keep going and add any multiple of 256 to this and get to the same place.

But this is just spinning the odometer. Things get more interesting when we use this technique in a loop:

image

Here, we add 2, move to the right and make that 2 as well. Then we move back to the left and add 7, and back to the right to add 2. We do this until the left number is evenly divisible by 256, which happens when we hit 1024. 7 * 146 + 2 = 1024. This means we’ve gone round the loop 146 times. 146 * 2 is 292. 292 - 256 = 36. So we’ve passed zero only once in the right variable, leaving us with the remainder of 36. 

In Part 2, we’ll look at nested loops. In the mean time, there’s a fucking huge list of brainfuck constants.