A sometimes minimal FORTH compiler and tutorial for Linux / i386 systems
Richard W.M. Jones
FORTH is one of those alien languages which most working programmers regard in the same
way as Haskell, LISP, and so on. Something so strange that they'd rather any thoughts
of it just go away so they can get on with writing this paying code. But that's wrong
and if you care at all about programming then you should at least understand all these
languages, even if you will never use them.
LISP is the ultimate high-level language, and features from LISP are being added every
decade to the more common languages. But FORTH is in some ways the ultimate in low level
programming. Out of the box it lacks features like dynamic memory management and even
strings. In fact, at its primitive level it lacks even basic concepts like IF-statements
Why then would you want to learn FORTH? There are several very good reasons. First
and foremost, FORTH is minimal. You really can write a complete FORTH in, say, 2000
lines of code. I don't just mean a FORTH program, I mean a complete FORTH operating
system, environment and language. You could boot such a FORTH on a bare PC and it would
come up with a prompt where you could start doing useful work. The FORTH you have here
isn't minimal and uses a Linux process as its 'base PC' (both for the purposes of making
it a good tutorial). It's possible to completely understand the system. Who can say they
completely understand how Linux works, or gcc?
Secondly FORTH has a peculiar bootstrapping property. By that I mean that after writing
a little bit of assembly to talk to the hardware and implement a few primitives, all the
rest of the language and compiler is written in FORTH itself. Remember I said before
that FORTH lacked IF-statements and loops? Well of course it doesn't really because
such a lanuage would be useless, but my point was rather that IF-statements and loops are
written in FORTH itself.
Now of course this is common in other languages as well, and in those languages we call
them 'libraries'. For example in C, 'printf' is a library function written in C. But
in FORTH this goes way beyond mere libraries. Can you imagine writing C's 'if' in C?
And that brings me to my third reason: If you can write 'if' in FORTH, then why restrict
yourself to the usual if/while/for/switch constructs? You want a construct that iterates
over every other element in a list of numbers? You can add it to the language. What
about an operator which pulls in variables directly from a configuration file and makes
them available as FORTH variables? Or how about adding Makefile-like dependencies to
the language? No problem in FORTH. How about modifying the FORTH compiler to allow
complex inlining strategies -- simple. This concept isn't common in programming languages,
but it has a name (in fact two names): "macros" (by which I mean LISP-style macros, not
the lame C preprocessor) and "domain specific languages" (DSLs).
This tutorial isn't about learning FORTH as the language. I'll point you to some references
you should read if you're not familiar with using FORTH. This tutorial is about how to
write FORTH. In fact, until you understand how FORTH is written, you'll have only a very
superficial understanding of how to use it.