#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.

[stkptr]

Oh ho ho it's esolang wiki time. Time to prove the computational class of another weird programming language! I wonder which model I'll emulate this time... Maybe it will be a Turing machine! Or perhaps even something like lambda calculus. Surely I won't use counter machines again!

Nevermind it was counter machines again.

[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

[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

[nepcitami]

Introducing, gias agias

an esolang I just made because why not

[savagegardensprogramming]

CodeBlock Maps - Introduction

Take a look at Exhibit A – Its what I call a Code Block-Map. This is my crown jewel. A graphical code construct suitable for management level programming. Sub-Level 2 of SavageGardens.

Exhibit B is the sketch programming language. Its what the bright minds at MIT are working on. Its a toy. Its impractical for professional use. I am well aware as to why. I conceived something similar almost 30 years ago. I bet I wasn’t the only one.

Exhibit C is the book I was first taught programming. This book takes the flow chart approach. It does not want you take write a single line of code until you’ve drawn a full flowchart of your program. Its a painstaking approach because it takes a long time to draw a flowchart compared to the functionality you get from it. Very good for learning flow of logic but impractical for professional uses. This is the reason why the sketch programming language is what it is. It sits on the same situation. It takes too long to draw. It also takes too long to drag and drop. Mind you in the future we will have eye tracking and dragging & dropping will be done at a fraction of a second. Still, this kind of language will remain impractical.

I been sitting on this situation for literally decades. My break thru was to break out of the box. Stop using graphics to represent details. Graphical code constructs are not suitable for representing details. Lets look at sketch again Exhibit B. You see how they mapped a graphical representation to individual code constructs. One graphical representation for the if statement. Another one for a repeat loop. Another one for an individual function call such as play, stop, set volume, etc. Those are details.

Stepping out of the box for me was when I realized that graphical code constructs are good for representing big pictures. Managing the big pictures. Metaphorically speaking. Step away from the forest and look at the landscape. At a higher level you can move a whole mountain from the right to the left, Put the lake right next to it. Have the river move down from the lake and curb to the left. Put a small town situated at the curb of river. And finally mark an X on the mountain where Smaug the dragon hangs out. The point is managing the big picture items as opposed little details.

If mind-maps and flowcharts got together. CodeBlock Maps would be their child. CodeBlock maps is basically a map of blocks of code. What it maps out is flow of logic. Let rectangles represent a block of code. The code can be it as simple as adding two numbers together. Or as complex an AI algorithm with millions of lines of code. Then interlink these rectangles indicating flow of logic. That is it. LISP is just commas and parenthesis. CodeBlock maps is just rectangles and lines.

Exhibit D CodeBlock Maps are made up of individual CodeBlock Cells. A rectangle is referred to as a cell. Anyways here are the individual parts of a code block cell. Most of it is verbiage. I would say the only thing that translates into code is the fact that its a cell, the interlinks and the type descriptor.

Exhibit E. There are different verbiage requirements depending on the situation. Here I have enumerated them all. But at the core they are all the same fundamental construct. A rectangle interlinked with lines.

Exhibit F is syntax diagrams represented as a code block map. Good for representing recursive descent graphically. Note that CodeBlock Maps are about making code look pretty. It turns out that beauty has a practical use in code comprehension. I suspect women will enjoy programming in SavageGardens.

In SavageGardens I have designated code block maps as a sub-language for code management but mind you its quite capable on its own. It is touring complete. As simple and powerful as LISP. Its good for encapsulation. Good for divide-n-conquer. Good for abstraction. It fullfills the goals I have set out for SavageGardens. It exploits the brain functions of memory recall. It is 2 dimensional. It is graphical in nature. Good for code comprehension. Good for code navigation. Does not hinder code efficiency. Not so good for code articulation but three out of four is not bad. It does work well with other languages. Hence good for management.

[glowing-disciple]

This afternoon I was watching an old movie and abruptly remembered something I was thinking about doing for funzies - invent a new esolang.

Never actually did it, but it’s interesting to think about.

[juliganga]

is this close enough

Coding will never really take off until they make a programming language you can write while being a cat.

[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; " ;

[stkptr]

qoob

qoob (pronounced /kub/ like coob) is a qoobular language, there are 3 qoobic qoobstructures:

0: put a 0 on the qoob

1: put a 1 on the qoob

[ ... ]: remove a bit from the qoob, then loop the contents if it was 1, repeating the check each loop around

qoob can do anything. This is because it is the most qoobish language in the universe.

https://esolangs.org/wiki/qoob

[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

[stkptr]

This one is actually not so accidental, depending on how "generous" you want to be with the term programming language. One could definitely argue that an uberstate -> seed format is certainly a programming language of sorts, just one that has limited utility.

There are absolutely a bunch of ways you can accidentally create programming languages though, even Turing complete ones. Pretty much whenever you have something operate on input, it's sort of a programming language.

Surely that's an exaggeration, right? Not really. Consider a basic interpreter for something like Brainfuck. All it does it steps through the program character by character and does something depending on the character. Brainfuck is Turing complete and certainly a programming language.

When you take in input and do something based on it, the user can control what the program does based on that input. If they are particularly clever they may be able to get the program handling their input to affect a computation.

This seems goofy but actually has security implications. In cybersecurity there's the concept of weird machines. There are many ways in which they can arise as a security problem, but generally if the user is able to corrupt the state of a program based on their input there's a good chance that they can then control the corrupted state using an unspecified secret latent programming language. This secret language that nobody intentionally wrote is a consequence of how the program was made and, depending on the circumstances, may allow for anything from exfiltrating secret variables and denial of service to complete arbitrary code execution.

Weird machines are squarely in the "accidentally made programming language" territory, but going back to the original example, there are many similar cases where a programmatic system is extended just slightly to the point of (at least "practical") completeness.

In C there's this function called printf, which prints output to the terminal based on a format string. Format strings look like "age: %d\n" with the %d being a placeholder for a number. There are a lot of different placeholders, including ones for decimals, strings, single characters, numbers in hexadecimal, etc. Particularly notable is the placeholder %n, which doesn't actually change what gets printed, instead it writes the amount of bytes printed out so far to a pointer.

The intended use case was to see how much space parts of a string took up, for alignment or similar. This simple intention combined with the overall behavior of C allows you to do pretty much anything using just looped printf, like implementing a tic-tac-toe game.

It doesn't have to be so explicitly unintentional, either. SQL started out as a database query language, and is still mostly used for that purpose. As time went on more capabilities were added to the conditions on which data could be retrieved, and eventually a full programming language specification was added to SQL. A lot of domain specific languages go down this route, as can be seen with the seed language.

As someone who does a lot of informal research on systems in theoretical computer science, it can be very easy to create a system which just so happens to be Turing complete. Hell, just 6 arbitrary precision integer variables in a loop with + - * and floor division is Turing complete, it's called blindfolded arithmetic. Even many systems which are not Turing complete can still do an impressive amount of computation.

If you're a programmer, keep this in mind whenever handling user input. Whether the input is a file, network request, or typed input, make sure to think about what kinds of input the user could potentially put in there and how your program might behave when certain data are input.

How do you *accidentally* make a programming language?

Oh, it's easy! You make a randomizer for a game, because you're doing any% development, you set up the seed file format such that each line of the file defines an event listener for a value change of an uberstate (which is an entry of the game's built-in serialization system for arbitrary data that should persiste when saved).

You do this because it's a fast hack that lets you trigger pickup grants on item finds, since each item find always will correspond with an uberstate change. This works great! You smile happily and move on.

There's a small but dedicated subgroup of users who like using your randomizer as a canvas! They make what are called "plandomizer seeds" ("plandos" for short), which are seed files that have been hand-written specifically to give anyone playing them a specific curated set of experiences, instead of something random. These have a long history in your community, in part because you threw them a few bones when developing your last randomizer, and they are eager to see what they can do in this brave new world.

A thing they pick up on quickly is that there are uberstates for lots more things than just item finds! They can make it so that you find double jump when you break a specific wall, or even when you go into an area for the first time and the big splash text plays. Everyone agrees that this is neat.

It is in large part for the plando authors' sake that you allow multiple line entries for the same uberstate that specify different actions - you have the actions run in order. This was a feature that was hacked into the last randomizer you built later, so you're glad to be supporting it at a lower level. They love it! It lets them put multiple items at individual locations. You smile and move on.

Over time, you add more action types besides just item grants! Printing out messages to your players is a great one for plando authors, and is again a feature you had last time. At some point you add a bunch for interacting with player health and energy, because it'd be easy. An action that teleports the player to a specific place. An action that equips a skill to the player's active skill bar. An action that removes a skill or ability.

Then, you get the brilliant idea that it'd be great if actions could modify uberstates directly. Uberstates control lots of things! What if breaking door 1 caused door 2 to break, so you didn't have to open both up at once? What if breaking door 2 caused door 1 to respawn, and vice versa, so you could only go through 1 at a time? Wouldn't that be wonderful? You test this change in some simple cases, and deploy it without expecting people to do too much with it.

Your plando authors quickly realize that when actions modify uberstates, the changes they make can trigger other actions, as long as there are lines in their files that listen for those. This excites them, and seems basically fine to you, though you do as an afterthought add an optional parameter to your uberstate modification action that can be used to suppress the uberstate change detector, since some cases don't actually want that behavior.

(At some point during all of this, the plando authors start hunting through the base game and cataloging unused uberstates, to be used as arbitrary variables for their nefarious purposes. You weren't expecting that! Rather than making them hunt down and use a bunch of random uberstates for data storage, you sigh and add a bunch of explicitly-unused ones for them to play with instead.)

Then, your most arcane plando magician posts a guide on how to use the existing systems to set up control flow. It leverages the fact that setting an uberstate to a value it already has does not trigger the event listener for that uberstate, so execution can branch based on whether or not a state has been set to a specific value or not!

Filled with a confused mixture of pride and fear, you decide that maybe you should provide some kind of native control flow structure that isn't that? And because you're doing a lot of this development underslept and a bit past your personal Balmer peak, the first idea that you have and implement is conditional stops, which are actions that halt processing of a multiple-action-chain if an uberstate is [less than, equal to, greater than] a given value.

The next day, you realize that your seed specification format now can, while executing an action chain, read from memory, write to memory, branch based on what it finds in memory, and loop. It can simulate a turing machine, using the uberstates as tape. You set out to create a format by which your seed generator could talk to your client mod, and have ended up with a turing complete programming language. You laugh, and laugh, and laugh.

[otesunki]

what if i told you

this:

is a Turing Complete Programming Language

[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