William wrote:

>If it isn't too much trouble, if you have the time,
>could you consider posting a rough list of some
>of the factors that went into your decision, why you chose SAGE, how
>other competitors fared, and what isn't perfect yet about SAGE for
>your desired goals?  I know some of that  reasoning is in your
>paragraph above, but I'm sure there was much more that came into play.

The reasoning behind why I chose SAGE was heavily influenced by the
unusual nature of the degree program I teach in.  Our Computer
Engineering Technology degree is a hybrid degree which is half
computer science and half computer engineering with an overall
emphasis on application.  The program's faculty consist of 2 computer
scientists, 2 engineers and 1 technologist and the type of student
that the degree is designed to produce is a deep generalist.  I am the
technologist and this has placed me in a good position to observe both
the algorithm-oriented computer science approach and the
mathematics-oriented engineering approach to problem solving.

I observed that the engineering classes were using software like
MathCad and MatLab to great advantage but, after seeing how the CS
classes were solving problems using programming languages, tools like
MathCad and MatLab did not appear to have a general enough design to
me.  I eventually decided to try Mathematica because of its more
general design and in spite of the fact the engineers didn't quite
understand why I would choose it over a traditional
engineering-oriented software application :-)  I worked with
Mathematica for over 2 years and I liked its mathematics capabilities
and notebook user interface but I found its programming capabilities
to be somewhat awkward to use, especially when compared to the Python
we had started to use in some of our CS classes.  Beyond this, I am a
Linux user and many of our students are too.  I found that
Mathematica's support for Linux was fairly poor and I was constantly
running into issues that needed to be worked around or fixed.

When we began our distance learning initiative, we chose to base it on
open source software as much as possible and this is when I decided to
find an open source alternative to Mathmatica.  I think that most
people who are searching for mathematics software quickly find this
Comparison of Computer Algebra systems page and so did I:

http://en.wikipedia.org/wiki/Comparison_of_computer_algebra_systems

After eliminating all of the proprietary applications, the short-list
of applications I selected to evaluate consisted of Axiom, Mathomatic,
Maxima, SAGE, and Yacas.   At that time I was heavily influenced by
Mathamatica's GUI notebook front-end along with the GUI front-end of
applications like MathCad.  Therefore, I rated having a nice GUI
front-end high on my list of requirements when I evaluated each of the
applications on this list.  I eventually decided to move forward using
Maxima and Python running inside of TeXmacs and for a while I thought
I had found what I was looking for.  Maxima seemed like it was able to
handle most of my mathematics needs and Python was able to handle most
of the computing needs I had, even though I was only a newbie Python
developer at the time.  TeXmacs was also where I received experience
with the concept of wrapping a wide range of software tools in one
user interface and I liked the flexibility that this provided.  The
more I worked with TeXmacs, however, the more 'quirky' it began to
seem to me.  Beyond this, I began to want maxima and Python to be able
to work together more intimately than they were able to do within
TeXmacs.  I reluctantly decided that I needed to continue my search.

Fortunately for me, it was at this point that I experienced a kind of
revelation with respect to Python.  The language I had learned just
before Python was Java and I came to Java from C.  For me, Java opened
a whole new world of programming that I did not know existed before,
especially when I observed the way that computer scientists used it.
When I decided to learn Python, however, my experience with Java put
limits on what I expected Python to be capable of.  As I dug deeper
into Python, I started to see that Python was even more advanced than
Java than Java had been with C.  When I moved from C to Java, it felt
like I had moved from manually pounding nails with a hammer to using a
pneumatic nail gun.  As I started to grasp the amazing power that a
dynamic language like Python contains, however, it began to feel like
moving from nailing boards with a nail gun to pointing a magic wand
and having them appear in a board with no more effort than a flick of
the wrist.  As I began to study Python deeper and program in it more,
it felt like my mind was starting to light up and I began to think
about programming-based problem solving in a whole new way.  This was
the feeling that Python gave me when I started to see how to properly
use it.  I found myself wanting to enter this frame of mind more
frequently and to hold it for longer periods of time.  I also started
to become convinced that this was the kind of thinking that we should
be encouraging our students to embrace.

It was with this new perspective that I reevaluated the list of
mathematics applications I had compiled earlier and when I looked at
SAGE again, it was with new eyes.  Instead of Python being just a tool
among equals like it was in TeXmacs, in SAGE it was elevated to the
position of being the means of managing the enormous complexity
inherent in these other tools and enabling the power in them to be
made available in a way that seemed more natural and effective than
the other approaches that I had looked at.  I am also changing my
thinking on the worth of entering mathematics using a rich graphical
front-end vs. entering it using typed source code.  When I was using
Mathematica, I use to enter almost all of my input though the
graphical notebook front-end because I thought it was somehow superior
to entering input as ASCII text.  I continued this thinking while I
was using TeXmacs but as I have studied SAGE's documentation further,
and started to work with it more, I am beginning to form the opinion
that it is much more efficient to work at the Python source code level
because staying at the Python source code level tends to keeps one's
mind in the 'light up' state that I referred to earlier.  Therefore, I
went from thinking that the best approach for teaching newbies
mathematics software was to hide the source code as much as possible
behind a GUI front-end to coming up with a way to teach newbies how to
program as easily as possible so that they would be able to
effectively use a source code interface.

Anyway, I know this answer is somewhat abstract, but that is how I
made my decision :-)

As for what isn't perfect yet about SAGE itself for my desired goals,
I am still learning how to use SAGE properly ( and I am also still
learning how to use Python properly ) so I am not quite ready to
provide suggestions yet, but I will probably be coming up with some in
the future.  What I currently see a need for is a SAGE tutorial that
is targeted at the programmer/mathematics newbie.  I am going to try
to develop a tutorial like this but it would be helpful if I could
periodically ask some dumb questions on this email list about SAGE and
mathematics in general.

Thanks,

Ted

--~--~---------~--~----~------------~-------~--~----~
To post to this group, send email to [email protected]
To unsubscribe from this group, send email to [EMAIL PROTECTED]
For more options, visit this group at 
http://groups.google.com/group/sage-support
URLs: http://sage.math.washington.edu/sage/ and http://sage.scipy.org/sage/
-~----------~----~----~----~------~----~------~--~---

Reply via email to