Re: A WWW-annotation protocol (good ideas and bad ideas)

On Sun, 29 Aug 1999, Bjarni R. Einarsson wrote:
> Crit currently consists of 3 parts:
> 
> 	1) A database of annotations (which are just web pages).
> 	2) A database of links between web pages, including but not
> 	   limited to 1).
> 	3) A mediator which inserts information from 2) into the
> 	   web page which is requested by the client.
> 
> 2) can link together any two web pages - not just annotations stored
> by the Crit server.  Thus different Crit server link databases,
> instances of 2), can contain links to annotations stored anywhere
> online - including annotations stored by other Crit servers.

Correct on all counts.

> Currently Crit implements all these features in one integrated
> system, but that isn't required by the architecture - each item on
> the list could be implemented & run seperately.

Again correct.

> Also, the client is responsible for fetching each annotation itself.
> The mediator, 3), only provides information about where the
> annotations are, not what they actually say.  "Potato-filtering" is
> impossible, because the client fetches the annotations' content
> directly from the source.

Sorry, could you explain what you mean by "potato-filtering"?

> The client's experience, 3), can trivially be migrated to a local,
> user-run process, such as the the browser or the "local proxy" I
> proposed in an earlier message.  It depends only on communication
> with 2).

Yes, correct again.  It seems you've perfectly understood everything
about how Crit works!  This is good news to me.

> Also, this crit-based model for annotations leverages the current WWW
> infrastructure as much as possible.  The only new standards we really
> need would describe how the client communicates with the link server.
> This involves defining a file format (XML based?), selecting a
> transport/request method (HTTP/CGI?) and a fine-grained link format
> (Xpointers?).

Indeed, these three things had to be designed into Crit.

    File format: Crit has a file format -- an extremely simple one.

    Transport: Crit currently provides a simple CGI transport which
        is used by the "CritMap" application for making link maps.

    Fine-grained link format: Crit has one that was designed to be
        robust despite editing and backward-compatible with existing
        HTML links; see the draft RFC on the site.

To see all of these things in concert, try

    lynx -source 'http://crit.org/links.cgi/http://www.mozilla.org/?backward=1'


I should add one more thing about the fine-grained link format --
something that i wish i didn't have to say.  Unfortunately, the
XPointer specification, though at one point it seemed simple and
perhaps comprehensible, has only grown increasingly complicated
over the past year.  It seems to be a moving target -- every time
i go back and check on it, it seems to be based on a different
language.  It appears to have been thrown out and rewritten several
times -- and it still seems to be in flux.  The current draft is
nearly 90 kilobytes in length, and appears to depend on another
entity, the XPath, whose specification is over 100 kilobytes long.

Crit was designed and implemented before XLink and XPointer existed.
The draft RFC for its syntax is only about 13 kilobytes.  The syntax
is so simple that you could look at a URL and guess what it means.

    http://crit.org/http://crit.org/draft-yee-url-textsearch-00.txt

Yet, the last time i checked, the enormous XPointer syntax was still
incapable of doing the simple and essential thing that the Crit
syntax does: word-by-word string comparisons.  Wayne Gramlich and i
have repeatedly requested that the string match operator disregard
whitespace and/or punctuation and we have been ignored.  Until it
can do this very simple and straightforward task, i am skeptical of
XPointer's suitability for annotations.

I really hope that this gets fixed in XPointer, and that somehow,
somewhere, someone takes a minimalist's perspective on the XPointer
standard and whittles it down so that ordinary people can grasp the
whole thing and actually use it effectively.

I am *not* claiming that Crit's link syntax is the ideal design.  I'm
sure one could do better.  But it works, and it's been doing the job
fine for two years while people have been arguing academic issues
about XPointer behind closed doors!  Nothing will ever happen until
people get out of the meeting room and get off their butts and write
code -- and i'm afraid we won't see open implementations for it in
browsers if it stays that complicated.



-- ?!ng

"Happiness isn't something you experience; it's something you remember."
    -- Oscar Levant

Received on Monday, 30 August 1999 03:21:13 UTC