From: mroussel@alchemy.chem.utoronto.ca (Marc Roussel)
Subject: Re: MAPLE resources reccomendation
Organization: Department of Chemistry, University of Toronto
Date: Tue, 17 Nov 1992 17:58:33 GMT

In article <BxuxC6.Dxz@news.cso.uiuc.edu> Richard J. Gaylord
<gaylord@ux1.cso.uiuc.edu> writes:
>the basic question iswhat do you want out of your cas? if you are going
>to do serious programming,  mathematica  is totally in front of the
>others.

     I don't think so.  There are some nasty "gotchas" in Mathematica
programming.  Some of these are merely syntactic, and I'm sure Richard
will disagree that they are problems at all.  Allowing space to stand
for multiplication for instance, while appealing on one level because of
its correspondence to hand notation, introduces opportunities for bugs
that would not arise otherwise.  Pattern matching is nice, but
mathematical objects should have types in order for this to work
properly.  The global and local namespaces are not properly separated.
(There are work-arounds to this problem, but they are not as nice as
proper scoping rules would have been.)  These are just a few of my pet
peeves with Mathematica's way of doing things.  By the way, a fairly
thorough list of Mathematica's weaknesses is to be found in a paper by
Richard Fateman available by anonymous FTP from either of the following
sites:

peoplesparc.berkeley.edu (128.32.131.14)
    Location: /pub/mma.review.ps.Z

math.utexas.edu (128.83.133.215)
    Location: /pub/mma.review.ps.Z or /pub/mma.review.tex.Z

     I should mention that there is one aspect of Maple that makes it
specially suited to programming: the availability of library source
code.  Quite often, all one wants to get started is a few cogent
examples of similar routines.  In Maple, getting these examples is as
easy as typing

interface(verboseproc=2);
readlib(simplify);

and Voila!  The simplify procedure is displayed on your terminal!  (It
even comes out properly indented! :-))  The advantage of library code
over either user-written or textbook examples is that you get to see
routines that were written by people who know the inner workings of the
manipulator quite well but that still was written to accomplish a real
purpose.
     An awful lot of user code has been written in Macsyma so that, in
addition to programming examples being abundant, many more special-purpose
routines are available for this than for any other CA system.  Also,
because almost all old CA systems were Lisp-derived, there is a lot of
Lisp-like code lying around that can easily be adapted to any of the
modern descendents of these systems.  In addition to Macsyma, this
category includes Derive.  (Any others that anyone can think of?)
     Mathematica is a fine tool but it has its weaknesses.  It does
things in a substantially different way than the other symbolic
manipulators; that has both advantages and disadvantages.  When you're
out on the frontiers, you have to expect bugs and design errors.  If you like
the way it does things, it's probably worth the trouble to learn its
quirks.  Many of us do serious programming with other symbolic
manipulators, so to claim that "Mathematica is totally in front of the
others" in this respect is misleading, especially given that the others,
as my examples above show, have their unique advantages too.

				Marc R. Roussel
                                mroussel@alchemy.chem.utoronto.ca
Newsgroups: sci.math.symbolic