Re: Least-damage approach to @href/@resource completing triples

One of the nice aspects of being on this side of the pond is that while 
I am sleeping, you guys over there in the New World sort out things 
(well, Mark seems to be on his machine day and night, but maybe he has a 
cloned instance somewhere in the US...:-). Meaning that I do not have to 
go through the long mails in all details...

Your two scenarios are well formulated although, I must say (but I am 
biased!) I am not sure the consequences of Ben's rules are indeed as 
dramatic as you describe:-). Until now I could happily encode what I 
wanted in RDFa without too much problems. To be fair, the whole question 
did not even come to my mind until the discussion broke out!

Note also that the @src issue is also in the balance. Yes, in some way 
it is different, but not completely. See my analysis in

http://www.w3.org/mid/4784A149.4030304@w3.org

in conjunction with Mark's model. It is special to @src, I believe, and 
may be somehow amended, but somebody should look at that again to either 
prove me wrong or right...

Ivan

Manu Sporny wrote:
> First, I do believe that Mark's approach is the proper way to do things
> from a programming/engineering/graph theory perspective.
> 
> Everybody that I've heard explain RDF/N3 have said that a triple is:
> 
> SUBJECT PREDICATE OBJECT .
> 
> If we assume that people will understand that @about/@href/@resource can
> be used to set the subject OR object (depending on whether or not you're
> chaining), then there are no issues. Unfortunately, I don't think many
> will understand that rather advanced concept until they've been immersed
> in RDFa for several months. The danger is: What happens if people don't
> understand that?
> 
> My initial thought on "accidental" triple generation was: "Too bad,
> that's what the markup states. They'll get burned, they'll learn and
> they'll fix their markup. They should learn how to use RDFa properly.
> They should understand what they're typing."
> 
> Ben's rules makes it harder to generate triples accidentally, as well as
> simplifying what can/can't generate a triple. This is at the cost of
> slightly more verbose markup and a compromise on orthogonality between
> what @about/@src/@href/@resource can do.
> 
> Mark's rules are very powerful and @about/@src/@href/@resource are quite
> orthogonal. In a way, they are simpler to explain... but harder to truly
> grasp without a basic understanding of graph theory. You can express
> things very succinctly, the danger being that you might generate
> something you didn't mean to.
> 
> Mark Birbeck wrote:
>> So no-one is proposing an alternate model to mine, they are just
>> suggesting that some of the formulations that my model enables should
>> be prescribed.
> 
> In that case, perhaps we can look at the issue assuming that the
> decision we are about to make is going to be disastrous.
> 
> Scenario #1: We go with Mark's rules. Ben is right. Spurious triples
>              are generated on a widespread scale, HTML markup must be
>              changed drastically to incorporate RDFa.
> 
> Outcome: Bloggers start unknowingly creating a large volume of spurious
> triples that express the wrong relationships, thinking that they
> understand which triples they are creating. They don't check their work,
> they're lazy. The semantic web becomes a sea of triples... half are
> correct, half are absolutely wrong.
> 
> How do we fix it: Replace Mark's rules with Ben's rules in RDFa 2.0...
> all of a sudden tons of triples disappear off of web pages (because
> people will probably just change the DOCTYPE at the top of the page - or
> people are using tag-soup parsers). The publishers that were using
> Mark's rules properly are very annoyed that they just sporadically lost
> 3 years worth of triples - they don't know which ones they lost because
> it is impossible to check automatically.
> 
> Scenario #2: We go with Ben's rules. Mark is right. Publishers have a
>              much harder time expressing semantics succinctly using
>              RDFa.
> 
> Outcome: Triples aren't being generated because blogger's aren't using
> the proper markup. Bloggers complain that RDFa is difficult to use
> because @href/@resource don't do what is expected... it's also too
> verbose, adoption is slow.
> 
> How do we fix it: Education and tools that generate the proper triples.
> If we have to, Ben's rules are replaced with Mark's rules in RDFa 2.0.
> However, we will have a ton of real-world use cases to see if Mark's
> rules would actually help or hurt matters at that point.
> 
> So, while I partially agree with Mark's approach, I can't support it
> because of the two disaster scenarios I've outlined above. Ben's rules
> are going to be less harmful in the long run if we're wrong. Most
> importantly, the semantic web can recover from Ben's rules.
> 
> If there is a place to be cautious about "accidental" triple generation,
> it is in version 1.0 of RDFa.
> 
> And if people complain about not being able to use @href/@resource to
> complete a triple, we have a great answer for them:
> 
>  "Then you're going to love the @href/@resource upgrade in RDFa v2.0!"
> 
>                                  :)
> 
> -- manu
> 

-- 

Ivan Herman, W3C Semantic Web Activity Lead
Home: http://www.w3.org/People/Ivan/
PGP Key: http://www.ivan-herman.net/pgpkey.html
FOAF: http://www.ivan-herman.net/foaf.rdf