The suggested format is RDF/XML, mostly for simplicity and performance reasons. Implementing the Dublin Core as a separate URL means that WikiEngines don't have to do expensive history lookups each time a page is served, but only when the metadata is explicitly requested.
RDF for the Dublin Core data can be generated dynamically from the WikiEngine, just like any other data. It's just a different format.
On the displaying a Wiki page, an HTML <link> element can be used to point to the URL that will generate the metadata, like so:
<link rel="meta" href="http://wiki.example.com/ExamplePage?action=dc" />
This is the current recommendation for Dublin Core in RDF.
It has the advantage of being DTD-validatable, and being a full recommendation, but the disadvantage that some qualifications to the elements aren't present.
The following are some suggestions for what to assign to the elements of this encoding. Elements marked "ignore" should just be left out, unless there's special mechanisms in the Wiki engine to support them. (See DublinCore for a way to add special MetaData markup to a page.)
"Authorship", in wiki, is a difficult subject. Dublin Core differentiates between creators and contributors. There are several ways to map wiki editing methods onto Dublin Core:
You can identify contributors and creators a few ways. One is to use spaced-out versions of their user name: "EvanProdromou" -> "Evan Prodromou". Another is to use an URL to their user page, as follows:
<dc:creator rdf:resource="http://wiki.example.com/EvanProdromou" />
It may be good to use the resource if a user page exists, and the spaced-out user name if not.
Anonymous editors should be identified as "Anonymous".
The following is a full example of the RDF output for an example wiki page:
<?xml version="1.0"?> <!DOCTYPE rdf:RDF PUBLIC "-//DUBLIN CORE//DCMES DTD 2002/07/31//EN http://dublincore.org/documents/2002/07/31/dcmes-xml/dcmes-xml-dtd.dtd"> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:dc ="http://purl.org/dc/elements/1.1/"> <rdf:Description rdf:about="http://wiki.example.com/ExamplePage"> <dc:title>ExamplePage</dc:title> <dc:creator rdf:resource="http://wiki.example.com/MaryFakename" /> <dc:subject>Example Page</dc:subject> <dc:publisher rdf:resource="http://wiki.example.com/ExampleWiki" /> <dc:contributor rdf:resource="http://wiki.example.com/BobMadeup" /> <dc:contributor rdf:resource="http://wiki.example.com/ZeldaErsatz" /> <dc:contributor>Danny Hasnopage</dc:contributor> <dc:contributor>Anonymous</dc:contributor> <dc:date>2003-08-04</dc:date> <dc:type>Text</dc:type> <dc:format>text/html</dc:format> <dc:identifier>http://wiki.example.com/ExamplePage?version=4</dc:identifier> <dc:source>http://wiki.example.com/ExamplePage?version=3</dc:source> <dc:language>en</dc:language> <dc:rights rdf:resource="http://www.dsl.org/copyleft/dsl.txt" /> </rdf:Description> </rdf:RDF>
The newer encoding for Dublin Core is here:
It enhances the simple Dublin Core encoding with some more specific terms. It's not DTD-validatable (but it does use an XML Schema), and it's only a proposed recommendation, not a full one. However, it's what Dublin Core uses for its own site, so maybe that's a good enough endorsement for now.
Qualified Dublin Core for wikis should use all of the above Dublin Core terms,in the principle of GradualDegradation?. It should add the following, also:
If historical versions of a page are directly navigable (like "http://wiki.example.com/ExampleWiki?version=2"), that page can/should have metadata, too. The simple stuff should be equivalent, but only include contributions up to the version shown. The qualified DC elements should be as follows:
If the Wiki engine provides information on links to and from the page, each may be added as <dcq:isReferencedBy> and <dcq:references> elements, respectively. This could be useful for building site maps, for example.
Some additional human-edited metadata can make the Dublin Core data here more complete. This is probably only useful for things that the Wiki engine can't figure out for itself; some metadata that may be useful:
Creative Commons has their own metadata standard almost but not quite identical to the Dublin Core one. It concentrates slightly more on licensing and digital rights.
There's not really much that needs to be changed for wiki that doesn't need to be changed for other Web resources. The above-defined DC elements should work well within the Creative Commons format.
[new]RecentChanges page (or relevant cluster) for dc:publisher.
[new]RecentChanges page is where changes are published, so it makes sense. (It also means separate communities using a DividedCommons will be distinguishable, but that's kind of theoretical right now.) I chose dc:subject for categories because it seemed to fit the description:
Subject And Keywords The topic of the content of the resource.
Equally, for dc:publisher:
Publisher An entity responsible for making the resource available Examples of a Publisher include a person, an organisation, or a service.
I'd call RC a service It seems to be the best - and only - place to put a page's cluster.
Well, if I had never heard of a wiki and it showed up in the metadata as a publisher, I'd like that URL to point to a page describing the wiki itself, not a page full of changes. A WikiNode page, or something like CommunityWiki or MeatballWiki. I guess I think RecentChanges is more of an insider's view of the wiki, not the FrontLawn.
[new] I don't understand this:
<dc:creator> -- the last editor of a page
The creator should be the First not the Last editor...
In the example, why are the values for dc:identifier and source not rdf:resources, as are dc:creator, publisher, creator, and rights?
Regarding Creative Commons metadata: it is not different than DC RDF. The former extends the latter. Take
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:dc ="http://purl.org/dc/elements/1.1/"> <rdf:Description rdf:about="http://wiki.example.com/ExamplePage"> <dc:title>ExamplePage</dc:title> </rdf:Description> </rdf:RDF>
which obtains the triple
http://wiki.example.com/ExamplePage http://purl.org/dc/elements/1.1/title "ExamplePage" .
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:dc ="http://purl.org/dc/elements/1.1/" xmlns:cc ="http://web.resource.org/cc/"> <cc:Work rdf:about="http://wiki.example.com/ExamplePage"> <dc:title>ExamplePage</dc:title> </cc:Work> </rdf:RDF>
which obtains the triples
http://wiki.example.com/ExamplePage http://www.w3.org/1999/02/22-rdf-syntax-ns#type http://web.resource.org/cc/Work . http://wiki.example.com/ExamplePage http://purl.org/dc/elements/1.1/title "ExamplePage" .
In other words, all that cc:Work does is add type information (that the subject is possibly a copyrightable work). This is a case where the RDF/XML encoding makes CC metadata appear annoyingly incompatible with DC though it is not.
To either of the above productions we can add
<dc:rights rdf:resource="http://example.com/licenses/foo" />
<cc:license rdf:resource="http://example.com/licenses/foo" />
Again, they look annoyingly different. However, the latter is just more precise. cc:license refines dc:rights (see the schema embedded in and linked to from http://web.resource.org/cc/). Admittedly this is a bit harder to deal with than the triple added by cc:Work -- an otherwise ignorant application would need to be rdf schema-aware to discover this.
I think cc:Work and cc:license ought to be used, though it isn't a tragedy if one just uses rdf:Description and dc:rights with a reference to a CC license URL where appropriate. It would be unfortunate to hand out separate DC and CC metadata as is contemplated at http://meta.wikipedia.org/wiki/RDF_metadata.
Wow, that's a lot to reply to. Let's see if I can take it bit by bit.
For identifier: I think the point of rdf:resource is to refer to some resource that contains the answer to the question. "Who is the creator of this page?" "The answer is here: http://wiki.example.com/Evan". But the identifier for a Web page isn't at the URL; it is the URL. So I think that the URL should stay content, not an rdf:resource.
As to the relationship between CC metadata and DC metadata: I think you may be mistaken as to the extensibility of Simple DC RDF/XML metadata. It's defined in a DTD, and doesn't leave much room to change the elements available. The Qualified DC RDF can be extended, but it's different.
I think it makes some sense to support both.
(Heh! That didn't turn out so bad after all.) B-)
A couple of issues, on review:
You're right about simple vs. qualified DC RDF/XML. I completely missed that the target is the former, though it's plain as day above. Oops. I guess I have two followup points then:
I have two motives:
Regarding identifier: I could swear there was a long discussion of this on http://www.jiscmail.ac.uk/lists/DC-USAGE.html though I can't find it now. Some DC list anyway. This is a confusing topic, but I'm pretty sure that the only difference between
<dc:identifier rdf:resource="http://example.com" />
is that the former value is a literal, while the latter is a URI. Again, looking at the triple produced in each case makes things clearer:
<> http://purl.org/dc/elements/1.1/identifier "http://example.com" .
<> http://purl.org/dc/elements/1.1/identifier http://example.com .
or to belabor the point even further, the former says that the current document has an idenfier which is some string, the latter that the current document has an identifier which is a URI, not that the identifier may be found at that URI.
Please disabuse me of any (quite likely) false notions.
I most willingly admit that my RDF/XML-fu is weak. But according to the RDF primer:
It says, in part:
However, later in the document, they use an URN (heh, gotta love URNs!) in an rdf:resource in dc:identifier. So, y'know, I could be reading this completely wrong.
OK, the Qualified Dublin Core definition does use <dc:identifier rdf:resource="URI" />. I'm really losing ground, here, I think.