Re: a simplified Turtle-like profile for JSON-LD

ne 31. 3. 2024 v 12:19 odesílatel Michael C. Thornburgh <zenomt@zenomt.com>
napsal:

> i expected this to have come up already, but i didn't find this sentiment
> in
> list archives (including the CG and WG lists) or GitHub issues. i'm sure
> i'm
> not the only one to have thought this, though.
>
> in the interest of brevity (and foreshadowing), i'll leave most of this as
> bullets instead of prose.
>
> * the full JSON-LD spec is large and complex, and isn't really
> "lightweight" (anymore)
> * common implementations are huge (jsonld.js is 1.2 MB unminified, 287 KB
> minified, 84 KB min+gzip)
> * "developer friendly idiomatic JSON":
>   - counterproductive for pure LD applications
>   - coercions and other mappings mean a casual human reader can't actually
> be sure what the document is saying (as RDF)
>   - need to know the JSON schema (formal or informal) of every document
> type one expects to encounter
>   - assumes it's too hard, or too much code, to parse and work with RDF
> directly
>   - relative URIs are desirable; those still need to be resolved
> * external contexts are problematic:
>   - privacy
>   - complexity
>   - availability, especially when disconnected
>   - temporal decoupling
> * i'd use Turtle for pure Linked Data applications, but processing Turtle
> is a lot of code and complexity too, unfortunately
>
> i propose a simplified profile of JSON-LD, inspired by Turtle:
>
> * @context can only define an @base, @vocab, and compact IRI prefixes
> * IRIs are always in an @id member (except for @type)
> * one graph per document (no @graph, use @included if needed)
>
> * no external contexts (documents are self-contained)
> * no recursive compact IRI prefix definitions
> * no coercions (except for @type itself) or other transformations
> * no @index, @reverse, @nest, @protected, @propogate, @import, etc.
>
> i'm calling this the "Terse" profile (since Turtle is the "Terse RDF Triple
> Language"), identified (for now) by profile URI
>
>     http://zenomt.com/ns/jsonld-terse
>
> dereferencing that URI yields a more detailed and precise description of
> the
> constraints.
>
> my reference implementation for this profile is at
>
>     https://github.com/zenomt/jsonld-terse
>
> it's currently 201 lines of plain JavaScript (about 7 KB, GitHub says "170
> loc")
> with no external dependencies, and gzips to 2116 bytes. it parses and
> expands
> conforming documents to interconnected Plain Old JavaScript Objects,
> resolves
> relative URIs given the document's URI and any @base directives, and can
> render a graph as a JSON-LD tree rooted from any node (optionally
> relativizing
> URIs to a provided base, but not "compacting" with an @context) or as an
> array
> of triples. there's a test page included in the repo, and it's published to
> GitHub Pages so there's a live test page to play with.
>
> limitations of this implementation: @list is intentionally not expanded to
> an RDF List, since RDF Lists are harder to work with than JavaScript
> Arrays;
> only URIs are processed, since web browser JavaScript doesn't provide
> native
> IRI processing functions. IRIs in documents might end up transformed to
> URIs
> according to the JavaScript `URL` API.
>
> example Terse JSON-LD document:
> ```
> {
>     "@context": {
>         "@base":  "https://example.com/people/card",
>         "foaf":   "http://xmlns.com/foaf/0.1/",
>         "schema": "http://schema.org/"
>     },
>     "@id": "#me",
>     "@type": ["foaf:Person", "schema:Person"],
>     "foaf:name": { "@value": "Michael Thornburgh", "@language": "en-us" },
>     "foaf:nick": "Mike",
>     "foaf:depiction": { "@id": "mike.jpg" },
>     "schema:worksFor": {
>         "@type": "schema:Corporation",
>         "schema:name": "Example Corp.",
>         "schema:employee": { "@id": "#me" }
>     },
>     "@included": [
>         { "@id": "", "@type": "foaf:PersonalProfileDocument",
> "foaf:primaryTopic": { "@id": "#me" } },
>         { "@id": "_:b86", "foaf:knows": { "@id": "_:b99" } },
>         { "@id": "_:b99", "foaf:knows": { "@id": "_:b86" } }
>     ]
> }
> ```
>
> equivalently expressed as idiomatic Turtle:
> ```
> @base           <https://example.com/people/card> .
> @prefix foaf:   <http://xmlns.com/foaf/0.1/> .
> @prefix schema: <http://schema.org/> .
>
> <#me>
>     a foaf:Person, schema:Person;
>     foaf:name "Michael Thornburgh"@en-us;
>     foaf:nick "Mike";
>     foaf:depiction <mike.jpg>;
>     schema:worksFor [
>         a schema:Corporation;
>         schema:name "Example Corp.";
>         schema:employee <#me>
>     ] .
>
> <> a foaf:PersonalProfileDocument; foaf:primaryTopic <#me> .
>
> _:b86 foaf:knows _:b99 .
> _:b99 foaf:knows _:b86 .
> ```
>
> i hope this is of interest and use to others.
>

Hi Michael

This is great work.  You inspired me to create a minimal subset of JSON-LD,
which focuses on the @id part:

https://linkedobjects.org/Linked-JSON

It's called Linked-JSON, and simply aims to make URIs in JSON first class.
Community feedback is welcome.  Slight interest so far, one researcher at a
uni seems to like it.  If there's more I'll make some libraries.

There is one more possible extension that could align with turtle, and that
is to put <URIs> in angle brackets and then transpile them to JSON-LD.
Unsure whether or not that's a good idea, but it would make JSON(-LD) look
a bit more like turtle.  That part is not yet in the spec, just playing
around with the idea.

Best
Melvin


>
> -michael thornburgh
>
>
>