Worksheet interface

[Nils Barth <nbarth@fas.harvard.edu>]

One interface that several general math applications use is a
``worksheet'' (Maple's name) or ``notebook'' (Mathematica) interface.
Including the aforementioned program, I think MathCAD uses it too.

Worksheet is the better term, since it's basically one electronic sheet.

a screenshot of Mathematica's idea of a notebook is available at:
http://www.fas.harvard.edu/~nbarth/mathematica_screen_shot.png
the following discussion is easier to follow with the picture as a
companion.
Sorry I don't have screenshots of other applications -- I don't think
Maple has an X interface (or at least our distribution doesn't) and I
don't want to do screen-capture on windoze. Suffice to say that it
looks like Mathematica only uglier.
We don't have a license for MathCAD around here, and non-free software
people are pretty stingy with screenshots (probably 'cause they're
usually ugly). It looks vaguely similar to the above, as far as I can see.

Basically, a worksheet interface means:
* a hierarchically structured document
* mixed data types in one document
* execution blocks can be inserted/executed in any position

In more detail:
Note the layers of right braces in the shot. The rightmost is for the
worksheet (redundant? maybe a ``notebook'' can have several
independent worksheets), the next one is for the title block, text
block, or execution block. Within an execution block is the input,
possible error, possible graphics, output.

There are several data types in the document, the most spectacular of
which is the inline graphic. Also the inline equations/output (note
the integral and Pi). Mathematical also has primitive stylesheet
support, so you can change formating for assorted text (basically,
change font (including color), background, justification, and
boxing/frames -- would you like more screenshots/examples?)

``Out of order'' execution ;-)
Basically, you can insert a new block between any two blocks (text
blocks, execution blocks, etc.) If you insert an execution block and
execute it, then it runs with the existing context. So...
if I execute x=3 at the bottom of the page, then delete it, go to the
top of the page, and execute x+1, I'll get 4.
This has the problem that (if abused), it can make the current
state/context unclear, and the flow of execution/reasoning very
tortuous; this doesn't happen too often in practice, and if we want,
we could add an option to only allow insertion at the end of the
document (maybe useful for students?).


What I'm suggesting is:
* I think a worksheet-style interface would be a welcome addition to
  Dr. Genius, and not too hard to implement.
* A worksheet-type thing would likely make for a good approach to a
  general file-type/session log -- I think some XML type would be
  ideal.
  (though I'm not sure about graphics -- UUencode or some such? Is
  there a good XML solution to inline graphics, other than SVG?)
* Style-sheets should be CSS (if GNOME supports this) or XSL when it
  gets standardized/supported.
  We could hack a simple CSS parser if we get desperate, but I doubt
  that'll be necessary/useful. Stylesheet are not a high priority, but
  they should be easy to integrate later.
* The canvas could probably do any rendering easily; I'm not familiar
  with implementation details, but this looks really easy with the
  GNOME framework.
* A worksheet should NOT be the only document type; you'll often want
  a graphic or geometry object in a separate window. Basically we
  could just add: New->Worksheet
* Once we get an equation editor component, we can integrate that for
  graphical equation entry.
* We do not need to be bound by specifics of this implementation; I
  show it only as a starting point.

Last note: Mathematica also retains the console interface, as we do
via the genius executable. This is definitely a Good Idea (TM).
Worksheets are basically a really nice UI feature, but don't add any
essential functionality.

So. . .anyone interested in this?

-- 
  -nils