Computer algebra system? / SAGE and Pipes

The comment that SAGE's mechanisms are good (or adequate) for linking
various systems is either na?ve, or assumes that users of SAGE use SAGE only
for simple things, or the systems SAGE is linking together are na?ve.  ( I
think the last is false since it includes Maxima).

Pipes as popularized by UNIX are suitable for exchanging relatively
low-capacity serial messages in an environment where the options on each
side of the communication are fully characterized. I have not studied SAGE,
but here are some issues that I think would come up.

1. Maxima sometimes answers a question with another question, not an answer.
(e.g. Is s positive, negative, or zero). This is usually unexpected.

2. Maxima sometimes runs out of memory, or goes into a loop.  Interrupting
it from the keyboard may or may not be possible (depends on the Lisp,
probably).

3. Maxima sometimes produces objects that cannot be serialized without
substantial (exponential!) growth in size, unless it is done in some
sophisticated fashion. Exchanging such objects by simply pipes of Lisp
read/write of characters is not sophisticated enough. 

4. Serializable objects (say, from Maxima) in the command system of SAGE
must be understood in a context that is suitable for interacting with
objects from another hosted system (say, MAGMA). Does SAGE understand
Maxima's Poisson Series? Writing one to a file and then reading it in via a
command sent in a pipe could be extraordinarily expensive. Saving everything
that one can conceive of -- say a restartable core image, via a pipe would
be, I think, a challenge. Mapping all error messages in Maxima to a single
error may be uncomfortable.  A variety of evaluation and simplification
strategies can be present and it may not be clear who governs.  E.g. in
SAGE, evaluate(simplify(  maxima(expression1)+maple(expression2)) ?  What
happens?

Introducing yet another language (Python, PERL, ....) to the mix makes the
semantics potentially more difficult.  Lisp, for example, has an entirely
smooth interface between small and large integers. Does Python? 

Writing totally in Lisp  (though perhaps not generic CL in everyone's
implementation) has an interesting proof-of-concept: the Lisp machines.  In
these designs the entire or nearly entire system from operating system to
user-interface (including compilers for Fortran, paging systems etc. were
all written in Lisp, as well as Macsyma...) This residential system provided
a far more uniform environment than I think is possible in the SAGE design.
There were Lisp machines built by Symbolics, LMI (Texas Instruments), Xerox.
Some of these are still running, apparently.

Some of the current Maxima project coding effort is, I suspect, similarly
hobbled by pipes.  Perhaps someone else might comment on this! My impression
is that the plotting has the defect, that (say) zooming in and computing
more points in a plot may not be possible in the usually Maxima plot because
the data produced by the Maxima plotting program is a fixed package that is
handed (via a pipe or something similar) to a stand-alone plotting program
that does not know that it can call back for more information,  as it
should.  (Such features are available in the commercial Macsyma, and have
been for many years. I think they were recently introduced to Mathematica).

It is much easier to write a system in which everything works well as long
as all the participant programs cooperate nicely with the human user. It is
much harder to write a system that works when the participant programs are
stretched to (or beyond) the breaking point and the human is trying to solve
problems that were unanticipated by the designers.  I don't know where in
the spectrum of systems SAGE fits.  I have been impressed and somewhat
surprised by the apparent success of SAGE, but it could also be that many of
the participating programs are more cooperative than Maxima, and were
designed ab initio to play nicely as batch programs.

RJF


>