Writing a common lisp system in python would solve your problem and be
more feasible, in my opinion.

If you want to write a program to do 80-90 percent of freshman
calculus problems, copy the program
in Norvig's book which implements the derivative-divides method (and
is based on a program I wrote
with a student).  It is often the case that one can, with only 10% of
the code, solve over 80% of the
problems by using fairly weak methods.

William Stein said..

I so wish the years of use that Maxima has seen meant it were nearly
bug free.    I certainly don't mean to ignore bugs and code quality in
this discussion.

...
Writing new python code might be beneficial in eliminating some sorts
of bugs, but if the code were
constructed by copying each subroutine from lisp into python, it would
probably have many of the
same bugs, and likely would have more, unless that top-10 python coder
were also extremely good
at reading Lisp.

Writing new python code from scratch, reading the literature would be
another approach, but not
likely to produce good programs.  A friend once compared programming
to making waffles.
The first one never looks right.

As for what percentage of users of Sage use it essentially as a front
end to access Maxima's calculus program vs. (say) other material that
is not encountered short of graduate-school math, I suggest you try to
gather some statistics.

When I was running a table-lookup integration program on the internet,
I was surprised by what percentage of the inquiries were syntactic
nonsense, and of those that were syntactically acceptable, how many of
them were sin(x).
The world out there is very different from the world I expected with
respect to mathematical interests and sophistication.

As an alternative feasibility proposal, I have, from time to time
suggested that the core part of Maple, that implements its programming
language, be implemented in Lisp.  Then all the programs written in
the Maple language could be freely executed within a Lisp
environment.  (Naturally this would require a Maple license).  But
programs written natively in Lisp could interoperate somewhat with
Maple programs. Also Maple language programs might be compiled to Lisp
and to assembler. Also Maple would be able to benefit from the
(possibly better) implementation of garbage collection in a good Lisp.
Also Maple would (except for front end) run on all computers running
the same Lisp, reducing the effort of the Maple people.    You might
consider rewriting that core in Python, though it would not absolve
you of licensing issues, it might
be fun to load all of Maple into Sage to see what it could do.

Rewriting Sage in Lisp is like the algorithm for removing a chocolate
stain from your clothes. The final step, if nothing you have tried
removes the chocolate, consider dunking the entire garment in melted
chocolate and turning it all into chocolate color.

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

Reply via email to