I don't know that this blog is going to turn out to be. But the
name is a reference to the three programming languages
bloop,
floop, and
gloop that Douglas Hofstadter introduced
to illustrate a few points in computability.
bloop is especially designed not to be turing-complete,
and he removes one constraint to create
floop which
is. That one still is unable to compute every imaginable
function and thus he continues to
gloop, only to confront
us with the fact that there is no such thing. No programming language
can be more powerful that
floop.
From the theoretical point of view, that is. In practice there is
a big difference in how much effort you need to express in different
languages what you want the computer to do. Programming is much
about abstracting away repeating chores, and it is astonishing how
much of those
can't be automated in the popular languages
of the day.
By now I am actively suffering from the fact that there are so many
things that a good language would make easier but such language either
don't exist or aren't reasonable to use in the field I need them.
Closures, anonymous functions and proper lexical scoping are the
things I would like to play with. But a proper macro system is the
one thing that would really spare me a lot of tedious work.
To be able to toy with these concepts I am hacking a language that
is more or less going to be a (im)proper java: static typing with local
functions and closures, and most importantly with means to extend the
parser and to write macros that can use the full power of the language.
One additional aspect is to make the virtual machine fully persistent
meaning that it can simply resume execution of a program after the
VM has terminated for some external reason.
So this language and other linguistical musings will be the
topic of this blog. I'm probably not going to rant about aspherical
lenses for glasses here.
And no, I don't have the compiler ready. At the moment I have a very
basic lexer and parser. The third version, actually. I started with
C++ (ugly), then Ruby (good), then Nice (not bad). The last try is
partly because the Ruby version was already two months ago and partly
because I have hopes that the Nice version is more easily translated
into the target language itself. Next job is to figure out a VM and
execution model.
