[rdfweb-dev] foaf:maker RDF property and relationship to DC creator

Dan Brickley danbri at w3.org
Fri Aug 15 09:56:43 UTC 2003

(sent to Dublin Core architecture group, cc'd to FOAF developers)


Short version: please review foaf:maker vocabulary and consider 
  supporting something like a 'dcterms:creatorAgent' relationship within DC.

Long version:
Some of you might have heard about my side-project, FOAF. In the FOAF 
project we have an RDF vocabulary for talking about people and the
things they make and do. As we say at http://www.foaf-project.org/
"The Friend of a Friend (FOAF) project is about creating a Web of
machine-readable homepages describing people, the links between them and
the things they create and do."  There is an evolving spec at 
http://xmlns.com/foaf/0.1/ defined in RDF Schema and Web Ontology (OWL)
form, and a weblog and developer site at http://rdfweb.org/ 

As an RDF application, FOAF data allows free mixing of RDF/XML markup
from multiple namespaces, and many FOAF documents already use Dublin
Core when describing documents (images, weblogs, homepages, etc). Most 
common (here as elsewhere I suspect) are dc:title and dc:description.
Most problematic (and the motivation for this message) is dc:creator.

The recent Eric/Andy exchange about dc:rights and structured values,
qualifiers etc (apart from giving me flashbacks to every DC meeting I've
been to since '97) reminded me to seek feedback from this group on the 
current FOAF design. I have also just updated http://xmlns.com/foaf/0.1/ 
so there is something fairly detailed for you to look at.

Here's the story. In FOAF, unlike DC, we mostly focus on describing 
stuff to do with people; however we overlap with DC concerns when we get 
to describing the results of the work and collaborations these people 
engage in. In particular, we are concerned to have a clean and simple 
RDF representation of the relationship between a person and the things
he or she has made, or helped to make (documents, artifacts ...). For
this purpose it was tempting to use dc:creator, and for a while I was an 
advocate of that route, using dc:creator as a relationship between
documents and their creators (authors, etc). However we run into the
usual DC frustration of trying to have our cake and eat it. Dublin Core
allows for dc:creator to be used in RDF in lots of ways. Sometimes as a 
relationship between a document and the name of its creator, sometimes
as a relationship between a document and the creator him/her-self. And 
sometimes as a relationship between a document and a Bag/Seq/Alt
construct which references one or more creators and/or names.

The current FOAF design doesn't encourage people to use dc:creator
*except* as a simple relationship to a name, eg.

<foaf:Document rdf:about="http://rdfweb.org/people/danbri">
  <dc:title>Dan's homepage</dc:title>
  <dc:creator>Dan Brickley</dc:creator>

ie. we no longer encourage the 
<dc:creator><foaf:Person>...</foaf:Person></dc:creator> idiom or
anything like it.

When we want to describe a relationship to the actual person who 
created the document, eg. so we can say more about them, we use the 
(relatively new) foaf:maker property. This is just an inverse of the
foaf:made property, which has been around for a while and relates a
person to a thing they made.

foaf:maker is documented at http://xmlns.com/foaf/0.1/#term_maker and 
used as follows:

<foaf:Document rdf:about="http://rdfweb.org/people/danbri">
   <dc:title>Dan's homepage</dc:title>
       <foaf:name>Dan Brickley</foaf:name>
       <foaf:workplaceHomepage rdf:resource="http://www.w3.org/"/>
       <!-- other person-oriented properties here -->
>From an RDF and FOAF perspective, I believe this works quite well.
However I do feel it is a shame that DC doesn't itself define such a 
property. If DC were to do so, I'd be very happy to express an 
equivalence within the FOAF schema and (if the details worked out) begin 
a migration. One other issue / note: in FOAF we make more use of 
RDF Schema and OWL constructs than in DC, defining classes (Person,
Agent, Document etc.) so that property definitions can use them to 
define domain and range constraints. So for example, foaf:maker has a
domain of foaf:Agent, in effect stating that only 'Agents' make things.
We don't currently constrain the kinds of things that can be made, so
for example I could write:

	  <foaf:mbox rdf:resource="mailto:danbri at w3.org"/>

...to in effect say "there's an image that depicts a Car that was made
by the person whose mailbox is ...". Of course at each point I could
provide more details (the URL and title of the image; the colour and 
weight of the car; the age and IQ of its maker...). FOAF tools are good
at merging data with other info based on uniquely identifying properties
(such as 'personal mailbox','homepage' etc) so often you'll see quite 
stark descriptions like this which don't go on about a person in much
detail. Often they'll also contain an rdfs:seeAlso pointer to a more 
detailed RDF description.

I won't go on much more about the details. This was mainly intended as a 
"heads up" to the Dublin Core community to keep some communication about 
how a DC-friendly RDF vocabulary is evolving, and let folks know about 
some design decisions we've made. 

I wrote up some of the backstory on 'dc:creator' for the FOAF developers
list, see Wiki page at http://rdfweb.org/topic/UsingDublinCoreCreator 
where (re-reading) I may have been a little rude about the use of
rdf:Bag, rdf:Seq etc. To be honest I regret that they're still in the
RDF spec, but they are. I find their use to be very varely appropriate.

One last point. I believe it is possible to write down a pretty simple 
rule that characterises how foaf:maker relates to dc:creator. Feedback 
on this is particularly welcome:

       ?D dc:creator ?N . 
        implied by 
       ?D foaf:maker ?M . 
       ?M foaf:name ?N  

In other words, something (we'll call it 'D') has a dc:creator that is 
another thing 'N' if there is a third thing 'M' that is a foaf:maker of
'D' and that has a foaf:name 'N', ie. "If you know the name of someone 
who made something, their name is the value of a dc:creator of that

Is this always true? Or just for documents? If I make a sandcastle on a
beach, is it true to say that the sandcastle has a dc:creator of 'Dan
Brickley'? If not, let's add in a further constraint:

       ?D dc:creator ?N .
        implied by
       ?D foaf:maker ?M .
       ?M foaf:name ?N .
       ?D rdf:type foaf:Document 

...ie that we only generate dc:creator in the case of a person having
made something.

I'll shut up now :)

Let me know what you think. Maybe FOAF can serve as something of an 
experimental lab for trying out ideas that could eventually filter their
way back into DC vocabularies... In my experience with DC, RDF _and_
FOAF, there is a clear need for a less ambiguous property than
dc:creator, whose values are always agents. But I appreciate that there
are complexities (ie. what to do about dc:publisher, dc:contributor; how
to define 'making', what kinds of things can be made, etc.). I'll report
back here occasionally on our experiences with foaf:maker and let you 
know how the design shakes out in practice...



(ps. just to be clear, the FOAF project isn't a W3C 'thing', any more than RSS1, 
DC itself, Creative Commons etc. I don't bother sending all FOAF-related mail
from danbri at rdfweb.org since that would set up impossible expectations
re partitioning of my work and email habits. Since various webloggers have on 
recent occasions refered to FOAF as an 'emerging standard' I feel the need to
mention this from time to time...).

More information about the foaf-dev mailing list