W3C home > Mailing lists > Public > www-rdf-interest@w3.org > April 2001

RE: Common Metadata (was:RE: RDF in XHTML)

From: Danny Ayers <danny@panlanka.net>
Date: Sat, 21 Apr 2001 08:10:53 +0600
To: "Gustaf Neumann" <neumann@wu-wien.ac.at>, "Brian McBride" <bwm@hplb.hpl.hp.com>
Cc: "RDFInterest" <www-rdf-interest@w3.org>
Message-ID: <EBEPLGMHCDOJJJPCFHEFOEDDDDAA.danny@panlanka.net>
Yep - while IRCing to Brian last night (through #rdfig - very useful) I
remembered DMOZ, which makes use of IDs and manages to contain metadata for
a *lot* of pages (example below). This is external to the page, and the info
relevant to a page is only a fragment, but the principle's ok. This could
easily be turned around and the keys placed in each individual doc.

Brian's opinion was that the place for something like sharing and/or
inheritance was a layer on top of RDF(S) - and now I'm tending to agree.

I do think it needs a bit of attention/thought though - it isn't an assured
thing that keys can be used in a similar was as in RDBMS, and even whether
this is the best way - you would still need a key reference in each doc's
metadata, which although considerably shorter than whatever the full
metadata fragment would be, still takes up space that would be saved using
some kind of implicit inheritance mechanism. I propose (keeping it concise)
:

danja:forFurtherInformationPleaseReferToTheDocumentIdentifiedAs


Cheers,
Danny.

DMOZ -

part of structure :

<Topic r:id="Top/Business">
  <tag catid="3"/>
  <d:Title>Business</d:Title>
  <narrow r:resource="Top/Business/Consulting"/>

part of content :

<Topic r:id="Top/Computers">
  <tag catid="4"/>
  <d:Title>Computers</d:Title>
  <link r:resource="http://www.cs.tcd.ie/FME/"/>
  <link
r:resource="http://pages.whowhere.com/computers/pnyhlen/Timeline.html"/>
</Topic>

<ExternalPage about="http://www.cs.tcd.ie/FME/">
  <d:Title>FME HUB</d:Title>
  <d:Description>Formal Methods Europe (FME) is a European organization
supported by the Commission of the European Union (via ESSI of the ESPRIT
programme), with the mission of         promoting and supporting the
industrial use of formal methods for computer systems
development.</d:Description>
</ExternalPage>


---
Danny Ayers
http://www.isacat.net

<- -----Original Message-----
<- From: www-rdf-interest-request@w3.org
<- [mailto:www-rdf-interest-request@w3.org]On Behalf Of Gustaf Neumann
<- Sent: 21 April 2001 03:00
<- To: Danny Ayers; Brian McBride
<- Cc: RDFInterest
<- Subject: Re: Common Metadata (was:RE: RDF in XHTML)
<-
<-
<- On Friday 20 April 2001 18:47, Danny Ayers wrote:
<- > Thanks for your reply, but I can't say that I'm particularly
<- reassured. You
<- > mention ways of possibly bending aboutEachPrefix and seeAlso
<- into use. You
<- > also give reasons why these aren't exactly ideal. You refer to
<- a syntactic
<- > include mechanism - have you got an existing one in mind, or woud this
<- > need, erm... including?
<- >
<- > Let me suggest another scenario - I have 10000 documents on
<- cheesemaking,
<- > 5000 of these are by the same author, 5000 by another, half of the
<- > documents are from one publisher half from another (not along
<- author lines
<- > or anything). You will surely agree that this metadata doesn't
<- represent
<- > much information. Ok, perhaps I could dynamically generate metadata,
<- > perhaps I could hack XSLT to do what I wanted. Or of course I
<- could repeat
<- > the same information 10000 times inline with all the documents.
<- >
<- > The model for what's ideally needed is multiple inheritance,
<- or at least
<- > something approaching this.
<-
<-  i believe that ***sharing*** of the information is the way to go.
<-  you will have a registry for a cheesmaker factory that produces
<-  something like
<-
<-   <Cheesmaker rdf:ID="cm999">
<-      <name>....</name>
<-      ...
<-   </Cheesmaker>
<-
<-  and you refer from the cheesmaker to the appropriate cheesmaker ID.
<-  this is similar to good old normalization and might require
<-  something like a JINI like service.
<-
<-  best regards
<- -gustaf
<-
<- > From what your saying there is no 'natural' way
<- > of doing this with RDF as it stands. If there might a relatively
<- > straightforward way using what's already available, all well and good,
<- > otherwise there's going to be some hassle not far down the
<- line. Is this
<- > deserving of a 'see also' at the bottom of the
<- rdfms-abouteachprefix issue?
<- > Maybe not. But I'm going to be looking at topic maps a bit more closely
<- > from now on...
<- >
<- > Cheers,
<- > Danny.
<- >
<- >
<- > ---
<- > Danny Ayers
<- > http://www.isacat.net
<- >
<- > <- -----Original Message-----
<- > <- From: Brian McBride [mailto:bwm@hplb.hpl.hp.com]
<- > <- Sent: 20 April 2001 21:45
<- > <- To: Danny Ayers
<- > <- Cc: Lee Jonas; Murray Altheim; RDFInterest
<- > <- Subject: Re: Common Metadata (was:RE: RDF in XHTML)
<- > <-
<- > <-
<- > <- Hi Danny,
<- > <-
<- > <- So the problem is, "How is common metadata to be represented in RDF
<- > <- XML?" and you give a good example.
<- > <-
<- > <- Two ideas have been suggested: using aboutEachPrefix and
<- using seeAlso.
<- > <-
<- > <- There is an issue listed regarding aboutEachPrefix:
<- > <-
<- > <-   http://www.w3.org/2000/03/rdf-tracking/#rdfms-abouteachprefix
<- > <-
<- > <- One of the problems is that aboutEachPrefix is described in
<- the syntax
<- > <- but is not described in the model.  This is pretty dodgy
<- ground at the
<- > <- moment because a lot of systems don't implement it.
<- > <-
<- > <- Even if one were to use aboutEachPrefix, where would the
<- XML for those
<- > <- statements be?  In a separate document?  How would a system
<- find that
<- > <- document, given one of your 1000 pages?
<- > <-
<- > <- Regarding seeAlso, the definition of seeAlso states:
<- > <-
<- > <-   The property rdfs:seeAlso specifies a resource that might provide
<- > <-   additional information about the subject resource.
<- > <-
<- > <- So an RDF processor is not required to follow the link, but
<- could do so.
<- > <- However, what do you put in the see also document?
<- > <-
<- > <-   <rdf:RDF>
<- > <-     <rdf:Description about="WHAT">
<- > <-       <dc:creator>foo bar</dc:creator>
<- > <-     </rdf:Description>
<- > <-   </rdf:RDF>
<- > <-
<- > <- The problem is that the value of the about attribute is absolute, it
<- > <- does not change its meaning depending on what link you
<- followed to get
<- > <- it.  So
<- > <- that doesn't seem to do what you need.
<- > <-
<- > <- A combination of seeAlso and aboutEachPrefix might do it.  Put the
<- > <- seeAlso in each document and use aboutEachPrefix in the 'see also'
<- > <- document.  But as I said, aboutEachPrefix is not widely implemented.
<- > <-
<- > <- A syntactic include mechanism might do what you are looking for.  It
<- > <- might then include say:
<- > <-
<- > <-   <rdf:RDF>
<- > <-     <rdf:Description rdf:about="">
<- > <-       <dc:creator>foo bar</dc:creator>
<- > <-     </rdf:Description>
<- > <-   </rdf:RDF>
<- > <-
<- > <- Note the rdf:about.  There are problems here.  First, a
<- robot finding
<- > <- the file to be included would see that it was created by
<- foo bar, which
<- > <- might well not be true.  Secondly, XML isn't too good at
<- being nested in
<- > <- other XML at the syntactic level because of issues with things like
<- > <- uniqueness of ID's and namespace prefix usage.
<- > <-
<- > <- However, for the range of things under your control, you
<- could arrange
<- > <- to
<- > <- do this with say, an XSLT transform, to insert the meta data
<- > <- automatically.  This is not really an RDF solution.  If I had an
<- > <- immediate problem, I think this is the way I'd go.
<- > <-
<- > <- In terms of the issue list, I suggest you have highlighted an aspect
<- > <- of the rdfms-abouteachprefix issue, and I'd propose to add
<- a reference
<- > <- to this thread under a 'see also' link under that issue.
<- > <-
<- > <- Brian
<- > <-
<- > <-
<- > <-
<- > <- Danny Ayers wrote:
<- > <- >
<- > <- > I can't see how RDF could be practical without some mechanism for
<- > <- > inherited/shared metadata (you've got a 1000 documents
<- with the same
<- > <- > author - do you need to specify this a 1000 times), but I'm
<- > <- thinking that
<- > <- > because this is so significant it must have been dealt
<- with already -
<- > <- > seeAlso doesn't really seem adequate, I'm not sure of the
<- history of
<- > <- > aboutEachPrefix, but surely there is already some mechanism in
<- > <- place? Lee's
<- > <- > xsl:include/import suggestion sounds possible. If this
<- angle is well
<- > <- > covered, an idiot's guide is needed (for this idiot at least),
<- > <- otherwise I
<- > <- > think it could well be an issue.
<- > <- >
<- > <- > ---
<- > <- > Danny Ayers
<- > <- > http://www.isacat.net
<- > <- >
<- > <- > <- -----Original Message-----
<- > <- > <- From: www-rdf-interest-request@w3.org
<- > <- > <- [mailto:www-rdf-interest-request@w3.org]On Behalf Of Lee Jonas
<- > <- > <- Sent: 20 April 2001 19:47
<- > <- > <- To: 'Danny Ayers'; Murray Altheim
<- > <- > <- Cc: RDFInterest
<- > <- > <- Subject: RE: RDF in XHTML
<- > <- > <-
<- > <- > <-
<- > <- > <-
<- > <- > <-
<- > <- > <- Danny Ayers [mailto:danny@panlanka.net] wrote:
<- > <- > <-
<- > <- > <- ><- The RDF Schema spec hints at 'rdfs:seeAlso' for
<- > <- cascading purposes,
<- > <- > <- e.g.:
<- > <- > <- ><-
<- > <- > <- ><- <rdf:RDF ...(namespaces)...>
<- > <- > <- ><-  <rdf:Description rdf:about=""
<- rdfs:seeAlso="furtherinfo.rdf"/>
<- > <- > <- ><- </rdf:RDF>
<- > <- > <- >
<- > <- > <- >Looks viable - I wonder if there's anything more than hints
<- > <- > <- >this is rather important, probably well known (but I can't
<- > <- > <- think of it) -
<- > <- > <- >what is the best way to use inheritance of metadata
<- > <- between documents?
<- > <- > <- >How do I avoid adding the same author information to every
<- > <- one of the
<- > <- > <- >million pages I've written (with the aid of some monkeys)?
<- > <- > <- >
<- > <- > <-
<- > <- > <- Well, this is an entirely different prospect, and one I
<- > <- think that the
<- > <- > <- 'rdf:aboutEachPrefix' predicate was intended to address.
<- > <- > <- However, AFAIK it
<- > <- > <- has a lot of opposition due to the fact that it is difficult to
<- > <- > <- implement in
<- > <- > <- practise, e.g.:
<- > <- > <-
<- > <- > <- 1) Consider starting with a resource and trying to
<- determine who
<- > <- > <- the author
<- > <- > <- was.  If this info is in a 'rdf:aboutEachPrefix' statement in
<- > <- > <- some other rdf
<- > <- > <- doc, not even referenced from the resource you are currently
<- > <- > <- processing, it
<- > <- > <- is nigh on impossible to determine.
<- > <- > <-
<- > <- > <- 2) It relies upon the hierarchical location of resource
<- > <- representations -
<- > <- > <- the granularity of what these kinds of statements apply to is
<- > <- > <- too course -
<- > <- > <- i.e. all resources whose URIs 'startWith' a common
<- substring. It
<- > <- > <- might have
<- > <- > <- been better to do something akin to what XPointer does for XML.
<- > <- > <-
<- > <- > <- Suggestion:
<- > <- > <- IMHO rdf:seeAlso is equivalent to xsl:include semantics.  What
<- > <- > <- is lacking is
<- > <- > <- xsl:import semantics.  The latter might allow you to
<- define a set
<- > of <- > <- statements that apply to their current doc, then
<- 'importing' <-
<- > > <- that doc from
<- > <- > <- another would make those same statements apply to the
<- doc doing the
<- > <- > <- importing.  Hence, importing a handful of rdf docs containing
<- > common <- > <- statements (e.g. author) from a million XHTML web pages
<- > would <- > <- save a lot of
<- > <- > <- typing!
<- > <- > <-
<- > <- > <- This would solve both 1) and 2) above to some degree of
<- > <- > <- satisfaction - the
<- > <- > <- degree of satisfaction of 2) depends on how you structure
<- > <- your imported
<- > <- > <- docs.  Is this worthy of the issues list?
<- > <- > <-
<- > <- > <- >
<- > <- > <- >
<- > <- > <- ><- >On another line, forget XHTML for a moment, how
<- do we embed
<- > <- > <- metadata in
<- > <- > <- ><- >other XML markups?
<- > <- > <- ><-
<- > <- > <- ><- I thought this is what XML Namespaces are for!
<- Just embed your
<- > <- > <- elements,
<- > <- > <- ><- any processor that doesn't recognise the namespace
<- (within its
<- > <- > <- ><- context) can
<- > <- > <- ><- ignore it.  Note that to validate such documents
<- > <- properly (and allow
<- > <- > <- such
<- > <- > <- ><- open mixing-and-matching of different 'XML mini-languages')
<- > will <- > <- ><- require XML
<- > <- > <- ><- Schema.
<- > <- > <- >
<- > <- > <- >Quite. (to avoid this going in circles, please ignore) so why
<- > <- > <- should XHTML
<- > <- > <- >be treated any different?
<- > <- > <-
<- > <- > <- One reason is that it is currently validated using a DTD.
<- > <- Whether XML
<- > <- > <- Schema would fare better, I don't altogether know for sure.
<- > <- > <-
<- > <- > <- (Note that my current understanding of XML Schema is not
<- > <- perfect, I am
<- > <- > <- hoping that XML Schema allows you to freely mix-and-match
<- > <- elements in
<- > <- > <- different XML namespaces.)
<- > <- > <-
<- > <- > <- regards
<- > <- > <-
<- > <- > <- Lee
<- > <- > <-
<- > <-
<-
Received on Friday, 20 April 2001 22:17:22 GMT

This archive was generated by hypermail 2.2.0+W3C-0.50 : Monday, 7 December 2009 10:51:49 GMT