On Fri, May 1, 2009 at 8:17 AM, rjf <fate...@gmail.com> wrote:
>
>
>
> 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.

The short summary of the dozens of pages I've shown you before is:

  * support for building lisp is poor
  * recruiting developers to work on lisp is currently difficult

Both are purely social issues, but social issues are the most important.
I make no claims at all that "lisp is bad" in any technical sense.

>> > 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.

That's like saying OS X has to implement every facility that Microsoft
Windows and Linux and Solaris implement in order to "compete".   I
don't think that is true.

>
>> 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).

It turns out that it is actually better to have other people work on
the problem, since in the long run that decreases the "bus factor" for
the code.   The more people who understand the code the better.   In
the case you mention above of bugs in Maxima, the best strategy is to
stop using Maxima, and switch to a library for which there are many
more people who can work on the code, fix bugs, make improvements,
etc.

>> 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?

There are many such people involved in Sage.

> 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.

Yep.  Software sucks.

> 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.

I don't think the people involved in open source are on average less
clever or capable than people working at software companies.  Also, in
both commercial and noncommercial settings, the organization of a
software project can help mitigate the adverse effects of people who
try to apply themselves in areas in which they are less talented.  I'm
talking about code review, certain people being in charge, a well
defined decision making process, choosing a very readable
implementation language and conventions, etc.

> </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>

(Maxima is about 120,000 lines, including whitespace and comments.)

It seems like you view Sage as a "waste of effort", since it is new.
The same argument suggests that Apple writing OS X (instead of
sticking with or the previous OS 9) was a waste of effort.  Yet that
turned out to be a critical and important part of their longterm
strategy.

> 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.

The best we can do is to continue working to improve the situation in
whatever little ways we can.

William

--~--~---------~--~----~------------~-------~--~----~
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
-~----------~----~----~----~------~----~------~--~---

Reply via email to