What I've Been Up To (Upcoming Project)

My website has been pretty static lately, as it has a habit of being. That being said, I've been far from static!

Right now most of my time has been devoted to classes and many many math problem sets and readings, but I do have some software in the works. The main one should be making a debut here in a month or two and it is (drumroll please):

Equi/Equicontinuous/EquiParallel -- the name is far from figured out.

What it is right now is a scripting language that is slowly evolving, what it will be one day is a interpreted fully parallel programming language made for prototyping asynchronous big data programs on affordable clusters. There's a lot of work to get to those buzzwords though, and that is what I have been silently chugging away at.

And it turns out that, to no one's surprise, programming languages are hard. They actually use a ton of techniques from natural language processing, because they are in their own way a language. Taking a line of code such as:

if (a == b) print(a);

And just understanding how it breaks down as a grammar is actually really nontrivial. You can't just read it left to right and figure out what to do (maybe this one example you can, but when it gets more complicated you cannot), because the grammar of a programming language isn't actually regular, they are usually context free.

What that means is that we need to first define a grammar for our language, and then we need to find a way to work backwards from that grammar and build a "syntax tree" of what we want our code to do in a way that is more understandable for the code and in line with our intentions.

To the left is what a very early version of our programming language's grammar is defined as.

​To the right is our "parse tree" for what the code:
if (a==b) print(a);
is from.

This way we can take our intentions for how the code "should run", codify them in a grammar, and then hopefully when we run and parse the code it will do what we want.

The current version just has logical operators and declarations working (as you can sorta make out from the CFG), but it does do some things.

Like take the code on the left

​And get the result on the right! (Which we'd better hope that it outputs correctly)

More details will come in a little bit. I have most of the ground work done on the very basic version of Equi in this very productive weekend, so progress should speed up. Right now Equi is not turing complete, and has some very odd little quirks in the design that need to be ironed out, but as soon as it is slightly more impressive you will be sure to see it open sourced and several more write ups coming on out on a bit more of the process and ideas at work behind the code.