Re: [Axiom-developer] Aldor and Lisp

[root]

A bit of history....

(Please note that this is NOT a criticism of either Dick Jenks
or Bill Burge, both of whom rank among the best people I've ever
met in this business. Dick was like a father to me on the Scratchpad
project. I'm the opinionated, stubborn son(-of-a-bitch) in this story)

Boot grew out of work Dick Jenks did in Meta which was some
pre-scratchpad work he did. He and Bill Burge (another group
member) were very interested in parsing issues. Bill Burge has
a book out on parsing techniques (ISBN 0-201-14450-6) and knows
everything worth knowing about the subject.

(an aside. There was another portion of the system written in Meta
which I've already removed).

Scratchpad was originally written in a combination of boot and maclisp.
By the time I joined the project it had been moved to VMLisp on an IBM/370
mainframe. I had a very wide range of experience with many different lisps.
A previous project (Eclipse, a rule-based language) was implemented in
VMLisp and I had moved it to Common Lisp on a Symbolics Machine. Later
we moved it to Lucid Common Lisp.

At the time the IBM PC was becoming more popular and IBM had introduced
its new IBM/RT Risc processor (aka "the hairdryer" because both used about
1500 Watts and had the equivalent compute power). We wanted to move 
Scratchpad off the mainframe and onto the RT.

I connected with Scott Fahlman at CMU and got the sources for CMU Spice Lisp
(now known as CMUCL) and built it on the RT. We wanted our own version of
Common Lisp and took out a contract with Bill Schelter for AKCL which was
his version and extension of KCL (Kyoto Common Lisp, AKCL stands for
Austin-Kyoto Common Lisp as Schelter was a professor from Austin Texas).
AKCL is now GNU Common Lisp (GCL). I worked closely with Schelter on various
implementation details (like GC and tail recursion which we needed badly
as the top level loop of Axiom is tail-recursive)

I rewrote large chunks of scratchpad from VMLisp/Maclisp to Common Lisp.
As part of that effort there were numerous, sometimes heated, discussions
of Boot vs Lisp. Dick was firmly planted on the Boot side and I was firmly
planted on the Lisp side. Since Dick fathered the Boot language this is
perfectly understandable. Boot was one of many dozens (hundreds) of attempts
to make a paren-less version of lisp (Python is the latest attempt). 

I rewrote the whole system into Common Lisp at one point but was unable
to convince Dick or the rest of the group that this was acceptable and
the code was erased.

Bill Burge wrote several parsers for Boot which added new features that
were showing up in Common Lisp. There were so many "new" parsers that
we had a running jokefest about the "new-new-new-new version" vs the
"new-new-new-new-new version" of the language. You'll see references
to "Shoe" in some function names. "Shoe" was an improved Boot. (Bill
had a very dry sense of humor.)

Being firmly in the Lisp camp I wrote all of my code in Common Lisp.
Thus if you look at the sources the .lisp files were likely authored
(or re-written) by me as the rest of the group continued to use Boot.

I'm fundamentally opposed to Boot and have stated many times that my
goal is to rewrite the interpreter to elide Boot completely. There are
several reasons.

Boot gives up one of the fundamental features of lisp, the equivalent
representation of program and data. In fact, Axiom uses this equivalence
at various points and fundamentally depends on it.

Boot adds another layer of complexity to the system, a very difficult
layer. The effects are widespread. You need a Boot compiler to compile
Boot, which is written in Boot. Bill liked to build parsers in his new
language and, as a consequence, there was never a version of Boot that
would build from scratch. Up until the time I got Axiom as open source
it was always true that you needed a running Axiom system to build Axiom.
(Since I didn't have one available that could be shipped as open source
I had to solve the bootstrapping-Boot problem).

Boot breaks the lisp debugging tools because, while it compiles to lisp
it generates "compiler code" which is very hard to read unless you're
very familiar with the transformations it performs. Sure, it is valid
common lisp but look at the int/interp/*.clisp files and you'll see
some hairy-looking code. And when it breaks in mid-code the traceback
is not intuitive at a time when you need intuition the most.

There are interpreter-level support functions for working in Boot
which allow you to recompile and reload files. These are not needed
for Lisp code.

The whole Boot compiler subsystem can be removed if Boot is removed.
This reduces the Axiom build time and complexity quite a bit as there
is no need to bootstrap the compiler nor to compile the boot code.

Boot is a language known to very, very few people and is likely to
have an ever shrinking set of people as the original developers die.
The learning curve is either very steep or trivial depending on who
you talk to but it is still a learning curve. Boot, like all languages,
has some very pretty features but nothing fundamentally immortal.

I need to do this rewrite anyway as the whole interpreter needs to be
made into a literate, well documented program. Given that level of effort
it only makes sense to do all the cleanup/rewrite/refactoring at the same
time.

Not everyone agrees with me, of course, so it is ultimately up to me
to make this change if I ever want it to happen. As they say in free
software "Advocacy is volunteering" :-)


t