WSCCI Serialization Format Preliminary Report-Back

I'm not familiar with CMIS. Grepping its spec for "JSON" yields no results. Does it have a JSON representation at all?

I've looked into the others and JSON-LD looks very clean and attractive.

After doing some research it seems like all of the serialization formats have their own merits. Would anybody be interested in seeing a Shootout out together? Or is this something that would rather be debated in the comments?

As far as my serialization format of choice, I really think JSON-LD is the front runner. It's simple to pick up and also very powerful because of its simplicity. Though, I think the bigger win is that the JSON is already a familiar format to a lot of folks. Learning a new set of tokens to a familiar syntax would help sustain a higher level of developer following. Lowering this bar, if you will, would mean we also sustain a higher level of comprehension.

The other JSON based format, Collection+JSON, had less concise documentation, which is why I threw in my hat for JSON-LD. This is also why I raise the thought of having a Shootout, it may shake out some gotchas/facts.

Implementing even partial CMIS will be a big undertaking, but might be a good step if indeed eventually Drupal adopts PHPCR. That being said I would try to pull in Alfresco if you want to go that route. I used to work with Jeff Potts (http://ecmarchitect.com/) and could try to get him into the loop if you guys are interested. They are the people behind the current CMIS integration into Drupal.

It's a colossal piece of work to get CMIS working and yet you do not get i18 support. See https://wiki.oasis-open.org/cmis/Candidate%20v2%20topics Internationalization is listed as a v2 candidate.

Hi all,

Here are all of the requirements that you listed for this project and how I think that JSON-LD addresses each criteria:

Format Expressiveness/Hypermedia Linking

JSON-LD was created to express Linked Data in JSON without requiring folks to change the way they publish and consume JSON (unless they wanted to use some of the more advanced features of JSON-LD). This means that you can add meaning to any JSON document today by just adding an HTTP header:

http://json-ld.org/spec/ED/json-ld-syntax/20120522/#referencing-contexts...

Or by adding key-values to the data (one key-value if you want your keys to expand mean something in Linked Data, two key-values if you want to give your data IDs that are IRIs and make it true Linked Data):

{ 
  "@context": "http://json-ld.org/contexts/person",
  "@id": "http://dbpedia.org/resource/John_Lennon",
  "name": "John Lennon",
  "birthday": "10-09",
  "member": "http://dbpedia.org/resource/The_Beatles"
}

Example Hypermedia node content

You use IRIs to link to content - so any IRI will do. Here are some examples

{
  "@context": "http://example.org/drupal-wscci",
   "localFile": "file:///tmp/foo.txt",
   "localResource": "http://localhost/foo.txt",
   "remoteResource": "http://www.youtube.com/watch?v=RYlCVwxoL_g&feature=g-vrec",
   "remoteFile": "http://example.com/music/mysong.ogg"
}

Support for ad-hoc/configurable resource definitions

All JSON keys and values can be given "meaning" by modifying the JSON-LD Context:

http://json-ld.org/spec/ED/json-ld-syntax/20120522/#the-context

Not every value in the JSON needs to have a mapping in JSON-LD. That is, you can mix plain old JSON with JSON-LD and that's a perfectly valid way to operate in JSON-LD. This allows you to add fields first and give them meaning later - allowing flexibility during the design/development process. If a particular key/value becomes used widely, you can give it "meaning" by defining things like a URL to identify the term, a datatype, a default language, etc.

Discoverability is done just like on the Web. URLs and IRIs are first-class citizens in JSON-LD, which means all you have to do is "follow your nose" and you may find /more/ data at that URL. For instance, if you see this URL in JSON-LD: "http://example.org/foo/bar" - you can, via HTTP negotiation, ask for a JSON-LD representation of that IRI and you may get back a document with more JSON-LD data in it. So, you can effectively crawl the web to find more data... this is one of the powerful concepts that Linked Data uses to make data more useful and less tightly coupled with the system that is publishing it.

Formatter Implementation/Handling

I don't really understand this requirement, but I'll take a shot at it anyway:

You can associated a slew of meta-data with a URL in JSON-LD. This means you can give that URL a human readable name like "Really funny cat video", or a creation date like "2012-05-12T21:48:22Z", or even things like saying what sort of editor should be used to modify the URL (like a Web-based video editor that is started via a Web Intent): "contentEditor": "http://www.aviary.com/web". This approach is incredibly flexible and allows you to describe as much as you want to about a particular piece of data...

Internationalization

JSON-LD supports full UTF-8 Internationalization, and even allows you to tag any string with a language value (which allows you to do things like specify text labels for a particular piece of editable content in multiple languages):

http://json-ld.org/spec/ED/json-ld-syntax/20120522/#string-international...

Support for Collections

There are two types of supported collections in JSON-LD: sets and lists.

Sets are unordered collections (the concept of a mathematical set).
Lists are ordered collections (the concept of an array).

http://json-ld.org/spec/ED/json-ld-syntax/20120522/#sets-and-lists

UUID

UUIDs are supported in JSON-LD. There are three major ways of expressing UUIDs. The first is through a simple key-value:

"uuid": "550e8400-e29b-41d4-a716-446655440000"

The second is by representing the UUID as an IRI:

"@id": "uuid:550e8400-e29b-41d4-a716-446655440000"

The third is by translating a URL for the data to a version 3 UUID ( http://en.wikipedia.org/wiki/Universally_unique_identifier#Version_3_.28... ):

"uuid": "6ba7b810-9dad-11d1-80b4-00c04fd430c8"

But the best way to give your data an ID is to generate a unique URL for it that resides on the Drupal system:

"@id": "http://groups.drupal.org/comment/reply/229318#data-389247982"

Versioning/Conflict Resolution/Locking

You can use any JSON facility that does time-stamping, versioning, conflict resolution to resolve this. If you want to go a bit deeper down the Linked Data rabbit hole, you can use what are called "Named Graphs". Named Graphs allow you to talk /about/ information, not just express it. So, a named graph says "This is the information that I know about the URL http://example.org/foo/blah.txt". You can time-stamp when you retrieved information from that URL, you can version it by normalizing the data and digitally signing it (which JSON-LD supports both graph normalization and digital signatures), you can do conflict resolution in a variety of ways since JSON-LD supports information diff-ing (which allows you to tell, deterministically, what new data was added and what data was removed from a particular URL). More about this feature here:

http://json-ld.org/spec/ED/json-ld-syntax/20120522/#named-graphs

and here:

http://json-ld.org/spec/latest/rdf-graph-normalization/

Bottom line: These features allow you to do things like delayed conflict resolution and JSON object/change-set merging.

PHP Libraries

There is a reference implementation in PHP:

https://github.com/digitalbazaar/php-json-ld

It's the same one we use for our commercial implementation - it's always up-to-date (and will be kept up-to-date) because our business (Digital Bazaar) depends on it.

JavaScript Libraries

There is a reference implementation in JavaScript:

https://github.com/digitalbazaar/jsonld.js

It's the same one we use for our commercial implementation - it's always up-to-date (and will be kept up-to-date) because our business (Digital Bazaar) depends on it. You can see this library in use at:

http://json-ld.org/playground/

Current Drupal Projects and Groups

Unfortunately, I don't know enough about active Drupal Projects and Groups to answer this question. I know scor (Stephane Corlosquet) has a JSON-LD module for Drupal.

Community Experts

There are a number of people that are always on the #json-ld IRC channel on freenode.net. We're on there 24/7, so if you have a question, just drop it in the channel and you will most likely get a response within an hour (unless all of us are sleeping).

Other Drupal Resources

JSON-LD sprang out of the requirement for a light-weight Linked Data format for Web Developers. We were working on the Web Payments work and RDFa when we needed something lightweight to do a good Linked Data REST API:

http://payswarm.com/

Anticipated "Lift" for Core Implementation

I think that we've implemented most of the language/API stuff that you'd need. There are up-to-date libraries in PHP and JavaScript that have commercial support via Digital Bazaar. The last remaining bit that we need to settle once and for all is the Framing code for the JSON-LD API... but that's progressing nicely.

Also keep in mind that the W3C just picked up this spec for standardization... so, it's on track to become an official standard at some point in the next year:

http://www.w3.org/2011/rdf-wg/meeting/2012-05-30#line0235

Marketshare

Look at slide #15 for the systems that are currently integrating or have integrated JSON-LD:

http://www.slideshare.net/lanthaler/jsonld-for-restful-services

JSON/XML Flexibility

Since there is a path from JSON-LD to RDF... you can render in RDF/XML - which would be an awful thing to do. Since JSON-LD exposes a tree-based structure, you could also easily convert the key-value pairs into an custom XML-based Linked Data format. I can go into more depth on this if required as it's a big post in and of itself.

Semantics

JSON-LD is all about semantics... after all, it's a Linked Data format in JSON. More about this here:

http://json-ld.org/spec/ED/json-ld-syntax/20120522/#introduction

Support for Semantic Querying

There are two primary ways that JSON-LD can be queried. The first is via the JSON-LD API. You can query by example using the Framing feature of JSON-LD:

http://json-ld.org/spec/ED/json-ld-api/20120524/#framing

To view a framing example in the JSON-LD Playground, go here: http://bit.ly/KLvuTO
Click on the "Framed" tab at the bottom. You will notice that the input data is a flat representation of libraries, chapters and books. The framed output organizes the data into a more hierarchical form using something called a "frame" that places all chapters into books and all books into libraries. This is a mechanism called "query by example". You give the JSON-LD API a JSON object that you'd like to see in the output and it queries the data to find "things" that look like that object.

You can also translate JSON-LD to RDF and put that into a triple/quad store and use SPARQL to query the triple/quad-store.

Semantic Libraries/Tools Using

Aside from the libraries themselves, you can see other projects that are integrating JSON-LD here:

http://www.slideshare.net/lanthaler/jsonld-for-restful-services

Expect to see many more when the spec is finalized in the coming months and released as an official W3C standard.

Hope this helps. :)

I forgot to mention that the JSON-LD Community is open to the public. We have weekly teleconferences, which are also open to the public, are audio-recorded and minuted... example here:

http://json-ld.org/minutes/2012-05-29/

We would be delighted if a couple of you wanted to join us on a call to discuss Drupal's needs. Our calls are on Tuesday at 10am EST, details on joining are here:

http://json-ld.org/minutes/

If that doesn't work, we can setup any other time to have a call that works for a group of you here. We will host the call and can record it (and minute it) so that folks in the Drupal community can listen to the call at a later point or read the minutes. Let me know if this would be helpful and we can arrange a telecon to specifically discuss Drupal issues.

There is also the mailing list where you can drop in questions and will usually get an answer pretty quickly:

http://lists.w3.org/Archives/Public/public-linked-json/