Re: [JSON] PROPOSAL: Syntax structure should be object-based

On 03/16/11 14:02, Sandro Hawke wrote:
>> Yes, I know direct eval() is not often done.  The point stands though - 
>> is it a call that is specific RDF of a call that any JS app might make. 
>>   You are describing a non-generic call in which case the relationship 
>> between javascript objects and serialization is open.
> 
> Agreed.   If users have to call rdf_in_json.parse() then why shouldn't
> they just use turtle.parse() instead? Or, really, rdf.parse(), which
> understands turtle, rdf/xml, and RDFa.

We could do turtle.parse(), but then we're back to trying to convince
Web developers that they should drop JSON and start using TURTLE to
publish their data. We're also, simultaneously, not bringing any of this
JSON data into the semantic web.

If we want to take that approach, shouldn't we ask why TURTLE isn't
already widely used by Web developers? (I don't think that's an easy
question to answer, btw - just asserting that people out there are using
JSON to publish their data, not TURTLE).

Having something like turtle.toLanguageNativeObject() would be great --
and that's why the RDF/RDFa API is already headed in that direction.
That is, we're already doing this through the RDF/RDFa API via the
getItemBy...(), .query() and Projection/Property Group mechanisms.

http://www.w3.org/2010/02/rdfa/sources/rdfa-api/Overview-src.html#basic-concepts

However, what happens when people don't really want to use the API (for
whatever reason - like a hatred of RDF, like many of the folks that work
on Web Browsers have)?

To give you an example, the PaySwarm API will use a set of well-defined
prefixes for all of the data that we send out. 'foaf' will always map to
"http://xmlns.com/0.1/foaf/" in all PaySwarm systems. The value can be
overridden when data is written to the service via RDF in JSON over
REST, but the data we send out will always use the same default context.

If you think about it - this is exactly how Twitter operates. They don't
change key names in the objects that they send back to people because
they don't want to disrupt their app ecosystem. They want to provide a
consistent interface and if a company is doing that, there is no need
for rdf_in_json.parse() - you just continue to publish your JSON data
and provide some RDF goggles if folks would like them. You don't force
RDF onto people unless they want to use it... they can just continue to
use JSON.parse() if they want to.

> I'm wondering how terse and simple we can get the use cases here.

I bet that we could map almost every single one of them to very simple
JSON, and every single one of them to very simple TURTLE.

Shouldn't one of our primary concerns be which one of these is going to
be easier to sell to Web developers?

-- manu

-- 
Manu Sporny (skype: msporny, twitter: manusporny)
President/CEO - Digital Bazaar, Inc.
blog: Payment Standards and Competition
http://digitalbazaar.com/2011/02/28/payment-standards/

Received on Wednesday, 16 March 2011 19:13:36 UTC