Hollywood said:
Thats not to say that you should not attempt to have one model or format that is easily exchangeable without the need for unecessary formats.
If you wish to attempt to create a common model to exchange data between all possible applications without a) knowing what those applications are or may be and b) knowing how the data needs to be used from the applications POV, then I wish you luck.
It seems I've been over this a million times, I may have to start a FAQ-- the point of using XML with XSD is that each application can create a
namespace which basically dictates how the data can be used. This eliminates the need for "common" formats (in the scope of "general" or "universal"). I'm not sure what you mean by "unnecessary formats". An application requires what it requires as the programmer specifies. So what may seem inappropriate to one application may be required by another.
The point of having a common format is to cut down on time necessary to use application A with application B's character data. Common format means both can easily use the same data format for the same data. This relieves the burden of the developers of applications A and B from needing to do transforms to convert the character data from B for use in A or from A for use in B. These are simple concepts, and these are the reasons that there are plenty of data standards out there.
There are many reasons standards evolve. Just because a "common" format exists does not mean it is a "standard." I think it would be better for this conversation if you differentiate between the two.
There is no proof to suggest that having a common format relieves the burden of application development. In some cases it may make it more difficult. If, for example, you consider HTML to be a "common format" then consider what happens when different vendors introduce, or "extend" that common format, or decide to process that format differently, which has been the case of CSS.
Standards evolve from these "common formats" only after the needs of the many are evaluated, not before. How do you enforce a standard? You don't. It
becomes. That's why the W3 produces
recommendations, not standards.
And besides, what you had to say invalidates the need for your d20-exchange, because there is nothing to exchange. Everyone has their own proprietary format that they use and exchange is done by each developer transforming other developer's proprietary formats into their own proprietary formats. How archaic.
All data formats are proprietary. You're suggesting that there be a common format for (something) which would make it proprietary.
What if you could take proprietary data from one source and mix it with another? This is perfectly legal within the scope of XML.
I'm not sure what you mean by "nothing to exchange." Of course there's data to be exchanged. If PCGen created its own namespace, for example, data used in one application could simply be
extended to include the necessary PCGen data without breaking the original application. Consider this markup:
<abilities>
<dnd:strength>10</dnd:strength>
<d20:luck>12</d20:luck>
<app
i>x+y</app
i>
<abilities>
Here, a character has been created using the ability "strength" taken from a
dnd namespace, the ability "luck" taken from a
d20 namespace, and the
app namespace has an included processing instruction. All of this merged from an application or XSL stylesheet. Involved, yes, but not rocket science. And certainly more flexible than a "common" format. Once again, just using it how it was intended to be used.
Also, the above example demonstrates there's no need for a "common" format. Anyone can define a namespace and declare datatypes in an XSD, which can then be used by any application or any person marking up data. So the data formats reflect the real-world counterparts (D&D specific rules stick with D&D specifics, etc.) and there's no confusion as to how the data should be validated--because it's in the namespace.
There seems to be a misunderstanding on how namespaces are used and what that means in terms of data exchange and how data can be extended without creating arbitrary generalizations which a "common" format would have to produce. I started d20-dataExchange to get away from that school of thought.
Before you start working on your "common" data format, you might want to investigate the power of XSD and how namespaces work. It might change the way you think about exchanging data.
Regards,
/johnny
