W3C home > Mailing lists > Public > public-vocabs@w3.org > August 2014

Re: Inverse Properties in Microdata:, was Re: schema.org update, v1.8: added WebSite type; broadened isPartOf to relate CreativeWorks

From: Jarno van Driel <jarnovandriel@gmail.com>
Date: Tue, 5 Aug 2014 14:19:46 +0200
To: "'W3C Web Schemas Task Force'" <public-vocabs@w3.org>
Message-ID: <0a1e01cfb0a7$8c508d30$a4f1a790$@gmail.com>
"Fair enough. But I fear it's actually not that trivial... How are reverse properties, e.g., supposed to be integrated into application/microdata+json:  <http://www.w3.org/TR/microdata/#json> http://www.w3.org/TR/microdata/#json"

 

Good point. To be honest, I haven't got a clue. It's been two years minimum since I've even looked at it, let alone understanding what needs to be done to set it up such that it supports a reverse mechanism. Heck I don't even know if that's possible. 

 

Does anybody else?

 

2014-08-05 13:54 GMT+02:00 Jarno van Driel <jarnovandriel@gmail.com <mailto:jarnovandriel@gmail.com> >:

"So? They won't understand reverse properties either..."

The same could be said for @itemid. Which I didn't understand about either and only last year discovered how it works. With great difficulty by the way because there's almost nothing to be found about it. Which actually is a far bigger issue than understanding the technicality of it. And as long as that doesn't get resolved IMHO it's too easy to say "they won't understand".

 

"...Microdata is mostly about trees. Introducing reverse properties doesn't fit very well into that model IMHO"

It's true the way most use microdata (or RDFA Lite) + schema.org <http://schema.org>  will never require them go beyond a tree but in my personal experience, by using @itemid I can chain most top level entities together in a sensible way. Something that can't always be achieved if you stick to 'just' a tree, and which, for me, is a means to express valuable relations that I otherwise can't.

 

Unfortunately, from a developer's perspective, having to add @itemid and <link itemprop="..." href="#itemid"> isn't always solution for every situation either; It shares one property of @itemref that can get in the way: The need for an identifier (@id or @itemid). 

 

And from a developer's perspective this is why I'd like to see @itemprop-reverse get added to microdata. It just isn't always feasible to add identifiers throughout a template in a *cost effective* manner, and adding @itemprop-reverse helps to be able to resolve this issue. Now does it worry me that this goes beyond a tree? Not a sec. 

 

I'm a practical guy. I don't worry all that much about where which syntax is meant for. I just know I run into technical difficulties sometimes and I'd like to be able to resolve those. And whether or not this goes beyond trees or that microdata is becoming more like RDFa because of it, are non-issues for me personally. What occupies me more is understanding it enough so I'm able to explain it to everyday web developers, who, like me, most of the time think in much simpler terms than those expressed here at the public-vocabs, but who (need to) go beyond the examples the sponsors and schema.org <http://schema.org>  itselfs provides. Bridging that gap simply is of more importance of me. 

 

"RDFa 1.1 (Lite) is *much* simpler than previous versions."

Thanks for pointing it out but I'm well aware of RDFa Lite (and like it very much).   :)

 

"Reading my mini tutorial above, do you still think it will cost you "bucketloads of [your] free time"?"

For others? I sure do. I myself have invested so much time and energy already that I dare to think I understand most of it by now (thanks to a lot of folks here).

 

But try comparing the difference in output in Google's structured data testing tool between a document that contains microdata and the same document in RDFa (Lite). That alone is enough to fry the brain of most who are trying to make the switch to RDFa (Lite). Now sure, there of plenty of other tools as well, but just a small group of people in the world are aware of this. The rest has to make do with what they know, which is Google's SDTT and the info schema.org <http://schema.org> 's sponsors provide. Taking that into mind makes me say it does take a ton of time to understand.

 

"Did you, e.g., write down what you've learned over the years?"

Nope, although I help others almost on a daily basis through my activities on G+. Folks often reach out to me to me when they're stuck, so instead of having a blog full of tutorials (which I hope to have one day) I help folks fixing their issues on live sites. Something I also spend a lot of my personal time on and would love to do full time. But I'm not in a position to be a philanthropist and therefore also need to work for a living. Unfortunately there's only so much time I can dedicate to this. 

 

"So, help in the form of writing simple tutorials and blog posts etc. would be much appreciated"

