Lists Home |
Date Index |
Jonathan Borden wrote:
> With respect to composing schemas from multiple namespaces, a use case I
> considered was when a schema refers to a type e.g.
> <xsd:element name="this:foo" type="that:bar"/>
> the idea is that the "that:bar" type might be imported from the schema which
> _is obtained_ via the namespace URI associated with the "that" prefix.
_is obtained_ by whom? If software, then the document format should look
like one thing. If by a human being, then the document format should
look like another thing.
Why wouldn't the author (human being) go to the HTML or RDDL page,
scroll around looking at the list of schemas, find the one that is
appropriate and paste it into an INCLUDE. I think we all agree that it
is not safe to let the computer just choose a schema out of the RDDL.
> Without RDDL at the end of the namespace URI, there would be a strong
> temptation to place an XML Schema directly there.
XHTML or Docbook could go there.
> There are other examples where it is useful to associate namespace URIs with
> resources. This sort of thing appears very clearcut to me.
I don't think this first case is as useful as you say so I probably
won't see the rest as clearcut either. The only reason it is a problem
is because people will believe that the "right way" to build schemas (or
stylesheets) is to build them for namespaces, not document types, and
have software compose them dynamically. This will cause them serious
pain and anguish until they figure out that it doesn't really work in
Here's my model for thinking about namespaces. You figure out the
"controlling" namespace. Usually this is the one on the root element but
not always. You hand the document to a processor that knows how to
handle that data. It does some arbitrary rewriting of the data that
conforms to another namespace. THEN, it OPTIONALLY hands the rewritten
data to a processor that knows only about the inner namespace...and so
The problem with trying to find schemas and stylesheets at a namespace
URI is that there is no way for a piece of software like a schema engine
or a stylesheet engine to know a) what rewriting is appropriate and b)
whether the outer namespace even intends to use the inner namespace in
accordance with its schema and associated stylesheets.