Re: Library Standards and URIs

Ronald E. Daniel (
Tue, 3 Jan 1995 16:45:05 -0700

From: "Ronald E. Daniel" <>
Date: Tue, 3 Jan 1995 16:45:05 -0700
Message-Id: <>
Subject: Re: Library Standards and URIs

Larry Masinter sez:
| Naming each attribute *set* rather than each individual attribute will
| reduce the length to be something managable. It might be possible to
| also allow individual attributes to be named even if they don't occur
| in the overall set.
| <urc scheme="">
| <author>...</author>
| <title>...</title>
| <author scheme="">
| </author>
| </urc>

Terry Allen sez:
> This example seems to mix one overall scheme (here...) with
> a scheme local to an individual element (banana...).  Wouldn't
> it be better to offer instead only a choice of overall schemes,
> on the assumption that the components are defined by the overall
> scheme?

No, I think Larry's suggestion is the way to go. I think we want to be
able to specify a set of attributes, while being able to override that
on an attribute-by-attribute basis. In an earlier message I used
<subject> as an example of an element that cries out for that sort of

> If that's to be done in SGML (which I am not advocating), schemes
> with different URCs will have different allowable contents.  It is
> one of SGML's weaknesses that attributes can't affect content
> models (you can't say in the DTD that <urc scheme="foo"> shall
> contain only those elements allowed by scheme foo).  So a better
> approach (if SGML is really desired) would be to have one element
> for each flavor of URC:,, urc.banana.  Then
> in the DTD one could require that have only the 
> desired content.

This seems to point out our next area of discussion - the DTD and what
gets named by the URN in the tag.

The requirement that we be able to jam anything we want into a URC means
that even if we could, we wouldn't want to "say in the DTD that
<urc scheme="foo"> shall contain ONLY those elements allowed by scheme

<urc scheme="foo"> is supposed to tell us a few things. First, it
tells us if our code will know what to do with most of the tags it finds.
Second, it says that if we see a tag without a URN, handle it according to
the rules in "foo". If that tag doesn't appear in "foo" it is an error.
Tags that are not in the "foo" attribute set should have their own URN
to ensure uniqueness and to give us rules for processing them if we want
to. Typically we will ignore them.

Of course, this is almost, but not quite, what having a DTD is for. The
DTD is supposed to tell us what tags to expect and what their syntax will
be. Should we use the URN in a tag to name a DTD or DTD fragment? Not
exactly kosher SGML is it? Should we use a DTD to specify the attribute
set instead of <urc scheme="foo">? That would seem to require a pretty
capable SGML subsystem in anything that used URCs. Anyone got a third
(or fourth or ...) alternative?