I totally agree with you on this one, although many here already do this. But I think it would help even more if the W3C could handle this on w3schools.com <http://w3schools.com>  as well as the sponsors (together) on schema.org <http://schema.org>  as well as on their own sites. Together these can reach a far greater audience than we as individuals ever can. 

 

 

 

 

2014-08-05 12:04 GMT+02:00 Markus Lanthaler <markus.lanthaler@gmx.net <mailto:markus.lanthaler@gmx.net> >:

 

On Tuesday, August 05, 2014 12:52 AM, Jarno van Driel wrote:
>> "Why can't we simply recommend people to use RDFa for such
>> "advanced" use cases? Do we want to evolve both formats in the
>> future?"
>
> I'm not for that at all. It's easy to say "just use RDFa (or JSON-LD)"
> for this, but that doesn't imply:
>
> a] That person understands RDFa already.

So? They won't understand reverse properties either. Microdata is mostly about trees. Introducing reverse properties doesn't fit very well into that model IMHO.



> Personally I tried RDFa six years ago, failed miserably and turned to
> microdata.

That's a very good point.. at least it was six years ago. A lot of things changed in the meantime. RDFa 1.1 (Lite) is *much* simpler than previous versions. Moving from Microdata to RDFa 1.1 can, in most cases, be done by simply replacing some attribute names. Since I believe a lot of people on this list share your experience, let me quickly summarize the differences looking at all attributes Microdata defines and see how the map to RDFa 1.1:

  itemscope --> vocab="http://schema.org/"
  itemid --> resource
  itemtype --> typeof
  itemprop --> property / rel
  itemref  --> property="rdfa:copy"

Strictly speaking itemscope and vocab serve two different purposes but if you transform Microdata to RDFa the replacement does the job. RDFa doesn't infer the vocabulary from the type that is being used (itemtype in Microdata) but requires it to be explicitly specified (vocab).



> Which was easier to understand when starting out. And by
> now, I've 'sort of' got my head wrapped around it and am stumbling
> back into RDFa because of it, together with the ton of mistakes that
> come with it. But more importantly, it's costing me bucketloads of my
> free time to learn it all. Something I don't think can nor should be
> expected from everybody.

Reading my mini tutorial above, do you still think it will cost you "bucketloads of [your] free time"? Btw. there's a little playground at http://rdfa.info/play/ that visualizes the extracted graph (at least in Chrome and FF)



> If somebody started out learning microdata and has the audacity to
> become any good at it, then that person shouldn't have to discover
> that they need learn a different syntax to be able to take the extra
> step when of running into one of those 1 in a 1000 situations. I think
> that's too much to ask. Especially if adding one attribute to
> microdata can resolve it

Fair enough. But I fear it's actually not that trivial... How are reverse properties, e.g., supposed to be integrated into application/microdata+json: http://www.w3.org/TR/microdata/#json



> b] Website(s) being worked on can not "simply" be rewritten to
> accommodate RDFa.

Are you still sure about that?



>> "Reverse properties are not exactly the simplest thing as this thread has shown."
>
> Nope, there not 'easy'. And sure, I've asked plenty of questions and
> unfortunately I ask for a lot of input of the folks here, but that's
> because there are so little resources available to learn this type of
> stuff.

Yeah, but we can change that together. And "newcomers" that struggle with this stuff are almost always in the best position to write such material as they do experience these problems themselves. As paradox it sounds, but it is very difficult for experts to write good tutorials for complete newbies. Did you, e.g., write down what you've learned over the years? :-)



> Especially for the everyday developer who is looking for info
> that goes beyond examples on schema.org <http://schema.org>  or any of the sponsor's sites.
> And as long as that info isn't abundantly available it will stay too
> complex for most. Maybe the focus therefore should be more on
> educating folks as opposed to deciding something is too complex before
> ever giving them a chance to properly learn it.

We need to work together to make this happen. Writing and implementing specs is already time consuming enough. I personally, e.g., do that entirely in my free time. No one is paying me or supporting me in any other way to do this. I'm sure a lot other people are in the same situation. So, help in the form of writing simple tutorials and blog posts etc. would be much appreciated :-P


[1] http://www.w3.org/TR/microdata/
[2] http://www.w3.org/TR/rdfa-core/


--
Markus Lanthaler
@markuslanthaler



 

 
Received on Tuesday, 5 August 2014 12:20:19 UTC

This archive was generated by hypermail 2.4.0 : Friday, 17 January 2020 17:49:34 UTC