#esoteric programming

already starting off strong, but it gets worse

Wow! Sounds easy and intuitive to use! What’s the “crazy operation” you ask? We’ll get to that later. For now let’s see what a program in this language looks like :)

Thanks! I hate it!

it’s so difficult to work with that the first program was written by another brute force search program

mmmmm delicious base-3 arithmetic, what could go wrong? (For reference, that means this program forgoes the usual “0/1″ values of binary code in favor of a much more fun “0/1/2″ set of values)

ah.

Here’s how the language actually figures out what to do. It’s got 8 “simple” commands that can be executed easily by *checks notes* running the code itself through the modulo operation and taking the result.

As a bonus, on top of all that every single character in your code will now alter what every single other character does. So I hope you’re alright with cracking a cipher every time you add a new letter to your program!

oh god oh fuck.

behold, Malbolge’s primary arithmetic operation and what you’ll be using for most of your math while programming with it :)

This looks specifically designed to be the least logical math operation you could make, and knowing what the rest of Malbolge is I’d wager that’s precisely what happened. I never want to ever use this and it’s my favorite thing I’ve ever seen.

https://en.wikipedia.org/wiki/Malbolge

Finite State Automata defining spell syntax.

The spells use only three different characters to be written, "╭" (which can represent "0"), "ʌ" (which can represent "1") and a validation symbol "ᴎ" that can represent ";". When writing spells, spaces, indentation and parenthesis can be added to make them more readable. Those do not modify the spell meaning as only the three characters precedently mentionned matter.

A fourth glyph "╰" can be placed to signify the begining of a spell too, so indentations are more logical, but this character do not add meaning to the spell either.

This automaton is nearly deterministic, with the exception of the validating "root" state, that can only go back on itself to exit the current loop (an ongoing while, the spell itself or a function definition for exemple). The spell also cannot validate before exiting every ongoing loop, and can only validate once every loop are exited. Otherwise, the rest of the states and their transitions are entirely deterministic.

A more detailed version of the FSA :

I've been playing around with implementing esoteric programming languages as Minecraft data packs

for a bit I've had the idea of implementing BackFlip, a 2d language which is vaguely similar to the Langton's Ant cellular automaton and based on arrows and mirrors, the two of which conveniently resemble magenta and pink glazed terracotta

in figuring out how best to do output (I used tellraw with the "interpret" option for an NBT list, though I've since discovered this doesn't necessarily work for broader character sets than BackFlip's), I discovered that the new 1.19.4 "string" option for the /data command allows taking substrings; this (and the /data command in general) gave me the idea of implementing a more complex text-based language, which could be written in a book and quill

as a very basic proof-of-concept of text processing, I made an interpreter for the joke language Deadfish (which just has commands for incrementing, decrementing, squaring, and outputting a counter)

I was able to do it with a single function file, which made it convenient to add to the esolangs wiki page for Deadfish

finally, as a more complete example, I made an interpreter for the popular esolang brainfuck, with the program and input being read from books

unfortunately I used the same output method that I did for BackFlip, which it turns out doesn't work with the double-quote character, so I may have to make a fix sometime here..... (EDIT: it's now fixed -- somehow I had missed the very convenient option of selecting every item of the NBT list and setting the separator to empty string)

in any case though the data packs I've made so far can be found on GitHub

While I was back in highschool (iirc?) I made a thing which I titled “drocta ~ATH”, which is a programming language with the design goals of:

1: being actually possible to implement, (and therefore, for example, not having things be tied to the lifespans of external things)

2: being Turing complete, and accept user input and produce output for the user to read, such that in principle one could write useful programs in it (though it is not meant to be practical to do so).

3: matching how ~ATH is depicted in the comic, as closely as I can, with as little as possible that I don’t have some justification for based on what is shown in the comic (plus the navigation page for the comic, which depicts a “SPLIT” command). For example, I avoid assuming that the language has any built-in concept of numbers, because the comic doesn’t depict any, and I don’t need to assume it does, provided I make some reasonable assumptions about what BIFURCATE (and SPLIT) do, and also assume that the BIFURCATE command can also be done in reverse.

However, I try to always make a distinction between “drocta ~ATH”, which is a real thing I made, and “~ATH”, which is a fictional programming language in which it is possible to write programs that e.g. wait until the author’s death and the run some code, or implement some sort of curse that involves the circumstantial simultaneous death of two universes.

In addition, please be aware that the code quality of my interpreter for drocta ~ATH, is very bad! It does not use a proper parser or the like, and, iirc (it has probably been around a decade since I made any serious edits to the code, so I might recall wrong), it uses the actual line numbers of the file for the control flow? (Also, iirc, the code was written for python 2.7 rather than for python 3.) At some point I started a rewrite of the interpreter (keeping the language the same, except possibly fixing bugs), but did not get very far.

If, impossibly, I got some extra time I wouldn’t otherwise have that somehow could only be used for the task of working on drocta ~ATH related stuff, I would be happy to complete that rewrite, and do it properly, but as time has gone on, it seems less likely that I will complete the rewrite.

I am pleased that all these years later, I still get the occasional message asking about drocta ~ATH, and remain happy to answer any questions about it! I enjoy that people still think the idea is interesting.

