[
Lists Home |
Date Index |
Thread Index
]
I've spent too much time lately thinking about why I'm generally unhappy
with the direction that a lot of markup work is headed at present, and
about why things like XHTML 2.0 or RELAX NG make me much happier than
things like RDF or WXS.
The general answer - though one that I recognize probably isn't perfect
- is that I'm far more comfortable working with patterns than working
with identifiers. That's not to say I don't want to use identifiers -
names and labels are a critical part of the patterns I find useful, but
I tend to find them useful in context. Single identifers are easy to
fit into patterns, especially if (as with URLs) there's a clear use
pattern that makes it easier to make them concrete, but layers of
identifiers quickly become a barrier.
I don't find notions of abstract identifiers meaningful or particularly
useful. I suspect that a fondness for such identifiers is a key factor
in distinguishing high-end programmers, logicians, and mathematicians
from the general public, and that those communities eventually lose
track of the fact that what is easy for them is not necessarily easy for
the rest of us. (How long does it take for the average person to figure
out passing-by-reference vs. passing-by-value? It took me a couple of
years to be genuinely comfortable with it.)
My suspicion, after working with Ool [1] and out-of-line markup, is that
markup works because it lets people describe patterns (labeled
structures) in their content directly. They can see the patterns they
create directly, with no need to keep a mental list of which pointer
goes where. Containment is explicit, not controlled by a separate table
of pointers that requires maintenance.
Some markup technologies have taken advantage of this pattern-nature to
create useful tools that are reasonably accessible. XPath does this, at
least in its simpler forms. RELAX NG, especially in its non-XML form,
is also very easy to read as a set of patterns.
Other markup technologies seem to have gone toward the identifier-style
approach. Namespaces in XML uses both abstract identifiers (URIs) and a
scoped mapping approach that requires people working with documents to
keep track of which identifier they're using when. W3C XML Schema
supports the creation of - and extension and restriction of - types
(separate from the concrete element/attribute vocabulary) which require
a lot of tracking to get right. RDF appears to go furthest with this,
to the point that I'm not really sure how to use RDF to apply metadata
to a concrete representation of a resource rather than the abstract
resource itself - but it may just be that I can't follow the long chain
of identifiers. QNames are another catastrophe in this ongoing saga.
I've been worried for a long time that the W3C is badly tilted toward
developing specs that work on formal models of identifiers rather than
with patterns. This is a lot of why I talk about things like the W3C
and RDF inflicting "URI-poisoning" on XML or programmers causing as many
problems as they solve because of a dangerously different perspective on
information. The continuing dominance of those groups in markup
technologies is why I presently see little hope for improvement in XML
as maintained by the W3C. (At this point, I wouldn't be averse to
shutting down the XML activity in order to prevent additional damage.)
(The groups focused on maintaining and creating specific vocabularies
seem to do better, fortunately, though they have an awful lot to cope
with.)
[1] - http://simonstl.com/projects/ool/
-------------
Simon St.Laurent - SSL is my TLA
http://simonstl.com may be my URI
http://monasticxml.org may be my ascetic URI
urn:oid:1.3.6.1.4.1.6320 is another possibility altogether
|
