Re: Re 2: PROPOSAL to close ISSUE-37: Clarifying bnode explanation

Hi Nathan,

On Wed, Oct 20, 2010 at 8:04 PM, Nathan <> wrote:
> Mark Birbeck wrote:
>> However, nowhere do we say that in between the two serialisations
>> (RDFa and Turtle) the data has been stored and re-serialised. And
>> since nothing has happened in between those two serialisations then it
>> would be *wrong* to have a mismatch in the blank node identifiers that
>> are used in those two serialisations.
> not really being pedantic, but the only way to get the Turtle from the RDFa
> is to store and serialize it, so in reality anybody taking the example RDFa
> and converting it to Turtle will see different bnode identifiers. In fact
> about the only time the identifiers will ever presented as consistent, is in
> this document.

Now we really are going off-piste...why are you talking about getting
Turtle from RDFa!

Let's rewind...

Look at the top of section 3.6:

  RDF itself does not have one set way to express triples, since the
  key ideas of RDF are the triple and the use of URIs, and not any
  particular syntax. However, there are a number of mechanisms for
  expressing triples, such as RDF/XML [RDF-SYNTAX-GRAMMAR],
  Turtle [TURTLE], and of course RDFa. Many discussions of RDF
  make use of the Turtle syntax to explain their ideas, since it is
  quite compact. The examples we have just seen are already using
  this syntax, and we'll continue to use it throughout this document
  when we need to talk about the RDF that could be generated from
  some RDFa.

The point is straightforward; it effectively says that since RDF is an
abstract syntax, we have no way to represent the triples generated,
but as an approximation we will use Turtle.

To put it a different way, what we said way back when this was written
was: here's a *new* way of serialising RDF (RDFa), and the easiest way
we can think of to explain it to you is to use an *old* way of
serialising RDF (Turtle).

So we certainly aren't 'converting' one serialisation to another, by
parsing first.

> The only reason the bnode identifiers are aligned in the examples is because
> the group has chosen to show them that way for the sake of clarity...

Yes...clarity...and the minor issue that otherwise the examples just
simply wouldn't make sense.

> ...thus it
> appears perfectly reasonable to also state that bnode identifiers can't be
> relied upon and show an RDFa-Turtle example pair where the bnode identifiers
> aren't aligned, again for the sake of clarity. makes no sense. The examples are *not* about round-tripping
the triples, they are merely about trying to explain to people what
triples would be generated from some mark-up.

The issue you describe relates to *retrieving* triples that have been stored.

Or if you prefer to think in terms of the abstract syntax, the issue
is about moving from an RDF graph in which none of the bnodes have any
names (since they are by definition anonymous), to a serialisation
where they /do/ have names (i.e., bnode identifiers).

At that point...yes, the identifiers can be anything.

But to stress again, our examples have an RDFa serialisation followed
by a Turtle serialisation only to help explain what's happening. We
haven't moved to an RDF graph at all -- we've stayed at the level of
serialisation, by moving from one to another.

> The issue looks to be "clarifying bnode explanation" and I for one feel the
> text Toby suggested, with both examples, does indeed clarify the explanation
> of bnodes.
> Do you disagree?

Vehemently. :)



Mark Birbeck, webBackplane

webBackplane is a trading name of Backplane Ltd. (company number
05972288, registered office: 2nd Floor, 69/85 Tabernacle Street,
London, EC2A 4RR)

Received on Wednesday, 20 October 2010 20:16:57 UTC