Pet Language

It is probably more than a year since I started development (or designing phase) of my last pet language, Nothing 5 , so I decided it's time to start a new one - this time with a "purpose" (more on that later).

The Nothing Language Family

Well, there's no way you've heard of any of my languages called Nothing, so let me start off with a brief history and (most importantly) the reason I made / designed them.

It all started when I learned about Brainfuck (so 2012 or 2013-ish) and decided to make a little interpreter in Java (mind you, my skills at the time were... lacking, to say the least). It all went good, but then a huge obstacle appeared: loops. I couldn't figure them out, no matter how hard I tried, so I resorted to a drastic solution - I left them out entirely and called the subset of Brainfuck I just implemented Nothing. I even wrote a simple Hello, World! program for it (without copying the already existing ones for Brainfuck).

Then, about a year later, I was intrigued by the way Java works under the hood. I was simply fascinated by using byte code and its possibilities, so a new interpreter was born - Nothing 2. This is also where we depart from the strict definition of "language" - there was no Nothing 2 language you could write your code in (at some point later I wrote a ASM-like to Nothing 2 "compiler" in PHP, but that wasn't part of the original language). On the bright side, I learned a lot about editing in hex.

Later that year, I did a full rewrite of Nothing 2 in C, because I was learning about dynamicaly linked libraries (and I decided it would be nice to have a program that can take a "program" on input and run it using the right version of the interpreter. I also made Nothing 2.1, but only to actually have something to plug into my awesome new runner.

After a short while of tinkering with dynamic libraries, I moved on to try to grasp the basics of networking. This is also why Nothing 2.2 was made. I know there were some additions related to remote control (I'm sure there was client-server architecture, but client was just a mere terminal, something what could've been accomplished using SSH - but hey, everything about Nothing is just reinventing the wheel for the sake of learning). Now, the thing is... I don't really remember it that well and I cannot find the source code.

Anyway, it wasn't long until I decided I'm ready to take on another language, and that I have enough knowledge to start from design and do the implementation last. Well, let's just say it never got past the design stage...

Then I started another Nothing project, this time called Nothing 4. It was supposed to be my first language with support for dynamic modules and maybe even C <-> N4 interoperation. I don't really know what went wrong there, but the project and Git repo it was in both ended in one psychotic rm -rf execution. Guess it wasn't so ez.

Also, I once got a genius idea to start working on Nothing 5, but I luckily ditched it very early on, so I don't really count that one.


One day, I wanted to know what is the chance of random number generator winning the 2048 game, so I built a simulation for it (btw turns out it's less than 1:10e8 - I got bored after 100 million rounds without a single result of at least 1024), then I started optimizing it, learning basics of POSIX multithreading in the process.

Then I came up with a new idea - let's make a tool that makes solving similar tasks easy, so I created a project called "Cruncher". It's supposed to take a program which accepts a predetermined set of variables and spits out some kind of results. There should also be a pipeline allowing you to chain programs together. Basically, I am reinventing the wheel called OpenCL (you know, people don't reinvent the wheel to get the job done, but to learn how is the job done and why is it so)

A side note: the name comes from the fact that it helps with solving problems using brute-force and kinda "crunches" data to do it... Listen, the name isn't important, OK? Actually, forget this side note, there's nothing to see here.

So now comes the problem: what language should I use for Cruncher programs? I want something easy to implement and integrate with Cruncher, ideally not platform specific (one of the Cruncher's goals is to be able to do load balancing over multiple machines, with JavaScript target not being out of question). It also doesn't need a fancy standard library or anything, it should just carry out basic logic and arithmetic operations... Let's make another Nothing!

Nothing 2018

So here comes the new pet language, barely dodging the naming dilema of a new Nothing language - what number to use. Should languages that were never implemented be replaced and forgotten, or not? I hopefully cannot go wrong with a year in name - I don't usually spit out more than one language per year, and even if I do, I could get away with calling it 2018.1.

Given my goals, byte code is a clear choice here - there's going to be only limited set of instructions useful for solving general problems, maybe also some for optimizations. I'm also going with fixed instruction size in the bytecode, so it'll be easy to process.

Let's see what comes out of it.