On Apr 30, 8:15 am, William Stein <wst...@gmail.com> wrote:
>
>
> > ....
> > I would be quite interested in seeing a defense of this idea, because,
> > to me, it seems like quite a bad notion.
>
> > Replacing Maxima (which is [being treated as..] free/open) with
> > another [free/open] package, yet to be written, but which starts with
> > a package which does substantially less (if I understand the
> > description of pynac as Ginac), makes sense only if your mind set is
> > "lisp is bad, python is good".
>
> It is.
Thanks for this admission. I guess I won't see a defense of this idea.
>
> > If your goal is to compete with Maple and Mathematica, you will also
> > have to program all of the facilities in those systems as well in
> > pynac.
>
> Yes, we have to implement the mathematical features of those systems
> that users need.
You have no way of knowing what users need in advance of their
expressing their
needs, so it seems to me you can compete only if you supply all of
their facilities. Not
just the ones that are easy.
> This belief you have that only 2 people are smart enough to work on
> certain parts of mathematical software reminds me of what Stephen
> Wolfram says in defense of Mathematica being closed source (e.g., his
> remarks in that recent video were very similar).
I haven't seen the video, but you distort my statement. I think
perhaps you are showing your bias against reality. I said
"in a case where only one
or two people have the understanding to write or read a program
regardless of how nice the language is. "
I did not say that only one or two people in the world were "smart
enough" to do the job.
Gaining an understanding sufficient to write or read a program can be
a time-consuming and tedious process, as I think nearly anyone who has
written a program will understand. Certainly being smart helps, but it
is hard and error-prone work, and one can easily be deceived into
thinking that one has found a bug or fixed a bug.
Say that you have uncovered a bug in Maxima (or Maxima copied over
from Lisp into Python) that is perhaps localized to somewhere in the
Risch integration code. Sending 10 smart people off to fix it would
be much less productive that to (say) have the one person who
understands the code look at it (if there is such a person).
>
> I am highly impressed and *humbled* by the intelligence and
> capabilities of the hundreds of people who have contributed to Sage.
That's nice. How many of these hundreds of people would know where
to start to find a bug which might originate in (say) the python
garbage collector, and which might appear only in (say) Cygwin-based
Windows XP versions, and then only after running for 5 CPU hours,
sometimes?
My experience is that, while there are many clever and capable people,
they still write programs with bugs, or insert fixes which themselves
introduce additional bugs. Stamping out this phenomenon is difficult.
Especially in open-source projects, I think there are also well-
meaning and energetic individuals who are less clever and capable who
offer designs and implementations of features, or "fixes" that may be
best avoided. The more of these you have (hundreds?) the worse off you
may be.
>
> > (RJF) I hope these comments, negative as they may seem, provide some help
> > in formulating your position paper.
>
> Thanks. I strongly recommend taking anything RJF says with a grain of
> salt, since he seems to have a bone to pick against "pure mathematics"
> for taking funding from computer science.
This is true. The NSF should fund "pure mathematics" from its
mathematics directorate. The writing of computer programs whose
application area is "pure mathematics" is (most likely) also part of
the mandate for the mathematics directorate, even if they would prefer
that it be computer science. NSF Math prefers to fund people who are
mathematicians-in-training, not staff programmers or computer
equipment.
It would be (I think) a mistake for NSF's computer science/engineering
people to fund the writing of applications of computers to (say)
sociology, music, business, chemistry, archeology, biology,
astronomy, ... the separate disciplines should fund that, generally.
There is a case that might be made about some applications being so
cutting edge that there is some computer science in them, e.g.
meteorology and parallel supercomputing, that some sharing of funding
may be justified.
> Also, he has personal
> commercial interest in lisp,
This is true, I own shares in a company that sells Lisp (Franz Inc.)
Its product Allegro Common Lisp is one of the several Lisps that can
run Maxima. No one has suggested that Sage use Allegro Common Lisp
for Maxima. I generally use the free Gnu CL version (GCL) which is
covered by the GPL. Sage (still?) uses CLISP which is several times
(5X?) slower than GCL, which then helps support the claim that Maxima
is slow.
> and a strong bias toward Maxima as he is
> one of the original authors.
Actually, I have many problems with Maxima, (Macsyma) and have written
extensively about things that it (and Mathematica) does wrong. Perhaps
you should read them. I would much prefer that efforts to write a NEW
computer algebra system be guided by such advice, and not duplicate
the design. I would guess that the model presented in the Axiom
system would appeal more to the initial Sage audience, though it too
has problems.
</begin sarcasm> My bias in favor of Maxima is clearly evident in that
I disagree with the idea of assigning to (staff or volunteers) the
task of rewriting 250,000 lines of Maxima's Lisp (and Maxima-
language) into Python. Or even using the Maxima specification, such
as it is, for writing a new CAS from scratch.
</end sarcasm>
In response to Jason Grout's note about bug finding, I note that he
talks about people who are extremely good at "code" working together
with people who are extremely good at "math".
He is unfortunately correct in that people who are good at one are
rarely very good at the other, and so the number of people who can fix
certain parts of CAS programs, or write state-of-the-art new programs
is rather small. But it goes further. What does it mean, "good at
code"? Someone who can find the bug in the implementation of bubble
sort? Or the person who would know that bubble sort is inefficient
and a library sort program is better? Or the person who would realize
that your array need not be sorted if you used a hash table? Or the
person who realized that you were using O(n^2) storage when you needed
only n*log(n)?
Few people have a deep background (e.g. graduate level math) and are
also well educated in computer science. I'm not sure what the reasons
are, but it is true generally of graduate students (in math) at
Berkeley. Few graduate students in computer science have deep
backgrounds in math (except a small percentage may be good at
statistics, computational complexity, discrete math, logic, and
perhaps numerical analysis). For projects I have run, requiring
computer science and (say) understanding of conformal mapping, hardly
any student is fully qualified.
There are pitfalls in building large systems by teams of enthusiasts
who know some application area like "group theory", but assume a two
week course in Python is equivalent to a thorough background in
software design and implementation. I suspect that there are even
worse pitfalls in building systems where the enthusiasts do not even
know the application area.
Perhaps the NSF meeting with Joyner etal is now over :)
RJF
--~--~---------~--~----~------------~-------~--~----~
To post to this group, send email to sage-devel@googlegroups.com
To unsubscribe from this group, send email to
sage-devel-unsubscr...@googlegroups.com
For more options, visit this group at http://groups.google.com/group/sage-devel
URLs: http://www.sagemath.org
-~----------~----~----~----~------~----~------~--~---
