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 _______________________________________________ Axiom-developer mailing list [email protected] http://lists.nongnu.org/mailman/listinfo/axiom-developer
