Re: [Axiom-developer] Why did Axiom fail in the 1990s?

[Bill Page]

On 7/1/07, William Sit wrote:
> My emphasis was to have more *USERS* and the question is
> why many former users abandoned Axiom and did not return.
> To clarify, "users" includes people who use Axiom to
> compute and/or contribute new algebra code with
> documentation (who may also be, but not exclusively,
> build-developers or system-developers: people who
> contribute to make, lisp, boot, user-interface, compilers,
> interpreters, packaging, etc.).

I think we need to face the fact one possible reason why previous
Axiom users have abandoned Axiom and why there are so few new people
who identify themselves as Axiom users is simply because Axiom is too
hard to use. We may have a strong belief and commitment to the
strongly-typed object-oriented programming environment offered by
Axiom but when you get right down to it - even after 5 years of
working with Axiom fairly intensively! - when I sit down to do
something new in Axiom I still find it enormously more difficult to
get started in Axiom than in Maple, Mathematica or Maxima. I think the
Axiom interpreted does a heroic job of trying to isolate the user from
the intricacies of the Axiom type system, but unfortunately it is not
nearly enough. After a few minutes of working on some new problem you
are almost certain to run into some expected behavior involving type
inference - some quite difficult to solve. I think this is often
deadly to all but the most die-hard Axiom novice users.

Even the original Axiom developers where aware how difficult it is for
new users to use Axiom and so started on a path to develop a new
interpreter called B# (BNatural). Unfortunately this was only towards
the end of the research project at IBM and the mean time both
Mathematica and Maple had started to make major in-roads with computer
algebra users. In spite of a major development effort by NAG,
realistically Axiom never really had a chance against this
competition.

I could be that as an experiment, the failure of Axiom as a viable
computer algebra system shows that there is something wrong with the
concepts of strong typing and object-orientation when it comes to the
design of computer algebra systems. After all most mathematics is not
conducted in anywhere near a rigorously typed manner as required by
even the simplest Axiom program.

Oddly however, the Axiom library with over 1,300 algebra modules is
strong evidence to the contrary. As an library of mathematical
routines, Axiom is a phenomenal success. Apparently a lot was done
right in the design of the SPAD (and Aldor) compilers.

Maybe Axiom was just a little too far ahead of it's time (again).
Maybe languages like Haskell with full type inference show a possible
way forward. Maybe dynamically types scripting languages like Python
(such as used by Sage), show a way to develop a user accessible
interpreter. But unfortunately for Axiom, it might be too late. :-(

Regards,
Bill Page.