01:43:42 <RRSAgent> RRSAgent has joined #json-ld
01:43:42 <RRSAgent> logging to https://www.w3.org/2019/09/18-json-ld-irc
01:43:44 <dom> RRSAgent, make log public
01:44:06 <wseltzer> wseltzer has joined #json-ld
01:44:13 <wseltzer> rrsagent, make logs public
01:46:07 <wseltzer> wseltzer has left #json-ld
01:46:17 <dom> Meeting: JSON-LD 1.1 Update
01:47:20 <azaroth> azaroth has joined #json-ld
01:52:16 <koalie> koalie has joined #json-ld
01:52:23 <koalie> RRSAgent, make logs public
01:52:27 <koalie> koalie has changed the topic to: https://w3c.github.io/tpac-breakouts/sessions.html
01:52:30 <koalie> koalie has left #json-ld
01:53:26 <gkellogg> gkellogg has joined #json-ld
01:57:22 <dom> dom has joined #json-ld
02:02:51 <azaroth> azaroth has joined #json-ld
02:03:34 <Zakim> Zakim has joined #json-ld
02:03:42 <azaroth> zakim, this is json-ld
02:03:42 <Zakim> got it, azaroth
02:04:01 <azaroth> rrsagent, set logs public
02:05:59 <azaroth> scribenick: azaroth
02:06:10 <azaroth> present+
02:06:20 <azaroth> gkellogg: Presentation about the updates for 1.1
02:06:44 <ssstolk> ssstolk has joined #json-ld
02:07:33 <azaroth> ... after 1.0 release had a number of languishing issues
02:07:47 <azaroth> ... that didn't make the cut. We started a CG 3 or 4 years ago to do a draft of update
02:08:08 <azaroth> ... work culminated 2 years ago in Burlingame TPAC, WG was chartered
02:08:16 <azaroth> ... addressed some before WG, including indexing data
02:08:33 <azaroth> ... want to index into a set of objects based on the id of those objects
02:08:51 <azaroth> ... added a raft of new ways to use json objects
02:09:13 <bigbluehat> present+
02:09:13 <azaroth> ... Anonymous graphs are used in verifiable credentials, so added ability to put properties in different graphs
02:09:28 <azaroth> ... nesting method in various JSON API, that put various properties under a non-semantic property
02:09:38 <azaroth> ... can put arbitrary depth using @nest
02:09:50 <azaroth> ... JSON-ld 1.0 didn't do recursive lists, which is 1.1
02:09:58 <azaroth> ... scoped contexts within a property or type
02:10:14 <azaroth> ... term definitions importing and then modifying with 1.1 features
02:10:24 <azaroth> ... more capabilities for framing, and a more robust, uniform way to match
02:10:26 <azaroth> ... added JSON literals
02:10:50 <azaroth> ... deprecated blank node properties, most notably in activitystreams context.  Supported in 1.1 but marked for removal
02:10:58 <vivien> vivien has joined #json-ld
02:10:59 <tung_> tung_ has joined #json-ld
02:11:01 <azaroth> ... Normalized the way we extract json-ld from html
02:11:08 <azaroth> ... plus a variety of other features
02:11:09 <kaz> kaz has joined #json-ld
02:11:28 <vivien> present+ Vivien_Lacourba
02:11:28 <azaroth> ... Want to take advantage of the abstraction of the model to allow for alternative serializations such as YAML
02:11:44 <azaroth> ... in 1.1 there needs to be a version announcement:  @version: 1.1
02:12:04 <azaroth> ... this will cause 1.0 processors to fail completely, so 1.0 processors will not process 1.1 contexts incorrectly
02:12:20 <azaroth> ... id maps -- indexed by the uri of the object.
02:12:26 <azaroth> ... [looks at example from spec]
02:12:40 <azaroth> ... Also have type maps, and graph maps
02:13:01 <azaroth> sander: Are the slides online so we can look at them?
02:13:23 <bigbluehat> slides https://json-ld.org/presentations/JSON-LD-Update-TPAC-2019/assets/player/KeynoteDHTMLPlayer.html
02:13:23 <azaroth> gkellogg: Graph containers -- use named graphs in rdf 1.1 without heavyweight syntax
02:13:47 <azaroth> ... Can put triples in a different graph, named by a blank node
02:13:56 <azaroth> ... property in the default graph that references the blank node
02:14:08 <azaroth> ... so BN in object position denotes the graph named by the same blank node
02:14:15 <azaroth> ... not exactly rdf 1.1, but is a common convention
02:14:47 <azaroth> ... Nested properties. See this often in the wild. Lots of features in 1.1 are to adapt to native JSON APIs. One such is putting properties into groups
02:15:08 <azaroth> ... e.g. specific labels within a label group, and the labels get folded up into the main resource semantically
02:16:26 <jc> jc has joined #json-ld
02:16:39 <azaroth> ... 1.0 allowed blank node vocabs to ease burden of people coming to -LD that didn't want to create vocabularies for everything
02:16:57 <azaroth> ... more common in RDF is to use a document relative term.
02:17:54 <azaroth> ... so now @vocab can be a relative URL based against the *document* URL, and thus that we can deprecate blank node properties due to this
02:18:04 <azaroth> ... slide 8
02:18:19 <azaroth> ... We're going through the changes section of the spec, btw
02:18:51 <azaroth> ... Recursive lists come from GeoJSON. Can say it in turtle (rdf:List of rdf:Lists), but couldn't in json-ld 1.0
02:19:08 <azaroth> ... So now any array inside an array that's a List is also a List
02:19:45 <azaroth> question: Can this be any depth?
02:20:04 <azaroth> gkellogg: Yes, any number of lists, in any position
02:20:32 <azaroth> ... did have some fancier versions requested, to have properties for the items, but that got very hairy
02:20:52 <azaroth> ... Scoped contexts -- the ability to define a context within a term within a context
02:21:08 <azaroth> ... if you follow a property to a term with a scoped context, that context comes into effect
02:21:38 <azaroth> ... If we go to a node that has foaf as a scoped context, then it becomes active instead of the higher node's context (e.g. schema.org(
02:21:51 <azaroth> ... can also do this on classes / types, not just properties
02:22:16 <azaroth> ... one of the concerns that came up is that some groups have just JSON interpretation, and important that semantics don't change in lower terms
02:22:34 <azaroth> ... so want to protect that name means something, even if other contexts are used
02:23:11 <azaroth> ... added @protected for terms, and if a downstream context tries to redefine a term, then it will raise an error
02:23:46 <azaroth> ... can only undo this if you have a property that defines a context of null, that wipes out the context.
02:25:08 <azaroth> (discuss extensions)
02:25:27 <azaroth> question: How to validate, with extensions?
02:25:38 <azaroth> gkellogg: Some ways to validate RDF such as shacl and shex that work here as well
02:25:56 <azaroth> ... I run a linter that follows the vocabularies and determines if they're consistent
02:26:22 <azaroth> mmccool: schema validators don't understand extensions but then misspellings can then be okay
02:26:35 <azaroth> bigbluehat: What for rdf validators?
02:26:45 <azaroth> mmccool: Not sure
02:26:54 <dontcallmeDOM> dontcallmeDOM has joined #json-ld
02:27:02 <azaroth> ... need to meet up with the json schema guys
02:27:21 <azaroth> ... like the intro that it's JSON with added semantics. Happy to see the messaging
02:27:29 <azaroth> ... one thing that will help is a unified set of validation tools
02:27:39 <azaroth> ... want to connect this structural constraint with the semantic constraints
02:27:46 <azaroth> gkellogg: SHACL does do this.
02:28:05 <azaroth> bigbluehat: Constant confusion between json-schema and json-ld, which is apples and oranges
02:28:16 <azaroth> ... talking to the json-schema folks to go towards a CG
02:28:31 <azaroth> gkellogg: Will be going to CR soon, which will get more feedback
02:28:33 <jc> jc has joined #json-ld
02:28:36 <azaroth> ... still time to address things
02:28:50 <azaroth> mmccool: think -schema is important because it's used as a sub-schema
02:29:21 <azaroth> (discussion of IETF json-schema debacle)
02:30:02 <azaroth> ... Used in WoT, STF, and in open api
02:30:18 <azaroth> gkellogg: Anything that looks at structure to determine correctness can miss a lot of variations
02:30:23 <azaroth> ... semantic validation needs attention too
02:30:32 <azaroth> ... one of the reasons that we chose RDF as the data model
02:31:36 <azaroth> gkellogg: Imported contexts.  Can import 1.0 contexts, and use it, but also add JSON-LD 1.1 features
02:32:00 <azaroth> ... Can fill in 1.0 gaps with this. Also for other things that we have not done, such as sub-resource integrity
02:33:20 <azaroth> (azaroth explains SRI use case)
02:33:54 <azaroth> mmccool: Frozen contexts that will never change. Don't want to require processing of a context, just as an identifier such that the processing can be cooked
02:34:04 <azaroth> ... ended up waffling a little and saying we might update for errors in the context
02:34:14 <azaroth> ... intent that version number in the URL would be fixed
02:34:44 <azaroth> gkellogg: Not a JSON-LD problem, it's a web problem generally. Other URI schemes that can help address. Advice is to use the document loader and fix the interpretation of the URIs there
02:34:51 <azaroth> ... e.g. never fetch a frozen document
02:35:08 <azaroth> mmccool: out of band a little, as opposed to in band.
02:35:21 <azaroth> bigbluehat: hashlink as well -- URI would indicate that it's cacheable
02:35:37 <azaroth> gkellogg: if you have a local copy you know you can always use it, and have several ways to get the content
02:35:43 <jc> jc has joined #json-ld
02:35:48 <azaroth> bigbluehat: can get via HTTP or IPFS or whatever
02:36:00 <azaroth> mmccool: Interesting in other contexts.
02:36:07 <azaroth> ... agree this is a web problem not JSON-LD
02:36:28 <azaroth> gkellogg: JSON literals.  RDF/XML and RDFA had XML and HTML literals that aren't interpreted, so we added the same for JSON
02:36:50 <azaroth> ... Can put raw JSON that gets preserved in the RDF as a literal, in a canonical form
02:37:10 <azaroth> ... c18n is based on a draft spec but uses js capabilities for ordering and so on
02:37:37 <azaroth> mmccool: what about xml in json?
02:38:07 <azaroth> ... want the structure to be reflected, e.g. turn xml attributes into json properties
02:38:21 <azaroth> gkellogg: XML is complicated by several things :)
02:39:22 <azaroth> ... Included nodes. Recent feature. A way in an object definition to have a block of objects that go along with it.
02:39:35 <azaroth> ... from separate spec, JSON-API
02:40:05 <azaroth> ... Return current resource, plus all related ones. Has also helped in other ways as @graph can be used for identifying named graphs, and at the top level to have a set of objects
02:40:11 <azaroth> ... more consistent just to use @included
02:40:30 <azaroth> ... no property relationship to the top
02:40:55 <azaroth> ... Framing. There is no 1.0 Rec for Framing, but is widely used. Will be 1.1 framing in new Rec.
02:41:06 <azaroth> ... Adds a few capabilities, including order dependent embedding
02:41:20 <azaroth> ... removed requirements for lexical ordering. Embed once rather than embed last
02:41:29 <azaroth> ... support for named graphs in framing
02:41:39 <azaroth> ... would previously only frame the merged graph, now either merged or default
02:42:04 <azaroth> ... can match on ids. Specify a set of ids to match on, only possible in a frame for matching
02:42:12 <azaroth> ... thus match for objects with any of those URIs
02:42:18 <azaroth> ... can be used at lower levels as well
02:42:32 <azaroth> ... e.g. an empty object is a wild card
02:42:44 <azaroth> ... @included in frames, and for @reverse properties
02:42:56 <azaroth> ... better value matching, with wildcarding
02:43:10 <azaroth> ... or matching without an @type (for example)
02:43:38 <azaroth> ... HTML data block extraction spec.  JSON-LD in HTML used since the beginning. Principle reason is schema.org use, in the script block with a type
02:43:47 <azaroth> ... have standardized that and added capabilities
02:44:11 <azaroth> ... set of types that can be applied. In media types can now ask for expanded form, or a frame etc. Can do that in a script tag too
02:44:20 <azaroth> ... with a parameter after the media type
02:44:37 <azaroth> ... investigated doing that for contexts but elected not to do that
02:44:41 <azaroth> they must be json-ld documents
02:45:02 <azaroth> ... but have added a way to do it with content negotiation and a link header, rel=alternate
02:45:08 <azaroth> s/they/... they/
02:45:21 <azaroth> ... we prefer conneg but in static environments not always possible, thus the link header
02:45:55 <azaroth> ... If didn't have jsonld, can embed the reference, and a document loader will follow that link to find the right context doc
02:46:04 <azaroth> ... lightweight mechanism for documenting it
02:46:18 <azaroth> mmccool: looking at directories and core-link (?) format
02:46:36 <azaroth> ... notice you use alternate ... has a special meaning in other contexts
02:46:56 <azaroth> ... might need to find a new rel type
02:47:05 <azaroth> gkellogg: Would be document loader behavior
02:47:41 <azaroth> ... abstracted from json objects to maps, meaning the syntax doc goes to an internal represetnation such as what you would get for JS, and then lets us map out to other formats
02:48:11 <azaroth> mmccool: OCF had a lot of trouble with YAML. JSON quotes names used for keys, YAML does not. Some problems with certain characters not allowed in some places. Some round tripping issues
02:48:22 <azaroth> gkellogg: Should highlight that in the note
02:48:33 <azaroth> mmccool: Can I serialize, parse, reserialize and have the same thing
02:48:42 <azaroth> gkellogg: Also interest in binary, such as CBOR
02:49:08 <azaroth> ... question about literal features that aren't in JSON such as dates
02:49:15 <azaroth> mmccool: also different number precisions
02:49:26 <azaroth> ... extended json-schema for non-json native types such as lengths of numbers
02:49:31 <azaroth> ... may or may not cause the same problem
02:49:40 <azaroth> gkellogg: definitely caveat emptor here!
02:49:54 <azaroth> ... Will align with xsd: data types, so might need c18n algorithms
02:50:06 <azaroth> mmccool: internationalization?
02:50:17 <azaroth> ... text direction!
02:50:24 <azaroth> everyone: dedicated session for this :D
02:50:32 <azaroth> mmccool: We have a bandaid solution
02:50:45 <bigbluehat> Getting Text Direction into RDF https://w3c.github.io/tpac-breakouts/sessions.html#rdf-dir-literal breakout session this afternoon
02:50:46 <azaroth> gkellogg: We won't have an elegant solution, as RDF won't have it yet
02:50:57 <azaroth> ... blank node with a value property or something like that
02:51:21 <azaroth> mmccool: ease of use -- needs to be default text direction, like default language
02:51:41 <azaroth> gkellogg: Yes. Would be good to have @direction in JSON-LD. It's an RDF problem
02:52:10 <azaroth> mmccool: thing that motivates us is inferring from language is impossible. Doesn't always work and in small devices is painful
02:52:30 <azaroth> gkellogg: complete in june. CR in Q4, and we're ready in the next few weeks
02:52:40 <azaroth> ... playground is not fully up to date with the spec
02:52:49 <azaroth> ... (a bit of a problem at times)
02:52:52 <gkellogg> gkellogg has joined #json-ld
02:52:54 <azaroth> ... ruby implementation is up to date
02:53:09 <azaroth> ... working on getting underlying JS implementation updated, as basis of the playground, in the next month or so
02:53:19 <azaroth> ... Call for implementations coming!
02:53:33 <azaroth> ... new implementations as well as updates to 1.0 implementations
02:53:41 <azaroth> mmccool: current implementations?
02:54:08 <azaroth> gkellogg: list of implementations on the site. 1.1 on track are ruby, js and python. Want to see Java. Others include C#, C and erlang
02:54:23 <azaroth> mmccool: C++ useful for embedded devices.
02:54:45 <azaroth> ... js might be okay if it uses a specific subset of features
02:55:24 <azaroth> bigbluehat: request semantics extracted in -js, as then you cut out a lot of security issues and dependencies
02:55:32 <azaroth> ... but still need to get them
02:55:46 <azaroth> gkellogg: if there's an interest, and bandwidth to contribute, a C++ implementation would be great
02:55:59 <azaroth> dave_raggett: testing?
02:56:11 <azaroth> gkellogg: close to accepting implementation reports. Have a full test suite.
02:56:20 <azaroth> ... available for anyone developing, thousands of tests
02:56:26 <azaroth> ... more implementations would be grat
02:56:44 <azaroth> ... Questions? :)
02:57:04 <azaroth> ssstolk: JSON literals very nice. Seeing in GIS sector prefer to use well known text type
02:57:30 <azaroth> ... states coordinates in a particular way. So JSON literals will help there.
02:57:42 <azaroth> dave: what kind of information do you have about usage?
02:57:51 <azaroth> ... a report to management sort of thing
02:58:17 <azaroth> gkellogg: web of things is a major use. Automotive. Hard to track.
02:58:26 <azaroth> mmccool: who would we like to be using it?
02:58:47 <azaroth> ... Have things converge, such as Open API.
02:59:11 <azaroth> gkellogg: There's lots of bias to overcome
02:59:22 <azaroth> bigbluehat: thankfully top people at open api are not opponents
02:59:32 <azaroth> ... you guys have started to map json-schema terms to a vocab
02:59:41 <azaroth> mmccool: json-schema as json-ld also a good target
03:00:03 <azaroth> gkellogg: talked about it a bit. Seems like an interest group?
03:00:23 <azaroth> draggett: CG or IG
03:00:33 <azaroth> gkellogg: There is a CG, which is dormant at the moment when the WG is done
03:00:42 <azaroth> ... but best form for advocacy?
03:00:59 <azaroth> draggett: CG would be good for advice. MDN is good for JS in the browser ... would those guys pick it up?
03:01:08 <azaroth> bigbluehat: json-ld going into chrome's lighthouse.
03:01:13 <azaroth> gkellogg: MDN would be nice
03:01:25 <azaroth> bigbluehat: From what dom has said, if you show up with content and willing to maintain it
03:01:35 <azaroth> ... then they're okay to include it
03:02:02 <azaroth> gkellogg: If google interested, esp given lighthouse inclusion, then have some resources maybe
03:02:19 <azaroth> bigbluehat: in context of integration, growing pattern to have an active CG with an active WG and run in tandem
03:02:37 <azaroth> ... rather than ebb and flow between the two
03:02:45 <azaroth> ... keeping in parallel would be good
03:03:02 <azaroth> gkellogg: Group is very close to CR. But have notes to do
03:03:30 <azaroth> bigbluehat: Figuring out what JSON-LD needs is a big part. applications of it is a different part
03:03:48 <azaroth> gkellogg: a cg might maintain a timeline, get input as to what to see on that, and use it to drive interest
03:04:04 <azaroth> ssstolk: DCAT?
03:04:33 <azaroth> gkellogg: JSON-LD widest RDF representation
03:04:45 <azaroth> gkellogg: for 1.0 it wasn't quite full rdf 1.1, but now it is
03:04:56 <azaroth> mmccool: upgrading applications to use 1.1?
03:05:09 <azaroth> gkellogg: schema.org to use 1.1 features would be very good :)
03:05:29 <azaroth> bigbluehat: schema.org user base is authors, not context folks. Not clear how search engines use it internally
03:06:06 <azaroth> ... need to push processing of the SEO driven content. Want to go to lighthouse rather than structure data testing tool
03:06:27 <azaroth> ... maybe merging pieces is one task of the CG
03:06:34 <azaroth> gkellogg: need to kickstart the CG again
03:06:43 <azaroth> ... should see people to step up :)
03:07:05 <azaroth> bigbluehat: could do a monthly call in the CG
03:07:13 <azaroth> TOPIC: Adjourn :)
03:08:02 <azaroth> rrsagent, draft minutes
03:08:02 <RRSAgent> I have made the request to generate https://www.w3.org/2019/09/18-json-ld-minutes.html azaroth
03:08:28 <azaroth> zakim, set log public
03:08:28 <Zakim> I don't understand 'set log public', azaroth
03:08:34 <azaroth> rrsagent, set log public
03:09:08 <azaroth> present+ gregg_kellogg
03:09:14 <azaroth> present+ Michael_McCool
03:09:21 <azaroth> present+ Dave_Raggett
03:09:25 <azaroth> present+ bigbluehat
03:09:30 <azaroth> present+ ssstolk
03:09:35 <azaroth> rrsagent, draft minutes
03:09:35 <RRSAgent> I have made the request to generate https://www.w3.org/2019/09/18-json-ld-minutes.html azaroth
03:11:02 <azaroth> azaroth has joined #json-ld
03:29:13 <azaroth> azaroth has joined #json-ld
03:30:11 <azaroth_> azaroth_ has joined #json-ld
04:11:45 <gkellogg> gkellogg has joined #json-ld
04:15:49 <toyo> toyo has joined #json-ld
04:20:00 <gkellogg> gkellogg has joined #json-ld
04:28:09 <kaz> kaz has joined #json-ld
04:29:39 <dontcallmeDOM> dontcallmeDOM has joined #json-ld
04:31:33 <azaroth> azaroth has joined #json-ld
04:43:59 <dom> dom has left #json-ld
05:04:13 <azaroth> azaroth has joined #json-ld
05:22:15 <Zakim> Zakim has left #json-ld
05:24:29 <gkellogg> gkellogg has joined #json-ld
05:35:19 <gkellogg> gkellogg has joined #json-ld
05:36:06 <azaroth> azaroth has joined #json-ld
05:37:13 <azaroth> azaroth has joined #json-ld
05:41:42 <jc> jc has joined #json-ld
05:42:16 <jc> jc has joined #json-ld
05:45:28 <kaz> kaz has joined #json-ld
05:46:59 <jc_> jc_ has joined #json-ld
05:49:38 <jc> jc has joined #json-ld
05:57:07 <jc> jc has joined #json-ld
05:59:56 <vivien> vivien has left #json-ld
06:04:07 <jc> jc has joined #json-ld
06:16:05 <jc> jc has joined #json-ld
06:22:04 <jc_> jc_ has joined #json-ld
06:24:27 <jc> jc has joined #json-ld
06:31:29 <azaroth> azaroth has joined #json-ld
07:33:57 <azaroth> azaroth has joined #json-ld
07:34:32 <azaroth_> azaroth_ has joined #json-ld
07:39:24 <jc> jc has joined #json-ld
08:28:34 <azaroth> azaroth has joined #json-ld
08:35:47 <jc> jc has joined #json-ld
08:38:54 <azaroth> azaroth has joined #json-ld
08:40:17 <jc> jc has joined #json-ld
08:40:38 <jc> jc has joined #json-ld
08:41:16 <gkellogg> gkellogg has joined #json-ld
08:51:14 <jc> jc has joined #json-ld
09:03:38 <azaroth> azaroth has joined #json-ld
09:04:27 <jc> jc has joined #json-ld
09:09:10 <azaroth_> azaroth_ has joined #json-ld
09:20:17 <jc> jc has joined #json-ld
09:21:59 <jc> jc has joined #json-ld
09:28:50 <jc> jc has joined #json-ld
09:30:52 <azaroth> azaroth has joined #json-ld