W3C home > Mailing lists > Public > w3c-sgml-wg@w3.org > June 1997

Namespaces, the universe, and everything

From: Tim Bray <tbray@textuality.com>
Date: Thu, 19 Jun 1997 09:54:19 -0700
Message-Id: <3.0.32.19970619095106.00a5b620@pop.intergate.bc.ca>
To: w3c-sgml-wg@w3.org
This discussion continues to be useful, if a bit theological in its
flavour now and again.  I'd like to address these issues:

1. Why namespaces anyhow
2. Web engineering perceptions
3. Validation, DTDs, and schemata

1. Why namespaces anyhow

Here's the canonical scenario that I think we're trying to make possible.
People want to stick together a chunk of XML that gives a PICS rating, 
another one that applies some Dewey Decimal classifications, another one 
that explains copyright status, pack them up with a chunk of content 
(HTML for now, but soon XML), and jam the whole shooting match down the 
wire in one blob.  They want to do this ad-hoc.  

For one or more of these chunks, validity may be an issue.  For most of 
them, there will be a requirement to map them to a formal schema, which 
may or not be a DTD.  This compound blob will be well-formed but probably 
nobody cares if it's valid, as a whole, with respect to any particular 
DTD.  The goal is that you can cook up a chunk of meta-content, stick it 
at the front/end of the document, and somehow not worry about GI
collisions confusing a simple-minded app that is reading the 
transmission.  Probably there will be multiple independent downstream
apps, most of which care only about (a) the content or (b) one of the 
blocks of meta-content.

[corollary: this scenario *presupposes* that most web metacontent is going
 to have XML syntax, one way or another.  Smiles.]

2. Web community perceptions

I mentioned in an earlier note that the people who are our customers
for this facility are up to this point in time very hostile toward the
idea that we do it all with AFs (er, fixed attributes).  Said mention
drew down a storm of abuse, and as a result the first draft of this note
was very nasty.  My best friend walked by the computer, glanced at the
screen, and said "don't send that out tonight, OK?".  So I've confined
the nastiness to the following well-marked excursion:

<nasty>
 At 03:23 PM 18/06/97 -0500, David G. Durand wrote:
 >I don't think that it is a good idea to throw away what we know to be
 >useful (DTDs) based on so-called "massive resistance" from people who don't
 >know what they are talking about. 

Gimme a $#%!# break.  Uh, how many pieces of DTD-driven software were 
downloaded voluntarily and used on a daily basis by 50 million people 
because they like it and they get useful work done without training?  
In fact, I <gasp> happen to think that some of these Web guys actually 
do, on a regular basis, know what they are talking about, when they are 
on the subject of the kind of software that people like to use and 
developers like to interface to.   Fortunately for the AF partisans in 
this debate, people like Jean and Jon and myself are insulating 
the web engineers from the above kind of militant ignorance; which means 
that 8879 conformance, for the moment, still has a fighting chance.
Sheesh.
</nasty>

OK, let's try again.  I and Jean (and I'm sure Jon at Sun and Dave at 
HP etc etc etc) are  having a lot of trouble with really smart and really 
senior people who at the moment look at us like we're nuts when we try to 
convince them that Architectural Forms are a viable way to go, because 
they exist and are standardized, etc... especially because we *really* 
don't want them to go and look at the relevant standard, if they do we're
toast.  These people see what looks like a self-evident self-explanatory 
no-brainer syntax 

         <dc:name>

and say "why won't this work?", as opposed to

         <!ATTLIST AUTHOR DC NAME #FIXED "NAME">
         ...much later in the document, or maybe even a different entity... 
         <author>

Things they don't want to do include:
 1) loading up every element with form attributes, or
 2) figuring out, as they append successive chunks of XML, what things
    have to be surgically implanted in the internal subset to avoid
    problem #1, and
 3) ensuring each little lightweight application includes a DTD syntax 
    parser [yes, I know it's not that hard, I know first-hand, Lark 
    processes <!attlists from the internal subset precisely to support 
    constructions like the above, but they DON'T WANT TO and are going 
    to have to be given good solid reasons why they should].

What is the correct answer?  Saying "we know what we're talking about
and you don't" isn't good enough.  At the moment, I have not heard a
good enough argument to convince me that AFs are better for the
purpose described above than the colon syntax.

3. Validation, DTD's and schemata

The discussion has suffered a bit from the assumption that when we
say namespace or schema or whatever, this necessarily means we are 
tied to some DTD and we are worried about content models and the like.
A lot of the schemata that people want to write are concerned with
things that DTD's don't care about: data typing, domains and ranges
of properties, inheritance of one kind or another.  Yes DTDs are
schemata.  But the traditional SGML mind-set, that metadata means
markup declarations, and that markup declarations means a DTD, and
that the DTD must necessarily constrain the whole document from end
to end, just doesn't apply any more.  

The concept of "validity" in XML isn't going to go away, but it's going 
to be subsumed into the much larger concept of "piecewise conformant to 
the rules for the schemata that apply to various document components".  
Lots of applications that are very stringent about what their data can 
contain just don't care about, for example, content models.  Nobody is
trying to *discard* DTD's; we need more validation, not less.

It seems pretty clear that it's probably not realistic at this
point to extend the 8879 syntax in 8 different directions at once
to meet the needs of all the meta-content group requirements - so
for now we're preaching that they should at least use XML, not 
S-expressions or tab-delimited files or whatever other proprietary
weirdness they may have been considering.

Perhaps in a future revision process DTDs will transmogrify, and
son-of-8879 will have a much more ambitious world-view as to what
constitutes a markup declaration.  In the meantime, these guys are
convinced that they need namespaces and they need them well-defined
by Q4 '97, and we shouldn't tell them that they can't have them.
 -Tim
Received on Thursday, 19 June 1997 12:56:15 EDT

This archive was generated by hypermail pre-2.1.9 : Wednesday, 24 September 2003 10:04:41 EDT