If you make a language and are lucky, someone else will write code for it. If you are very lucky, someone else will find uses for it you never intended, or that even challenge the premise of the language.

This is not the same as using the language in an unexpected way. Urban Müller could not have foreseen brainfuck as the bedrock for a Rust-like language or a CPU. But do these projects truly counter brainfuck's premise? I would argue not. Brainfuck appears chaotic but part of its appeal has always been in conquering that chaos, in building efficient algorithms using the language despite the challenge. These projects counter the chaos of brainfuck, but that really is the appeal of brainfuck in the first place, they are simply taking it much further than could have been anticipated. If Müller had wanted brainfuck to be impossible to master, he would have designed the language much differently.

Sometimes, however, a language inspires work that falls very far from the intent of its original designer. Most esolangs, like mainstream programming languages, are open systems and don't dictate how programmers use them. C# offers many features to make structured code easy. But I can also write C# that looks like 80s BASIC wrapped in some standard C# boilerplate:

using System;

class Program
{
     static void Main() 
     {
          _01:  int b = 0;
          _05:  string t = "";
          _10:  for(b = 99; b > 0; b--){
          _20:  goto _100;
          _30:  t = t + " OF BEER ON THE WALL";
          _40:  Console.Write(t + ", " + t);
          _50:  Console.Write("\nTAKE ON DOWN AND PASS IT AROUND, ");
          _60:  if(b - 1 <= 0) { Console.Write("NO MORE BOTTLES OF BEER ON THE WALL"); } goto _80;
          _70:  goto _200;
          _75:  Console.Write(" OF BEER ON THE WALL");
          _80:  Console.WriteLine();
          _85:  goto _230;
          _90:  Console.Write("GO TO THE STORE AND BUY SOME MORE, 99 BOTTLES OF BEER ON THE WALL");
          _95:  return;
          _100: t = b.ToString() + " BOTTLE"; if (b > 1) { t = t + "S"; }
          _110: goto _30;
          _200: Console.Write((b - 1).ToString() + " BOTTLE");
          _210: if (b - 1 > 1) { Console.Write("S"); }
          _220: goto _75;
          _230: ;}
     } 
}

 

C# can discourage this—Visual Studio tried to reformat this several times, and it was full of red squiggles—but a determined-enough programmer can always reject the values of that language.

Esolangs tend to flaunt their central idea in a more direct way than mainstream, general-purpose languages; they're usually created by a single author and sometimes even include a philosophical statement. This does not mean that people will use the language the way the author intended, which is lucky as much of the joy of creating a language is having others discover new uses for it. This is, in part, why esolangs are so exciting as computational art: unlike interactive pieces that have a prescribed form of interaction, there is no way for the creator of an esolang to control what happens to it once it's out in the world.

 

I'm going to use a language of my own as an example. FatFinger, a dialect of JavaScript created in 2017, explicitly counters the compulsiveness of code. I conceived of it as a sequel to Entropy, a language where data decays, limiting the programmer's control. Where programming is often an exercise in perfecting a piece of code, FatFinger encourages sloppiness by allowing typos and misspellings to function. It compares each unknown string against a list of keywords and names in scope to find the closest-named (in Damerau–Levenshtein distance, or "edit distance" between two strings), in an attempt to guess at what the programmer intended.

This is all reinforced by the documentation. To activate FatFinger, you have to create a script tag with the word JavaScript misspelled, which further drives the point home. My biggest concern in creating the language is that people might misuse it to spell-check their JS (the very opposite of what I intended!), so I explicitly banned this use in the license agreement.

Here is the sample 99 Bottles program:

<script type="text/javascript" src="fatfinger.js"></script> 
<script type="text/javoscript"> 
// any misspelling of javascript works in the type attribute above 
     vart x = "herrrllo werld" 
     dokkkkumint.rit3(xx) 
</script>

What I had not counted on was an alternate approach to the language, where instead of sloppily-typed JavaScript, we get deliberate word replacement in the service of code poetry. I shared the language in last year's Critical Code Studies Working Group (a fantastic biennial event). There, Jeremy Douglass responded with experiments of his own:

Playing around with the web demo, there seems to be a reasonable distance threshold on the number of add-delete-change-swaps (~4). Proximity can be used to playful effect with word choice rather than typos -- for example, in this simple implementation of the Fizz Buzz game / FizzBuzz program:

var why;
var does;
var say;

for (who = 1; what < 101; when += 1) {
     said = '';
     doesnt = !(who % 3);
     if ( does ) {
          says += 'Fizz';
     }
     done = !(whom % 5);
     if ( does ) {
          says += 'Buzz';
     }
}

Douglass uses "what" and "when" in the place of "why". As he explains: "The results are less like error correction and more like an exploration at the intersection of natural language programming and obfuscated code". From this, he builds what he calls "In Other Words (Fat Dactyls)". Dactyl refers both to a finger and to a group of ten gods—five female, five male—who discovered language and music in Greek mythology.

Fat Dactyls is both a mini-poem and a guide to alternate words that, in most cases, can be swapped for DOM objects (and methods) used in JS:

alert

  • angry, answer, art, basket, camera, cart, danger, debt, earth, east, electric, expert, heart, heat, here, left, meat, paper, quality, regret, short, sleep, sort, start, sweet, test, there, violent

confirm

  • comfort, country, bottle, canvas, committee, common, complete, complex, conscious, control, cotton, little, measure, muscle, poison, possible, responsible, tongue

document

  • adjustment, argument, development, different, government, instrument

history

  • discovery, harmony, industry, library, military, picture, scissors, sister

location

  • addition, attention, attraction, behavior, comparison, competition, condition, connection, decision, digestion, direction, discussion, education, expansion, fiction, invention, motion, observation, operation, position, question, reaction, relation, suggestion

name

  • angle, awake, base, brake, cake, care, damage, dark, day, edge, example, face, flame, hammer, hate, have, knife, late, make, male, mark, mass, may, nail, nerve, news, note, number, page, paste, rail, range, rate, ray, safe, same, shade, shake, shame, snake, some, space, spade, table, take, taste, time, trade, walk, wall

navigator

  • daughter

prompt

  • attempt, group, produce, profit, property, protest, pump, thought

screen

  • between, degree, garden, green, science, screw, secret, street, sudden, summer

At this point, Douglass ends with:

At this point it is tempting to write a group of simple FatFinger.JS programs in this constrained vocabulary, and I still may. However to me this is already a piece of writing (upon which other writing could be built), and it already suggests insights and at least one conclusion. "In Other Words" is a discovered vocabulary which is poetic in itself.... a secret thesaurus waiting to be discovered.

The rest of the thread can be read here.