RE: CLASS vs. ROLE

Hi Ben,

I actually see it more as "this node 'plays the role of' a sitemap" rather
than "this page has a sitemap", as I'll explain.

Quite a long time ago we agreed that:

  <x role="y" />

was simply a shorthand for:

  <x rel="xh:role" href="[y]" />

There are a number of reasons for this, but one of them is the need to be
able to assign multiple roles to an object, which you can do by having lots
of <link> items:

  <nl role="wai:sitemap">
    <link rel="role" href="[wai:toolbar]" />
    <link rel="role" href="[wai:blibble]" />
    <li ... />
    <li ... />
    <li ... />
  </nl>

I think we should keep this predicate explicitly, whereas in your examples
Ben, it has been factored out to represent something else. (Note that 'role'
is one of the 'special' values of @rel and @rev in XHTML 2, for this very
purpose.)

One thing that might be an issue though is that no relationship between this
node (the <nl>) and the actual host document has been defined. So, although
it's clear that we've made these statements:

  _:bnode0 xh:role wai:sitemap
  _:bnode0 xh:role wai:toolbar
  _:bnode0 xh:role wai:blibble

It's not clear how this says that "this document *has* a sitemap".

My feeling is that this is not the concern of RDFa as such, and if we want
to define it at all (and it's not clear we should) then it could go into the
XHTML 2 profile for RDFa, that we've started to discuss.

The reason I say I'm not sure if we should define it, is as follows. Let's
say we decide to say that this statement:

  _:bnode0 xh:role wai:sitemap

actually generates or allows the inference of this:

  <> wai:sitemap _:bnode0

In other words, if some node 'plays the role of' a sitemap, then the
document containing that node can be said to have a sitemap predicate of
that node.

My concern here is that we can only really say this because we sort of
'know' that a site might only have one wai:sitemap. But what if there is one
sitemap for many pages:

  <link rel="wai:sitemap" href="sitemap.html" />

In this case to 'infer' from role="wai:sitemap" that this was *the* sitemap
would be a step too far.

Similarly, what if the item being referred to is 'local' to a particular
area of a document:

  <div id="a">
    <nl role="wai:toolbar">
      <li ... />
      <li ... />
    </nl>
    <nl role="wai:toolbar">
      <li ... />
      <li ... />
    </nl>
  </div>

Here we actually want the element 'a' to have two toolbars, not necessarily
the document. This could well be particularly important, if, for example we
were generating portlets from these pages, where the features would need to
'travel' with their sub-document.

So my view is that the RDFS definitions for wai:sitemap and wai:toolbar
should include further triples that can be understood to be present, and
RDFa shouldn't be involved in this.

Which also leads to the point about whether something should *automatically*
have an rdf:type when @role is used:

  _:bnode0 xh:role wai:sitemap
  _:bnode0 rdf:type wai:sitemap

I still think generating this extra triple is unwise, and actually
unnecessary, but until someone comes out with a more 'formal' statement that
takes one side or the other, I have to say that I am agnostic. :) By that I
mean that if some logician comes along and says that when something *plays
the role* of something, it is, to all intents and purposes, the same as the
thing it is playing the role of, then I'm happy to see the implied rdf:type
added. But I'm guessing that they are not the same--if a crowbar plays the
role of a 'door opener', it doesn't mean it has all of the properties of a
key, and that's what worries me; if some processor were to do things with
_:bnode0 based on the fact that it *is* a toolbar, things may go wrong.

(I have some comments on @class, but they are proving tricky....)

Regards,

Mark


Mark Birbeck
CEO
x-port.net Ltd.

e: Mark.Birbeck@x-port.net
t: +44 (0) 20 7689 9232
b: http://internet-apps.blogspot.com/
w: http://www.formsPlayer.com/

Download our XForms processor from
http://www.formsPlayer.com/ 


> -----Original Message-----
> From: public-rdf-in-xhtml-tf-request@w3.org 
> [mailto:public-rdf-in-xhtml-tf-request@w3.org] On Behalf Of Ben Adida
> Sent: 13 May 2006 17:53
> To: public-rdf-in-xhtml task force
> Subject: CLASS vs. ROLE
> 
> 
> 
> Hi all,
> 
> I had a thought today about CLASS vs. ROLE. Consider the 
> example from the XHTML2 working draft [1]:
> 
> =======
> <nl role="wai:sitemap">
>      <li href="downloads">Downloads</li>
>      <li href="docs">Documentation</li>
>      <li href="news">News</li>
> </nl>
> =======
> 
> Now, is this saying that the NL *is* a sitemap in general, or 
> is it saying that it's the current page's sitemap? I think it 
> might be the latter, in which case, what we're really saying is:
> 
> <> wai:sitemap _:bnode0
> 
> and *not*
> 
> _:bnode0 rdfs:class wai:sitemap
> 
> In other words, my feeling is that CLASS designates an object 
> with the current element as subject, while ROLE designates a 
> predicate with the current element as object.
> 
> This seems to match the intended usage of ROLE, which is to 
> say that something "plays the role of" for the current 
> resource, and the historical use of CLASS, which specifies 
> some semantic type for the current element without expressing 
> a relationship to the current URI.
> 
> The example from the XHTML2 editor's draft then does pretty 
> much what we expect, using RDFa Containers:
> 
> <> wai:sitemap _:bnode0.
> _:bnode0 rdfs:class rdf:Alt.
> _:bnode0 rdf:_1 <downloads>.
> _:bnode0 rdf:_2 <docs>.
> _:bnode0 rdf:_3 <news>.
> 
> 
> Consider, in addition, and to follow up on Ivan's email a bit 
> more, the following example (that I just made up):
> 
> =======
> This page was authored by
> <span role="dc:creator"><meta property="dc:name">Ben 
> Adida</meta></span> =======
> 
> which yields:
> 
> <> dc:creator _:bnode0.
> _:bnode0 dc:name "Ben Adida".
> 
> which seems to be doing the right thing.
> 
> Thoughts?
> 
> -Ben
> 
> [1] http://www.w3.org/TR/xhtml2/mod-role.html
> 
>

Received on Monday, 15 May 2006 12:54:34 UTC