#esolang

[mantacid]

Just came up with a programming language lol.

It’s object oriented (I think. I’ve never done this before), and supports a lot of features that lisp has, including

I call it RunOn, because

The Syntax kinda looks like actual sentences, and

because the period character terminates the whole program.

Now you have Syntax that kinda reads like a run-on sentence:

*define the class DOG as being an instance of a MAMMAL with an attribute called fur_type*

ASSUME (A DOG) IS (A MAMMAL WITH (A SLOT NAMED fur_type INITIALLY “brown”);

*create an instance of a DOG named Fido.*

ASSUME fido IS (A DOG);

*Fido has Spotted fur now.*

SET (THE VALUE OF (THE SLOT OF fido NAMED fur_type)) TO “spotted”;

*pretty-print the object tied to the name fido to STDOUT (me).*

DESCRIBE (THE DOG NAMED fido) TO me.

* ——> “fido is a ‘dog’ with ‘spotted’ fur_type.”*

Also, each keyword (purple, blue, and green) takes only one argument, but expects a certain number of other keywords whose definitions change based on the context of the operators before it as well as the values given to those keywords. I did this for a couple of reasons:

Because it does a good enough job at forcing an English-like syntax,

It allows for methods specializing on all kinds of aspects of the data to be implemented, but more importantly

Because if I didn’t give myself that kind of restriction, I would’ve ended up having reinvented lisp for the third fucking time.

I have no idea how to make this thing a reality, so if someone out there knows how to make esolangs and wants to give this a shot, hit me up and I’ll send the documentation I have so far.

[quanyails]

the fact that the only way to communicate between cars is with a sudden, loud HONK is horrible language design 😤😤

like you're telling me the expressions for "please excuse me" and "SCREW YOU DRIVER FOR CUTTING ME OFF" use the exact same phoneme structure

[lily-of-the-code]

What's your favorite esoteric programming language? I've never used one, but I've done rese on them and there are some funny ones. For example, there's one where code is written like Shakespeare.

[esoteric-codes]

I have yet to find a residency brave enough to let me perform this language, by continually rearranging all of their stuff

[ashlidev]

Silly little language I cooked up based on an old idea:

I love pattern matching,,

[aeolids-zenith]

esolangs in Minecraft

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

another esolang I've thought in the past about implementing in Minecraft is Piet, since it's pixel-based and that translates fairly well to Minecraft blocks; the main challenge is figuring out how to efficiently parse and represent the program, since NBT lists can't be indexed by variables and I might want to avoid creating an entity for every pixel? (though IDK maybe marker entities wouldn't be an issue for performance)

[cant-think-of-a-good-one]

WHAT IF I MAKE MY ESOLANG SHAPES INTO A BLENDER ADD ON

[nepcitami]

Introducing, gias agias

an esolang I just made because why not

[zwoelffarben]

Esoteric Programing language where the files are written 'like a normal' file, but the compiler reads columns of characters.

SSS tyy rss itt nee gmm .. HoE euX ltI l.T op; r =i "n Ht el ln l( oH e Wl ol ro l) d; " ;

[thatnoulguyorsomething]

Currently trying to write a bubblesort algorithm in Befunge, which is pretty much the level of weird that I should've expected to be doing on the weekend before crimsas

[crafto2007]

spent some time on the esolang wiki. fucking crying btw.

[piratesexmachine420]

Bad esolang idea -- brainfuck variant that encodes instructions as combinations of open- and close-parens so you can embed BF programs in your LISP programs

[autistic-sack-of-friends]

no way it's the reference

[aeolids-zenith]

computation in DEFLATE

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!

but DEFLATE's computational ability isn't entirely limited to that theoretical result; there are some at least somewhat interesting things that you can actually see it do (as opposed to everything being theoretically possible but not viable to execute in practice) -- you can see some programs I've written, such as the aforementioned multiplication and rule 110 cellular automaton, on github, some accompanied by instructions and/or links to the CyberChef tool to more conveniently run the DEFLATE versions

[cant-think-of-a-good-one]

Trick or treat :3

:3 lime slices

[nettakrim]

Cooking show concept:

its a well known fact that too many cooks spoil the broth, so we can make a 2x2 grid relating "quality of broth" with "presence of cook" and it would look something like this:

. | No Cook A | Cook A

No Cook B | Bad | Good

. Cook B | Good | Bad

with no cooks, the broth is never made, so its bad, with just cook A or just cook B we get a good broth, but with two cooks the broth is spoiled, everyone knows this

now anyone whose familiar with logic gates probably noticed that this is an XOR gate!..

which begs the question, how do we convert a good broth into the presence of a cook in a later XOR gate, since this would allow us to chain logic gates

the obvious solution: Gordon Ramsay.

Gordon Ramsay tastes the broth, and if the broth is good, the cook moves onto the next round, if the broth is spoiled, no cooks move on (ofc regardless of the lack of a good broth, no cooks move on when there *are* no cooks)

