[Axiom-developer] [Axioms Community]

[Bill Page]

Changes http://page.axiom-developer.org/zope/mathaction/AxiomsCommunity/diff
--

++added:

Axiom and the scientific commnunauty

  (based on an email from Daniel Augot on Friday, September 19, 2003 5:18 AM)

  I think there is an issue for the future life of Axiom, which involves
  researchers in computer algebra. From some email exchanges with
  friends, I do not feel that the revival of Axiom as free software will
  motivate them to go back to Axiom.

  In the French commnunauty, which I know a bit, because I was involved
  during my PHD thesis, 10 years ago, many people got very involved with
  Axiom. Many wrote domains, packages etc... for implementing the
  algorithms they were introducing in their research work.

  But at his time, Axiom was a very closed software, and the French
  communauty was on its own, for documentation, help, contacting gurus,
  etc... Axiom also had its load of defaults~: a cumbersome system of
  categories, poor speed of code, compiler and interpreter bizareness,
  no way to use Unix pipes and redirection etc. Furthermore NAG did not
  show any clear sign about the future of Axiom. Even more, there was
  the promising A#/axiomxl/aldor project, with Basicmath, but it was
  immature, so the choice between Axiom and aldor was unclear.

  As a consequence many were confused and discouraged, and switched to
  other computer algebra systems, for instance Magma, which offers a
  large library and is very fast (although it does not offer the rich
  mechanism of Axiom for contructing domains and categories).

  Consequently, I think there must be a thinking about the state of
  Axiom, and clear signs concerning its future, beyond the point of
  making it publicly available. Will the compiler will be fixed ? Will
  it be documented ? Will compiled code be faster ? Will researchers in
  computer algebra be able to incorporate easily their software ? Will
  they be able to redesign the system of categories ? Will it be
  possible to link against efficient C code ? etc, etc...

  May be the benefits of the free software will show up, but, after
  discussion with friends, it will not be enough for switching back to
  Axiom.

  Kind regards, and felicitations for the work done. I have been able to
  download and compile all Axiom, and I am very glad for that.

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

  Daniel Augot

Reply

  (based on an email from Tim Daly, on Friday, September 19, 2003 10:43 AM)

I have had both face-to-face and direct email discussions that the
issues you raise are real and need to be addressed. I'll try to give
you my current thinking on the subject.

I don't expect that Axiom will gain a great deal of use simply because
it is free. I have collected about 100 free "computer algebra" systems
which I distribute on my Rosetta CD collection. Free CA systems are
"a dime a dozen" quite literally. Indeed many of these systems were
built by researchers as part of their research work.

My experience shows that most of these free systems start with the insight
that math "types" and programming "types" are similar. Starting with this
idea it becomes clear that you can build a nice, clean system from scratch.
It takes about a semester to build up a full, general purpose, polynomial
manipulation library in C++ and, indeed, you find that the math and computer
types interact very well. Then the insight occurs that the library isn't
useful to anyone but the researcher so the second semester of work involves
writing a front-end interpreter on the library. Subsequent effort involves
trying to convince others that this could be a very useful system given
sufficient effort.

This is very seductive since it looks like great progress. It has several 
problems. 

First, a local problem is that the research work that is "reduced to 
practice" using a newly implemented system cannot be effectively used by
others (e.g. library systems rarely do simplification and almost never
document their algorithms).

Second, a local problem is that reduction to practice, that is, "programming"
is generally not "valorized". The research is recognized but the year or
two spent building a working system is either ignored or considered to
be of little worth during tenure discussions.

Third, a global problem is that the algorithmic work, while free, is
generally useless to others. Either the system is so specialized that
it only does one thing well which makes it into a single-purpose, once-only
use tool or it tries to be general purpose and has such a limited range of
algorithms that it quickly reaches a point of frustration for the user.
Thus the one great algorithm at the center of the system is buried and lost.

Fourth is the "rule of 3". It takes 1 unit of work to get something for
yourself. It takes 3x1 units of work to make is so your office neighbor
can use it. It takes 3x3x1 units of work so you can use it "in the 
department" and in courses. It takes 3x3x3x1 units of work to give it
to the world for free without support. It takes 3x3x3x3x1 units of work 
to make it into a commercial product with support, a hotline, lawyers, etc.
Most "computer algebra" systems stop at the 3x1 level as there is no
interesting new research work beyond the first unit and the 3x1 units
are expended as a matter of trying to get the work out to the world.

Building your research on top of Axiom or the 3Ms (Mathematica, Maple, 
Matlab) immediately gives you the benefit of the 81 units of work already 
done.

