(no subject)

[Brian P Templeton]

Kevin Holmes <kholmes@localhost.localdomain> writes:

> From: Kevin Holmes <kholmes@localhost.localdomain>
> To: tunes@tunes.org
> Subject: Re: Mox
> Reply-To: kholmes@sedona.net
>=20
> Brian P Templeton bpt@tunes.org wrote:
>=20
>=20
>> environment in other languages, except that instead of being a
>> mapping between symbols and objects, it is simply a collection of
>> objects, internally identified by a tumbler (a word borrowed from
>> Xanadu) - though I may change `tumbler' to something else, since I
>> don't really know what would be like in Xanadu other than being of
>> the form 0.x.y.z (I could probably do some research on it, though).
>=20
> Can you provide a link or explanation on what a tumbler is?
>=20
Hmm. I think <URL:http://www.sunless-sea.net/> may have some
information, and you can probably google for something like "Xanadu
tumbler" to get some information.

(Of course, the Xanadu books (_Literary Machines_ and the out-of-print
_Computer Lib_, both by Ted Nelson) should have some information, but
I haven't read them yet, so I'm not sure.)

>> In MOX, source code is merely a sequence of arrows, possibly, e.g.
>> using the Lisp tradition of using lists to represent function
>> applications. However, there are *no symbols*. It will likely be
>> possible to attach a default label to an object, through hints, but
>> there is no particular reason why one must use labeled objects at all.
>> In fact, using hints, someone could implement, say, a system where
>> objects were identified by color (yes, that's probably a really stupid
>> idea, but there are most likely some interesting variations on it).
>=20
> Can you give more examples on how to reference an object without a symbol?
>=20
Quite simply, you use a reference (sort of like a locative)! Although
I am not sure what the exact semantics of 'verses and arrows are (for
example, how could something like `fluid-let' be implemented?), here's
a possible example:

    'verse 0:
        [...]
        99: function object: concat
        100: string object: "abc"
        101: string object: "def"
        [...]
    source code:
        [...]
        (#<arrow to object 99 of 'verse 0>
         #<arrow to object 100 of 'verse 0>
         #<arrow to object 101 of 'verse 0>)
        [...]

Note that the #<...> parts, the function name, parentheses,
double-quotes, etc are ONLY to make the example easier to read.

>> - Synopsis - MOX is based on a datastructure called an arrow (in
>> honor of Brian Rice's excellent Arrow system, which it seems that no
>> one other than he understands :)). Source is just a sequence of
>> arrows ``pointing'' to an object in a 'verse, which can orthogonally
>> or non-orthogonally make objects persistant, and [FIXME: is this a
>> good idea? - probably not] the same arrow will always point to the
>> same object, unless, perhaps, a hint is provided to the contrary. A
>> 'verse is a collection of objects. There are no symbols in MOX,
>> though they can be emulated.  MOX combines development and hypertext
>> in a somewhat novel way.
>=20
> Could you explain what a hint is and how it would be used? And how is
> hypertext involved?
>=20
Hints are sort of like Far=E9's annotations or CL's declarations.
Although I'm not sure whether they would store type information or not
(objects might turn out to be immutable with a versioning system), one
possible use would be to specify the canonical name of an object for
editors to display, etc.

The connection to hypertext is a very tangled one. First of all, a few
months ago (perhaps early last fall) I read ``As We May Think'' by
Vannevar Bush, leading me to re-investigate hypertext. Then I learned
about the Lisp Machines, and heard `locatives' mentioned a few times,
but with no explanations. I planned to write a system called eMUmex
that would be a sort of an implementation of Bush's memex device.
Directly following that I found out about LyX, and envisioned a
similar, but much better, system (in Emacs, actually) that would
simply convert LaTeX objects into widgets for editing them, and then
convert back when the buffer was saved. After that I learned about
Xanadu (well, I had read a bit about it a few years prior, but never
read much about it), and came up with a scheme where a hypertext
document would merely be a series of objects that would have editing
and viewing widgets provided by various environments (e.g. Emacs-like,
billowing, environments for blind users, etc), with associated hints
for, e.g., a pseudo-environment for hardcopy output to restrict the
width of a particular object to, say, 3 cm. Then I re-read the Arrow
papers (I don't really know much at all about category theory yet),
and learned what a locative was. Finally, I realized that, instead of
having reference/transclusion/... objects in hypertext documents, and
locatives in programs, why not combine the two into generalized arrows
(imagining a locative as simply being a conceptual `arrow' to
somewhere else was helpful here)?

Lately, I've also realized that my new activation/deactivation scheme
(analogous to quotation/evaluation in some ways) would /not only/
allow one to discard the concept of source code separate from objects
altogether and facilitate metaprogramming, but *also* allow both
transclusions and hyperlinks in hypertext documents, very easily!!

*whew* That was a long explanation, and I may have left out a part, so
 please inform me if I've skipped anything.

> Best Regards,
> Kevin Holmes
>=20

Regards,
--=20
BPT <bpt@tunes.org>	    		/"\ ASCII Ribbon Campaign
backronym for Linux:			\ / No HTML or RTF in mail
	Linux Is Not Unix			 X  No MS-Word in mail
Meme plague ;)   --------->		/ \ Respect Open Standards