unfortunately, just XOR gates arent enough for turing completeness, which is of course the goal here, so what else can we construct?

well first of all, you can make a NOT gate by just having a cook in the XOR kitchen already, so now we just need to find either an AND, OR, NAND, or NOR and we can construct everything we need using De Morgan's laws

thankfully, this is already a solved problem, Regular Cooking Shows!

if no cooks enter the kitchen, noone leaves, if theres any amount of cooks, theres always exactly one winner! this is an OR gate! We can of course reuse Gordon Ramsay for this

(note that an "implicit OR" by just letting all cooks through would "overload" later XOR gates, spoiling the broths)

now the obvious issue with this is that the kitchens cannot reused, since cooks are left behind or exit permanently, but this is fine as long as logic is purely sequential

sequential logic *is* a lot easier to deal with though, and it actually helps solve another issue - the fact that a NOT gate cook could finish cooking their broth before another cook comes in to spoil it... the solution...... Gordon Ramsay!

we give him a list of kitchens to judge one by one, and thats the order the logic gates are evaluated in, since its sequential this naturally leads to the idea of defining our logic in the same order its evaluated in, something like:

0. OR -> 2

1. XOR -> 2

2. OR -> 3

3. NOT -> out

where NOT is built as an XOR kitchen with a cook already there

so following this notation here, we would build an OR and XOR kitchen connecting to a 2nd OR kitchen, then connect the exit of that kitchen to a NOT kitchen, then the exit of that is our output, then to run the cooking show we tell Gordon Ramsay to judge the OR kitchen, then the XOR kitchen, then the 2nd OR, then the NOT!

the eagle eyed reader, however, may have noticed that this is pretty impractical...- since we cant have one kitchen output to more than one other!.. this would mean we need to duplicate all our inputs and logic at every split, which would be a pain!!!

so we want something where when a cook completes one challenge, a separate cook is allowed into a later challenge...

luckily, the solution is another cooking competition! consider this:

the kitchen is split in two with a divider, with holes for passing of ingredients, each half of the kitchen has an incomplete set of ingredients, and in the other half there is a pre-existing cook

if no cook enters the empty half, the other cook wont be able to beat the challenge, so wont be allowed through when Gordon Ramsay judges them - if the cook does enter, then both cooks win, and their respective doors open

this challenge also doubles as an AND gate if you only let one of the cooks out and have both cooks as inputs instead of having one there already!

interestingly, both the AND and OR kitchens generalise nicely to more than 2 inputs, for OR you just add more contestants, for AND you add more dividing walls

XOR generalises as only true if theres exactly one cook, but there isnt really a set way XOR is supposed to generalise

this does help simplify our notation, as we dont need to confirm that there are only 2 inputs to each kitchen

so now with all of that established, i present a full adder:

0. A -> 3 (input)

1. B -> 4 (input)

2. C_in -> 5 (input)

3. SPLIT -> 6,10

4. SPLIT -> 6,10

5. SPLIT -> 8,9

6. XOR -> 7

7. SPLIT -> 8,9

8. XOR -> S (output)

9. AND -> 11

10. AND -> 11

11. OR -> C_out (output)

like earlier NOT is built as an XOR kitchen with a pre-existing cook, SPLIT is likewise an AND kitchen with a pre-existing cook for each additional output

this means we can count the total number of cooks we need, there arent actually any NOT kitchens, but we do have 4 SPLITs, with 2 outputs each, so thats 4 cooks, and then theres at most 3 additional cooks for each of our inputs, so let's say 7 contestants

we can also count the number of rounds (perhaps call them episodes) pretty easily, since its just the number of gates (there is no parralisation) in this case its 9

these two stats would be what you would want to optimise for

given how common SPLIT is, we could simplify our notation for humans at the cost of needing a compilation step by combining the splits into the outputs of gates, like this:

0. A -> 3,6 (input)

1. B -> 3,6 (input)

2. C -> 4,5 (input)

3. XOR -> 4,5

4. XOR -> S (output)

5. AND -> 7

6. AND -> 7

7. OR -> C (output)

but be aware that for this to be a valid cooking show you need to run it through some program first to uncompress the SPLITs

its also worth noting that an AND gate going into a SPLIT is often useless, unless you need to output to more kitchens than the AND gate has inputs, you can just use the inputs to the AND gate as your SPLIT outputs, this reduces how many cooks are needed, and could be included in the compilation (along with shortcuts for NAND, NOR ofc)

none of the cooks in the cooking show need to know the layout of the circuit for it to work, and neither does Gordon Ramsay

~The Producers~ just need to give him the list of what kitchens to judge in what order - the layout and challenge type of the kitchens and the doors control the flow!

so uuh... if you ever have a lot of kitchens and a lot of cooks and a Gordon Ramsay, now you know what to do?