(If someone wanted to work with me to do the rewrite, that might provide me the provided motivation to do the rewrite, maybe? No promises though. I somewhat doubt that anyone would be interested in doing such a collaboration though.)

Regarding the text based SBURB game, I assume I was talking about “The Overseer Project”. It was very cool.

hey, did you know that the compression format DEFLATE can be used to simulate a cellular automaton, or do multiplication, or, theoretically, anything else you want?

a couple years ago, I had an idea for an esolang: a PNG-style image format that would "happen" to involve enough self-reference to be turing-complete. eventually, struggling to come up with a reason for the program to be split between pixel data and compression, I simplified my goal to just a turing-complete compression format, modeled after DEFLATE, the compression used in PNG (as well as in other common formats)

in thinking about this, though, it occurred to me to wonder: what could be done with DEFLATE itself? the main obvious limitation would be that an individual DEFLATE stream gets decoded in one pass, element-by-element, and then is done; it always halts, and there's limited potential for self-reference

so, in order to make computation more viable, I decided to consider an iterative process of decompression, where one DEFLATE stream is decompressed to produce another, which is decompressed again, etc; this process requires some extra behavior outside the compression format itself, but it's a minimal amount (just a basic loop)

in order for this to work, I needed a DEFLATE stream that would endlessly decompress to DEFLATE streams, so my first step was to create a DEFLATE quine -- a stream that specifically decompresses to itself. (the way I accomplished this was more complicated than necessary -- involving carefully-selected code definitions to create specific bit patterns in an otherwise-empty compressed block -- but it worked)

once I had a quine, I just needed to attach some data to it that was allowed to change. to do this, I created Kwert, a language that compiles to DEFLATE and corresponds closely to how the format works -- it has a self-modifying program consisting of "commands" that can copy sequences of previous commands (corresponding to compressed DEFLATE blocks, which work in part by copying previously-output sections of data), and then skip evaluation of some number of following commands (corresponding to uncompressed DEFLATE blocks, which output some amount of following data as-is)

I was able to create a couple interesting things with Kwert (such as a fibonacci program of sorts), but for a while I struggled to come up with a way to do anything more complex; I had a sense that it might be possible to implement a tag system of some kind -- a computational model that can simulate a turing machine using a queue of symbols, something that's well-suited for a language like Kwert that involves start-to-end modification of the program -- but I couldn't think of a way to use commands as data without them being evaluated and producing an unwanted effect

then, a couple weeks ago, I followed up on an idea I had written down previously: that commands could potentially be transferred as data without side-effects by having it so when they're being used as data, they're positioned such that all they do is copy a no-op command

using this strategy, I was able to design a system in which sections of a Kwert program simulate a string of symbols, which change over time based on preceding symbols. I created a new language, Kmid, based on this concept

Kmid, although more like a cellular automaton than a conventional programming language, is definitely easier to do things with than Kwert, and I was finally able to implement Bitwise Cyclic Tag (a simplified but equally powerful version of tag systems) and confirm that it does successfully compile to DEFLATE, which means, to the best of my knowledge, that iterated inflation is indeed turing-complete!

New profile page, upcoming posts and some random esoteric stuff

My original page, adamlwalker.com, now points to its own one page about.me style page. It’s a beta but I am pretty happy with the new design. Please feel free to critique it.

Coming up on MetalPolyglot:

– The un/official terms for Ruby operator names – (directed at my co-worker) Yes, I prefer to call {} crab claws and a #{} is a octocrab!

– Pmetal – First glance at my Heavy Metal themed esoteric…

So recently I started kind of working on this again for a bit. I have fixed some bugs with the parser that I haven't pushed yet. I am also writing an improved interpreter that will use the parser instead of the hacky thing that just goes through strings.

However, for the time being, even after I release this version, I would recommend maybe using the older version for a while if anyone is using it, because this version is probably even more buggy.

However, you know how a few posts ago (but more than a year ago (wow) ) I posted that post where I said that I didn't think bifurcate can be used to split values into more than 2 values?

Well I still kind of think that, but on the map page for homestuck on act 6, it says split Act_6[Act_1,Act_2,Act_3,<etc>];

So this is something I intend to implement, and something I am implementing.

And like I said before I would like it to be done with repeated bifurcation, as a sort of syntactic sugar.

And I am thinking I want it to be like

[a,b,c] means the same thing as [a,[b,c]]

so split Z[A,B,C];

would be the same as

BIFURCATE Z[A,BCTEMP]; BIFURCATE BCTEMP[B,C];

and that split [A,B,C]Z;

would be the same as

BIFURCATE [B,C]BCTEMP; BIFURCATE [A,BCTEMP]Z;

But the way the splits would be done could also be backwards

so [a,b,c] could be the same as [[a,b],c]

I'm pretty sure I prefer the first way, but the second way is actually easier to implement.

or at least cleaner looking to implement.

Why doesn't my code look clean ever?

Anyway, my reason for this post is this:

I made a parser for ~ATH in addition to the interpreter. I might make the interpreter use the parser at some point in the future, or I might not. If I made the interpreter use the parser, the code for the interpreter would probably be a little cleaner, and possibly a little faster.

The parser is available from my github.

To use it, call tokenize on the text, and then read_all_from on the result of tokenize.

The output will be a list of lists

https://github.com/drocta/TILDE-ATH-Parser