login  home  contents  what's new  discussion  bug reports     help  links  subscribe  changes  refresh  edit

This page is intended for Axiom developers and those who might want to become developers. Here you can get an overview of what to do, and where to discuss issues with others.

Tim Daly has proposed the following development model for Axiom.

Current Axiom development work is archived using the Arch source code repository. Tim also explained why Arch was choosen for this task. Using Arch is not difficult.

If you have any difficulty with Arch, you can also access the same source code via darcs. See MathActionRepository.

Structure of Axiom Source Files

All of the Axiom source is written in a Literate Programming style and contained in Pamphlet Files. These files contain the system documentation (written in LaTeX) also contains the entire source code itself. The design and theory of operation of the program makes direct reference to the source code and both are updated together in a single source document.

Axiom bugs and patches

One tasks of the Axiom developers is to analyze known problems and to propose patches. You are cordially invited to join the hunt for solutions!

The second task is to add to the bug list those things Axiom should do but still cannot do, or worse, does incorrectly.

If you are new to Axiom or computer algebra in general, you might find it useful to browse through "A Critique of the Mathematical Abilities of CA Systems" by Michael Wester,

You can apply the patches by saying something like:

    cp axiom/mnt/linux/src/algebra/combfunc.spad .
    patch combfunc.spad combfout.patch
    axiom
    )co combfunc.spad

The next time you use Axiom, you simply say )lib COMBF to use the patched category/domain/package.

Axiom Design Issues

Well, design issues...

Axiom OldTodoList

Working towards the next Axiom Release

Axiom Found Objects

This is a collection of pages I found on the web, which may contain useful stuff.

Programming Language Issues

(from an email by Tim Daly on Sunday, August 31, 2003 3:56 PM)

Axiom is written in boot and common lisp. I wrote most, if not all, of the common lisp. I found the boot syntax (which is basically lisp except that parens are replaced by indentation) was impossible for me to use. However other people on the project hate parens. It was a religious difference that never got solved.

Boot has some nice features. It was basically Python before Python existed. The key flaw in Boot (and Python) is that programs are not data. That is, (print (eval (read "sourcefile"))) is broken. And there is no documentation as it is a perfectly obvious language (sarcasm optional).

But, being a religious debate, the issue can never be resolved. If I'm not mistaken (but memory fails) Bill Burge added a "feature" to boot to allow "nopile" (indented code was called "piled" code). that relied on syntax rather than spaces. It caused quite a stir about like having the Pope decide to require all catholic females to wear a burka. (Or Lisp programmers to code in Boot, which is far worse :-) )

There is a third language used in the system called Meta. (Which is why meta.tar exists in zips). This code is not part of the bootstrap but needs to be at some point. Changing the meta parser (see metameta.lisp, fnewmeta.lisp, and metalex.lisp) would surely cause havoc. In the distributed system I replaced the Meta code with common lisp.

There is a fourth language called CHARYBDIS used in the printing subsystem. This was a project at MIT around the time that IBM was working on MODLisp?. I'm not sure how they got co-mingled but I believe Dave Barton and Joel Moses (MIT) worked with Dick Jenks, Jim Griesmer, and Fred Blair (IBM).

There is a fifth unnamed language, a psuedo-tex-html language (see src/share/doc/hypertex/pages/util.ht) that is used by the hypertex system (which is a browser before browser existed). You can see this language stick up into the world in the comments section of the algebra files. Notice the \axiom{}. That's the TeX-used-as-HTML language. Scott Morrison invented this language to drive Hypertex, also his work.

In fact, if you do ")set output script on " you'll find support for IBM's internal TeX-like language called Script. Technical papers were written in Script before Knuth's TeX caught on. This isn't a new language within the system but it is another language that is still supported by the system. )set output fortran also works.

There is a sixth language, called spad, which is used to implement the .spad algebra files. There were several spad languages. Each time we redesigned the language we renamed the old language "old spad". We were talking about old-old-old-spad at one point in the project. These languages are now dead but you can still find code to support them Look for "old" and "new" in the sources. Bill Burge, our parser guy, used "old" and "new" as the spad and boot languages evolved. It caused no confusion in any given week but caused massive confusion in the code.

You can still see the confusion. Build Axiom then rebuild Axiom.

