RE: making RDF model visible in spec [was: representing hypermedia controls in RDF]

On Tuesday, November 26, 2013 3:54 PM, Ruben Verborgh wrote:
> Hi Markus,
> 
> I split this mail to discuss the spec representations separately.

Great.. I'll just answer to this mail now and to the other one tomorrow..
have to finish some other work :-(


> > Would you volunteer to convert the examples to Turtle?
> 
> I could, yes. Is there assistance from an automated tool?
> My workflow for understanding RDF/XML is now to use cwm and convert to
> Turtle;
> if I have something similar for JSON-LD, then I can do this.

There's a playground on both json-ld.org and on my site
www.markus-lanthaler.com/jsonld/ which lets you do that. You just have to
clean up the JSON-LD from the spec before feeding it into those tools (just
as JSON, JSON-LD doesn't support comments).


> > I'm still very skeptical about this. Turtle has been around for a
> decade now
> > and I have yet to see a Web API (outside the small Semantic Web
> community)
> > using it. JSON-LD on the other hand is still quite young and already
> widely used.
> 
> True, but:
> a) Turtle is still not standardized (the SemWeb maffia wouldn't admit
> the RDF/XML mistake)

Neither is JSON-LD :-P


> b) JSON is ideal to consume in Web applications
> 
> However, I as a spec reader am not a Web application.

Hmm...


> >> E.g., the triple model doesn't come to live with JSON-LD.
> > The question is, has it to?
> 
> Counter-question: does Hydra need RDF?

It could live without it (now stone me)


> It could be possible to define it just as a JSON subset.
> However, the choice was made to use the underlying RDF model;
> as such, we cannot pretend it doesn't exist.

I don't pretend that.. please don't conflate serialization formats with the
abstract data model.


> I strongly appreciate the JSON compatibility that JSON-LD brings for
> the RDF model;
> but this does not mean an understanding of JSON equals an understanding
> of JSON-LD and thus RDF.

Nope, but it's not the job of the Hydra spec to teach either RDF, nor
JSON-LD, nor Turtle.


> So if average Web developers are the core target of the spec, is it
> wise to use RDF as model?
> (Not being cynical here, honest question.)

Puuhh.. how could I possible answer that question? You know that RDF is so
general and *in principle* so simple that you can map just about anything to
it. That doesn't mean that you have to buy in the whole stack which includes
reasoning (which I'm convinced most web devs don't understand) and a
plethora of newish serialization formats that are just about being
standardized (I still find that a bad idea).


> If you say, RDF is the way to go (the SemWeb maffia thanks you),
> then yes, I think the underlying triple model should come to live for
> RDF-understanding readers.

Let's try and see if the Turtle examples make the spec any clearer. It would
also be great if someone could implement a demo similar to the issue tracker
demo on my website using Turtle.


> > Yeah, and I hope this is not turning into a syntax war :-)
> 
> Not here to fight that war :-)
> For me it's about model, not syntax.

Good.. peace! :-)


> > I've created ISSUE-18 [2] to keep track of this. Let's see if other
> people
> > (preferably non-SemWeb experts) complain about it.
> 
> Just want to ensure that people with my background (which is not all
> that different!)
> also understand it, as I need this spec to become important here.
> 
> The spec chose RDF as a model;
> if people with an RDF background don't find it easy to use,
> there's maybe no point in having an RDF model.

Fair enough


> > By simple I meant to keep my job simple :-) There are no examples to
> keep in
> > sync, no difference between syntaxes to be explained
> 
> Automated conversion is what we need.
> Just a JavaScript toggle from JSON-LD to Turtle;
> they're two syntaxes for the same model anyway
> (with the difference that JSON-LD also has the JSON model).

As you probably know, the spec is on GitHub:

  https://github.com/HydraCG/Specifications/tree/master/spec/latest/core

and uses ReSpec [1]. I think the simplest thing to make some progress here
would be a pull request so that we have something concrete to look at. uch
appreciated that you spend your time on this!


Thanks,
Markus


[1] http://www.w3.org/respec/guide.html


--
Markus Lanthaler
@markuslanthaler

Received on Tuesday, 26 November 2013 15:44:29 UTC