Re: [xml-dev] Four fine text-based data formats ... liberate yourselffro

["Simon St.Laurent" <simonstl@simonstl.com>]

On 3/24/13 10:34 AM, Timothy W. Cook wrote:
> On Sun, Mar 24, 2013 at 9:54 AM, Costello, Roger L. <costello@mitre.org> wrote:
> Most of XML's advantages for creating such standards, most notably its
> endless obsession with schemas, turn out to be dead weight for private
> interchange applications.
>>
>> Comments?
 >
> I find this statement to be ... well; bizarre, I guess is the best word.

It may not fit in your neighborhood, but it explains much of why XML has 
failed to prosper in other neighborhoods.

(Verbosity is the other common explanation.)

> Can you possibly explain "how" this is true?

Sure.

XML, practically alone among recent technologies, reliably drives its 
users into a top-down "waterfall" model of development.

There is nothing about markup itself that requires that model - it is 
absolutely possible to iterate through different vocabularies, maintain 
variant structures for different use cases, and build software that 
manages to handle multiple versions of messages without massively 
redundant code.

The bottleneck is the XML community's strange worship of schemas.  The 
schema approach expects universal agreement among participants on data 
structures up front. The resulting culture has churned through endless 
design by committee mixed with efforts to get there first and force 
everyone to use schemas already tilted in one's preferred direction.

You certainly can use schemas in private interchange, but they tend to 
be far less intricate.  In cases where the same developer (or often 
firm) controls both ends of a conversation, they often don't even 
manifest themselves as more than notes or sketches in an object model.

If you love top-down development models and consider the architect the 
true creator of a project, by all means, please handcuff yourself to 
schemas.  There are certainly business cultures which refuse to consider 
any other model.

(There are other data approaches which proudly wear those handcuffs as 
well - ASN.1 is another classic, even more extreme.)

If you can, however, escape that approach.

* Stop expecting that everything important about a document will be 
known before it arrives.

* Plan to write code that you will extend over time to deal with 
variations.

* Communicate with other developers who use your information on a 
continuous (or at least regular) basis, rather than "once than done".

* Treat schemas as documentation rather than as a brittle home for your 
future code.

Yeah.  It's hard to imagine, and it's never going to appeal to control 
freaks.  Even among programmers, however, control freaks turn out to be 
only part of the crowd.

(And yes, I participated in the drive toward schemas long ago and didn't 
figure this out either until it was too late for our culture.  That is 
my primary regret about my time in the XML world.)

Thanks,
-- 
Simon St.Laurent
http://simonstl.com/