Tunes Concept of the Week

[Chris Harris]

Hello All --

This list has seemed awefully quite this past month.  I hope I've made
some mistake and accidentally unsubscribed myself...because otherwise,
it would seem that Tunes is most certainly dead in its tracks.  If the
list has been busy as of late, please let me know so that I can check up
on the idea that I really am unsubscribed....

What I wanted to suggest to you all was an extension to our idea that
users and programmers are no different: that users and _programs_ are
also really not that different.  The basis for this idea is really very
simple; recently, I've found two incredibly useful, free pieces of
software, mSql, a relational database, and MuPAD, a symbolic algebraic
manipulation program, that seem to do what they intend to do very well.
Both are well-written, and I am quite impressed by their quality
considering the fact that they are free.  However, I see a fundamental
limitation that affects each of them, and that would also affect any
commercial counterparts: although I can easily use both programs
interactively, utilizing their functionality from within another program
is either impossible or much too difficult.  With MuPAD, in particular,
there is no API, even, to allow other programs to manipulate algebra
within the algebra system from the outside.

This inability to utilize easily one program from within another is a
problem to me because it, essentially, wastes the effort put into
writing each application.  If I have MuPAD, a program that manipulates
simbolic algebra with great accuracy and speed, installed, why, if I
wanted a small application I was working on to perform one or two
algebraic problems, should I have to write my own symbolic algebra
functions instead of utilizing those already existant in MuPAD?  I
realize that things must be the way they are with languages, compilers
and operating systems as they are, but Tunes must do better.

In Tunes, let us not write applications, which perform a set of tasks in
a straight, linear manner, but "packages", which extend the "basic
system" by making availible additional types, editors with which a human
can modify and examine the values of data of these types, and functions
to work on these types, to the system at large.  I see the Tunes version
of MuPAD not as a program that continually reads user input and then
calculates the result of the functions typed in, but an equasion type,
an arbitrary-precision number type, a polynomal type, and the functions,
such as solve(), that are useful for working on these types.  If this
were the case, I could create and solve equasions not only from within
the MuPAD application, but from within any application, and also from
within any programmable shell.  Functions would exist to perform such
tasks as converting the internal representation of an equasion into a
human-readable string, and editors would exist so that I could exter
equasions either graphically or textually (or via voice microphone or
...)  Any program or any user could manipulate any algebraic experssion
at any time.

With this system, any "user" could perform any task normally reserved
for "programmers", and any "program" could perform tasks normally
reserved for "users".  The system, Tunes, becomes one large, integrated,
flexible environment in which the value of each tool is exponentially
increased by the ease with which it can connect to all other tools.

Am I making sense?  Do others of you have similar thoughts?  Comments?
How can we make this vision -- and the whole Tunes vision -- come to be
before we're all 90 years old and running out of steam? 

-Chris

P.S. I've leaving in about 10 days for a six week bike trip to Portugal.
This won't really affect Tunes, as I'm basically sitting idle at the
moment in relation to this project, but if any of you curious where I am
in a bit, you'll now know.