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

Hi Markus,

> There's a playground on both json-ld.org and on my site
> www.markus-lanthaler.com/jsonld/ which lets you do that.

Is it available as a standalone npm package?
Otherwise, I just might do that first, so I have a command-line tool like
   jsonld file.json


>> a) Turtle is still not standardized
> 
> Neither is JSON-LD :-P

But JSON has been for a long time!

>> Counter-question: does Hydra need RDF?
> 
> It could live without it (now stone me)

Actually no, that's perfectly fine and has to be considered then.
What are the arguments for and against RDF for Hydra?

>> 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.

That's just my point:
saying that JSON-LD is easier for Web developers is conflating model and serialization.
When confronting Web devs with JSON-LD, they'll see the JSON model.
When confronting me with it, that's what I see too (right now, but I should become better at JSON-LD).

So if you say that JSON-LD is easier for Web devs,
my answer is that they see the JSON model; but that's only half of the story.
Hence, do we need the RDF model?

Which data model does Hydra use: JSON or RDF?
If the latter, it seems important to make the RDF model visible, perhaps through Turtle.

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

No, but it should make visible the model it uses.
Honestly, I don't care whether it is JSON or RDF;
I care about the visibility of the underlying model.

>> 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)

Agree on that, Web devs don't understand and don't need to care.

So important: who of the Hydra users would care,
and how can we accommodate their needs?

> and a plethora of newish serialization formats that are just about being
> standardized (I still find that a bad idea).

Wow, we said "peace" right? ;-)

> Let's try and see if the Turtle examples make the spec any clearer.

Wise!

> It would also be great if someone could implement a demo similar to the issue tracker
> demo on my website using Turtle.

As Turtle, like JSON-LD is just a serialization model of RDF,
we can just convert the Turtle to JSON-LD and continue from there?
Instead of a second demo, I just propose to extend the first with content negotiation.
Ask for JSON? You get JSON-LD.
Ask for Turtle? You get Turtle.
Then the client just needs an extra module to convert Turtle to JSON-LD.
Of course, the client would indicate in its Accept header that it prefers JSON-LD, but takes Turtle too.

> 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!

You're right. Mind if I postpone this until December? (Have a PhD defense coming up.)

Cheers,

Ruben

Received on Tuesday, 26 November 2013 16:02:03 UTC