Update on MINSE
First let me say that i'm very glad to have the opportunity
to be working with such a distinguished group of people
on something so significant.
Here is the update: an operational renderer to text
is now available on the site
You can now insert expressions into your documents
once, and expect them to be appropriately rendered
for both graphical and text-based browsers.
The more i look at the problem and think about what this
group has discussed, the more similar our approaches seem,
and the more it appears to me that MINSE might actually be
very close to what we want.
Its lexical analyzer is very similar to the one proposed
by Dave Raggett in . The parse trees are represented
in a LISP-like fashion, similar to the way it looks like
this group has been thinking about them. The only major
conceptual difference is that MINSE aims to be less math-
specific, and separates the notation definition from the
style definition. It also has a ready-to-use extension
language -- Python. (Python can be told to run modules
in restricted execution environments if were are downloading
styles and notations off the Web.)
I hope to have downloadable extensions working quite soon.
The text renderer is already implemented as a separate
The current implementation of MINSE is lacking with respect
to some of the thoughts of this group in the following ways:
- It doesn't do generalized template matching. It
just deals with operators, but you can define whatever
operators you want. Allowing template rules causes
problems with cascading notation definitions, as i
mentioned in the message about parsing.
- It doesn't do macro expansion (yet), but this will be
- There isn't a way of directly representing operations
performed upon operators. I believe the way to do this
would be to allow, in the internal representation,
lists as well as atoms to take the first position in
a list. I think it is quite feasible; a possible way
to add this to the syntax is to write .(sum;n) to
qualify the addition operator with the letter n, for
example -- this is natural because the period is used
currently to introduce operators.
Is operator-operator binding something that will ever
need to be carried to an indefinitely deep level?
As in operating on operators the operate on operators
that ... etc.
- You can't redefine what parentheses do. This may be
possible to change if template matching is added;
however, i think it's probably a good thing to have
some elements of fixed syntax. Grouping and argument
collection are quite basic, and it is possible to
express everything you need without redefining what
parentheses do. If you want an open or a closed
interval, just use a compound.
On the whole, i think that these aren't very serious flaws;
it also has the advantage, of course, that the implementation
exists at all. Interest is gathering among educators on the
Net. I think it is a reasonable place to start.
In any case, i shall proceed to brace myself for criticism.
Thanks for reading,