Systems like the 3Ms get purchased because they are general purpose
enough to do virtually anything and hold out the hope that research
done with these systems will be picked up and made useful to others.
However you tend to lose control of your work. If it is badly implemented
in the 3M world and has your name attached to it you have little choice
but to suffer the hit on your reputation. In a free system like Axiom
your reputation is yours to make or break.

Detailed discussions with researchers highlights another subtle fact.
The 3Ms are built on weak theory ground. Practically speaking this has
the effect of "limits of scale". You'll find that the more complex the
package you build the more difficult these systems become, for reasons
not related to your package. The difficulty is compounded if you need
to use other "non-core" packages. In some sense, these systems are like
Perl which is easy to use, fast to write, hard to scale to large projects,
and impossible to maintain (yes, I know this is a religious debate).

Axiom started out like any other home-grown system, called Scratchpad. 
However it was started at a time that major funding was available 
(computer algebra was considered to be a branch of artificial intelligence). 
It was heavily funded by both the U.S. government and IBM Research for about 
23 years. Many researchers came to visit, many people worked on the system, 
many algorithms were created in a broad range of areas. This is the
"dream realized" for the authors of the many free "library" systems.
Fortunately Axiom started out as a "theory" system and not a "library".
(See the footnote).

IBM ran into financial trouble and sold Scratchpad (as Axiom) to raise cash.
As a business decision this made sense but as a global decisions it was
pointless. Scratchpad is a great system for doing research work and had
the support and attention of about 400 researchers worldwide. If you're
going to do real math research Scratchpad was definitely the place to work.
It required at least a master's degree to learn but was easy to extend if
you understood the underlying math. Your work could be integrated and used
by the research community. As a "product" (Axiom) it had a very limited 
market with cash-poor clients who could not support Axiom as a commercial 
product. Axiom could never generate sufficient cash flow to cover the cost
of a development team in the commercial, closed source world. And open-source
generates no cash. So Axiom is the best place to do research and the worst
place to make money.

Scratchpad was "open source" before the term existed. People who asked me
(while I was at IBM) could get a free copy of the source code. Axiom
when it was released followed the standard commercial path of closed
source software. This depends on a staff of people to maintain, which
depends on a good cash flow, and clearly Axiom couldn't generate the
cash flow. So Axiom was cut off from the customers who made it useful
and could never survive in a closed source model.

Scratchpad was ported onto AKCL, a compiled, hand-optimized version of
common lisp specifically developed under contract. I worked closely
with Bill Schelter on several detailed features like second-compile
optimization of function calling, tail recursive optimizations, memory
management, etc. to make Scratchpad perform well. When Axiom became a
commercial product it was ported to run on CCL, a byte-code interpreted
partial common lisp. This solved the portability problem (AKCL was 
very hard to port as it compiles to optimized machine code) but 
basically broke Scratchpad. Function calling and garbage collection
optimizations disappeared. Axiom is now back to running on GCL, the
open-source version of AKCL. Camm, the GCL lead developer, is on the
Axiom maintainer list.

As to contacting gurus we on the scratchpad team were told to "circle
our chairs" until we came up with something other than computer algebra
to work on (they even brought in an industrial psych. to "reprogram" us
which I found to be a very painful experience both professionally and
emotionally). NAG was in a very difficult situation guru-wise as they
lost the help of the guys who wrote it.

Aldor has great promise but people insist on trying to build the world
"from scratch". It may be several years and several failed experiments
before it becomes clear that the "library" approach is flawed. In the
mean time Axiom and Aldor have committed to supporting cross-compiled
compatibility.

As to the other issues like "cumbersome categories", hey, it's now
open-source and I'm open to ways of improving it. Scratchpad/Axiom
evolved to the system it is now because hundreds of people worked on
it and improved it. Someone needs to "unify" the Axiom type tree with
the mathematics in a much more systematic way. This is about a whole
Ph.D-thesis level of effort. The benefits of such thesis work would
be enormous as it would clarify how to correctly build these systems.
Axiom's types grew with knowledge of the theory but without benefit
of the detailed analysis.

Now Axiom is back as open source. That is a necessary condition but not
sufficient. We need two things to survive. We need a community and we
need a funding model. 

For signs about its future visit savannah.nongnu.org/projects/axiom and
click on the "homepage" link. There are long range plans to unify with
theorem proving (ACL2 or MetaPRL), group theory (GAP and Magnus), 
[142 more lines...]

--
forwarded from http://page.axiom-developer.org/zope/mathaction/address@hidden