(digression: I have a second-build function-calling optimizer that Bill Schelter and I worked on. We needed to make function calling faster. There isn't enough information on the first compile. So if you look in src/interp/util.lisp in the function make-depsys you'll see the load of "/cmpnew/collectfn". This is code Schelter and I worked on. When you compile a lisp file for the first time (say foo.lisp) it spits out a file (foo.fn). If foo.fn exists and you recompile the foo.lisp file it will optimize the function calling code (fast-pathing the code) since it has "perfect information" about how many arguments and what type the arguments are. This is a significant improvement. So Axiom is much faster after the second build. I have to automate this in the build but haven't yet. It works if you hand-build Axiom twice).

On the second build of Axiom the function-optimizer has the .fn files. It will complain that duplicate code exists. The reason for this duplicate code is that some of it is "old^N" code (where N is ambiguous) and the duplicate code is "layered" on top of the old code. I have to go thru the system and decide which code is correct and elide the "old" code. I have marked all of the duplicates in the sources (look for "---->") but stopped that effort in order to get the code uploaded.

In any case this is an example of the "confusion" as we frequently needed to run "old" BOOT and spad code until I rewrote it into the "new" BOOT and spad code. Shortly before Axiom was given to NAG I spent several weeks rewriting all of the algebra files into the "new" A# (AxiomXL?, Aldor) compatible language so that the spad compiler and the Aldor compiler used the same language.

There is a seventh language, originally A#, then AxiomXL?, now Aldor which is a minor variant of spad. It allows the use of { } pairs instead of indentation making it a philosophical cross between the lisp and boot religions. (Bill Burge's "nopile" option exists in Aldor). (It also uses ";" which is an abmonination but that might be a religious opinion :-) )

There is an 8th language called SHOE (search for SHOE) which was a replacement for BOOT. Bill Burge liked puns. SHOE was a "more refined" BOOT. BOOT was a bootstrap language written in BOOT. Once Burge got a language "in the air" he was quite fond of losing the scaffolding that got it there. As a consequence BOOT and spad could not be built from scratch and required a running BOOT and spad compiler. This is fixed in the released version. This fix took the bulk of the last 8 months which is why it took so long to deliver an open-source version of a product (NAG already had a running Axiom and didn't need to build from scratch but I'm not allowed to distribute a runnable Axiom so I had to fix this fundamental problem). The fix is horrible and I'll rewrite it all from scratch eventually. However if you had to wait for me to "clean up" all the issues you'd have to wait a few years. Release early, release often is going to be my mantra.

There are even languages within languages. If you look at the common lisp you'll find such things as (from g-opt.boot.pamphlet): EVALANDFILEACTQ which is VMLisp?/370 (nee LispVM?, nee Lisp/360) a product of Fred Blair, Cyril Alberga, and Mark Wegman (which, by the way I need to add to the kudos list since Fred, Cyril, and Mark were heavily consulted during the translation from VMLisp?). Most of the MACLisp? and VMLisp? rewrites are in vmlisp.spad.pamphlet.

Looking even deeper into the common lisp you'll find MODLisp?, which was an effort by Dick Jenks, Dave Barton, and a few others. Bits of it still survive. It predated and fathered Scratchpad/Scratchpad II.

And there are even MACLisp? primitives still around like subrp (see src/interp/vmlisp.lisp.pamphlet).

I rewrote large portions of old code trying hard to eliminate these old languages but found that the newer languages didn't have a name for all of the old concepts (e.g. EVALANDFILEACTQ) or the new name didn't match the meaning of the old name (e.g. subrp vs compiled-function-p) exactly so I had to write cover macros/functions. Over time I eliminated the semantic differences and some of the cover functions/macros are now simply renames (e.g. subrp is now just a rename and should be removed). We sold Axiom before I could completely clean up the system. Now I get a second chance (of course I wish the filmy bastard (i.e. me) had DOCUMENTED some of this code :-( )

When dealing with languages it is very hard to do a rewrite. Usually the original programmer was an expert in his language (e.g. MACLisp?) and the rewrite-programmer is not. When the rewrite happens subtle things break. My special talent on the project was deep expertise in anything lispish as I worked in MACLisp?, VMLisp?, Common Lisp, SpiceLisp? ZetaLisp?, PSL, Scheme, Standard Lisp, NIL, and my own implementation (living quietly under code that runs IBM's and Unimation's industrial robots) and every other variant that I could find. I even have a lisp implemented in fortran. Thus you will hear me say (and not realize the religious nature of the comment) that "Axiom is just Lisp".

Clearly there is much more to do.

Anyway, this history lesson is brought to you by the letters Alpha and Omega, and the numbers pi and e.

---------------

Tim, the wizard (from Monty Python)




  Subject:   Be Bold !!
  ( 13 subscribers )  
Please rate this page: