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.