Meta-Browsing on Existing Systems

[Joseph Bowers]

Excuse me for excessive quoting here.....

Marc Santoro:
>   The Web is currently inadequate for any kind of meta-browsing. Content
>on the Web is almost completely static, and when it is not static, it is
>highly restricted and nigh-unusable. CGI allows the browser to see only
>what the script author had the foresight to program. In order for a CGI to
>allow meta-browsing, it would have to be so extremely complex, that it
>would be very difficult to learn to use. XML and DHTML are some
>interesting ideas. However, they are designed more to enhance HTML pages
>than to allow a true meta-browsing system. A page using HTML is still a
>linear page.

>   To be truly useful, our system needs to present information in the form
>of meaningful objects that can be interacted with. These objects not only
>need to interact with the user, but they should also be able to interact
>with eachother. Obviously HTML is useless because it allows no real
>interactivity. XML is useful, but it is still very limiting. XML is still
>a markup language, so we can define structured documents, but the browser
>is still limited to what the author wrote in his document. The reader does
>not get the full benefit of the authors knowledge, nor his own ability at
>processing information.

>   The problem with the current markup languages comes down to one simple
>point. They can't be arbitrarily interacted with by the user or the
>system. With meta-browsing, the system should be able to interact with the
>document natively. The document, at the very least, could be composed of
>objects that can respond to messages. These objects can reply with data,
>or could be a working example of the concept being described. And ideally,
>the objects should be a union of the two. The user could then browse these
>objects as he desires, and these objects could interact with each other to
>present the user with related information on what the he wants to see.

Here's where I have to differ. I hate to start web-buzzwording here, 
but I think the current w3 recommendations (XML/DOM) might be close to 
what you're looking for, or at least form a bridge between:

1) Static data that it is very difficult to decompose, gather
information
about, compose with other data, or change in a predictable way
(HTML, a paperback novel) and

2) Objects that can be queried, composed, cloned, and manipulated like
any other objects- you just got them (or probably copies of them, or
maybe proxies to them) from a remote source.

What this stuff proposes to do (if my understanding is correct, and it
may not be) is to

1) Define a pretty huge class of data- that is, anything that can be
represented by an Entity->Attribute relationship

2) Define an object model that isn't bound to any particular language or
platform that can be used to query, mutate, compose and decompose data
of 
the above type

3) Encourage users to compose these objects (because now they are
objects) in
such a way that, even if they expect them to be used and interpreted in
a certain
fashion (in a web browser, say) still allows them, or pieces of them, to
be 
meaningful in other, unpredictable environments and gracefully accept 
unexpected changes from unexpected sources.

As ambitious as the above is, they seem to be doing a pretty good job of
it, too!
XML is not perfect, but it is easy to parse, transformable, and pretty
expressive
for things that can be represented hierarchically (which are a lot of
things)
and the Document Object Model allows us to query a minimal interface on
all of
those things. 

Which brings me, finally, maybe, back on topic:

>XML is useful, but it is still very limiting. XML is still
>a markup language, so we can define structured documents,but the browser
>is still limited to what the author wrote in his document. The reader does
>not get the full benefit of the authors knowledge, nor his own ability at
>processing information.

We are not, in fact, limited to what the author wrote in their
document anymore than we are limited to what data is contained in our
object.
Admittedly, XML is not going to prevent people from not giving us enough
information just as an expressive programming language won't prevent you
from writing brittle code, but the possibilities are there to allow the
author
to index and describe their works, or (drumroll) others to describe
their work
regardless of the author's descriptions! Consider RDF. Using RDF, you
can link an XML document with 'something else' in a way that describes
their relationship (RDF, which looks a lot like the 'semantic network
databases' of old!) here is a system explicitly built for Meta-Browsing! 

Likewise, I can create XML documents that embed or inherit from other
resources, adding descriptions where the author neglected to, creating
collections and introducing information about context that may not be
meaningful to anyone accept myself, even overriding or discarding
authorial properties of this object, which is representable via Tunes
HLL!

That's the blue-sky of it, at any rate.

The reality of it is that each of these capabilities need to be written
into any
agent/consumer environment, and every XML namespace that comes down the
block must also be provided for, but that's not as hard as it could be
and getting easier
as namespaces allow us to create schema that are 'almost like' one you
use already.

Anyway, this stuff:

1) Is Pretty keen
2) Can serve the purposes described by 'Metabrowsing'

sorry for the sales pitch,
joe bowers jbowers@perspex.com