15:19:45 <RRSAgent> RRSAgent has joined #json-ld
15:19:45 <RRSAgent> logging to https://www.w3.org/2018/06/29-json-ld-irc
15:19:46 <ivan> rrsagent, set log public
15:19:46 <ivan> Meeting: JSON-LD Working Group Telco
15:19:46 <ivan> Chair: azaroth
15:19:46 <ivan> Date: 2018-06-29
15:19:46 <ivan> Regrets+
15:19:46 <ivan> Agenda: https://lists.w3.org/Archives/Public/public-json-ld-wg/2018Jun/0010.html
15:19:46 <ivan> ivan has changed the topic to: Meeting Agenda 2018-06-29: https://lists.w3.org/Archives/Public/public-json-ld-wg/2018Jun/0010.html
15:42:06 <simonstey> simonstey has joined #json-ld
15:45:49 <ajs6f> ajs6f has joined #json-ld
15:51:05 <azaroth> azaroth has joined #json-ld
15:57:24 <azaroth> present+ Rob_Sanderson
15:57:31 <azaroth> regrets+ Jeff_Mixter
15:58:01 <leonardr> leonardr has joined #json-ld
15:58:12 <ajs6f> present+
15:58:20 <leonardr> present+
15:59:13 <gkellogg> present+ Gregg_Kellogg
15:59:45 <simonstey> present+
16:00:22 <bigbluehat> present+ Benjamin_Young
16:00:36 <leonardr> for some reason I don't have access to the list archives to get the webex info - is it somewhere else?
16:01:31 <dlehn> present+ David_Lehn
16:01:35 <ajs6f> https://mit.webex.com/mw3300/mywebex/default.do?service=1&siteurl=mit&nomenu=true&main_url=%2Fmc3300%2Fe.do%3Fsiteurl%3Dmit%26AT%3DMI%26EventID%3D664756192%26UID%3D0%26Host%3DQUhTSwAAAATND-q04y-TfLQYcgIwWGUieeEi6yOYKKQUaQQ4PwBXor1A_eer-vfo51FTJNQciSQ4zia5OZKbmdtfcrZRyr510%26FrameSet%3D2%26MTID%3Dm468ab485799df7b08cb30e07d45ab08e
16:02:00 <david_newbury> david_newbury has joined #json-ld
16:02:06 <azaroth> Leonard - it should ask for your w3c account details?
16:02:16 <azaroth> regrets- Jeff_Mixter
16:02:17 <leonardr> and I entered them and it didn't like me :(
16:02:20 <azaroth> :(
16:02:27 <ivan> present+
16:02:47 <hsolbrig> hsolbrig has joined #json-ld
16:03:04 <hsolbrig> +present hsolbrig
16:03:12 <azaroth> I'm pretty sure I saw the email that you'd joined the group okay, so I wonder what's up. Ivan, after the call, can you check?
16:03:58 <azaroth> hsolbrig: present+ rather than +present (unless that's an alias?)
16:04:43 <hsolbrig> present+ hsolbrig
16:04:47 <david_newbury> present+ david_newbury
16:06:02 <azaroth> scribenick: david_newbury
16:07:35 <azaroth> topic: approve minutes
16:07:36 <david_newbury> First topic--approving the minutes of the last call.
16:07:37 <bigbluehat> +1
16:07:38 <hsolbrig> +1
16:07:54 <timCole> timCole has joined #json-ld
16:08:00 <david_newbury> +1
16:08:01 <gkellogg> +1
16:08:02 <azaroth> +1
16:08:05 <simonstey> +1
16:08:06 <leonardr> 0
16:08:17 <dlehn> +1
16:08:22 <ivan> +1
16:08:28 <ivan> resolved: last week's minutes approved
16:08:33 <azaroth> RESOLUTION:  Minutes of the last call are approved
16:08:48 <david_newbury> Announcements and reminders
16:09:24 <ivan> Topic: TPAC info
16:09:30 <david_newbury> Tpac: Hotel block extended through the friday night, which means that people who are leaving on Saturday (aka us) couldn't even book.  That's been extended, so everyone can both register and et the hotel at the correct TPAC rate.
16:10:14 <david_newbury> There are diversity scholarships available, so if there are people who are typically underrepresented in the web standards community, and would like to attend, please encourage them to apply for that scholarship fund.
16:11:08 <ivan> Topic: next week telco
16:11:19 <david_newbury> azaroth: Next week is independence day, on July 4th, is anyone then not going able to make next week's call?
16:11:42 <david_newbury> leonardr: I cannot make it
16:12:04 <david_newbury> azaroth:  Nobody else will not be available, it seems, so we will have the call as per normal.
16:12:17 <ivan> Topic: further introductions
16:12:36 <david_newbury> azaroth:  Introductions.  Let's go down the list.  If you were on the call, name and introductions.
16:12:49 <david_newbury> azaroth:  Semantic architect, J. Paul Getty Trust, co-chair
16:13:12 <david_newbury> adam: Apache software foundation, as well as smithsonian
16:13:59 <ivan> present+ Jeff_Mixter
16:14:11 <david_newbury> jeff: OCLC, working with semantic web for the past six years, getting linked data in OCLC's web standards, and working with Rob and others in advancing standards and the new IIIF presentation API.
16:14:47 <david_newbury> benjamin:  here, from Wylie
16:15:00 <bigbluehat> bigbluehat: Benjamin Young, John Wiley & Sons, Co-Chair of JSON-LD also participating in the Publishing WG
16:15:36 <david_newbury> david_lane: working at digital bazzar
16:15:52 <david_newbury> gregg kelllog: Spec Ops, and driver of JSON-lD
16:16:13 <gkellogg> s/kellog/kellogg/
16:16:43 <david_newbury> leonard: adobe systems, but chairs the XMP working group at the ISO, and one of the projects is to create a JSON-LD serialization of XMP, so here to participate.
16:17:04 <david_newbury> simon: research scientist at Seimanns
16:17:21 <david_newbury> tim: Tim Cole, University of Illinois, Urbana Champaign
16:17:56 <david_newbury> ...also working with the web annotation spec
16:18:43 <hsolbrig> harold solbrig: Mayo Clinic
16:18:56 <david_newbury> azaroth: JSON-LD community group has been working on things like framing and other things
16:19:08 <ivan> Topic: overview of the CG documents
16:19:39 <david_newbury> ...so, Gregg, as the main instigator of those drafts, can you go through them rapidly, since most people here understand JSON-LD 1.0 but may not have kept up with the community group changes?
16:20:02 <gkellogg> https://www.w3.org/community/json-ld/
16:20:41 <david_newbury> gkellogg:  The community group made pages, and if you open them, you'll find the updates to the 1.0 document which are obvious in a couple ways.
16:20:45 <gkellogg> https://www.w3.org/2018/jsonld-cg-reports/json-ld/#node-type-indexing
16:21:11 <david_newbury> ...for instance, if you check a section that has changed, you'll see it's highlighted and provides a visual indicator of the parts of the spec that have been changed.
16:21:13 <gkellogg> https://www.w3.org/2018/jsonld-cg-reports/json-ld/#changes-since-1-0-recommendation-of-16-january-2014
16:21:23 <david_newbury> ...there's also a section describing what has changed.
16:21:37 <gkellogg> https://json-ld.org/presentations/JSON-LD-Update-TPAC-2017/assets/player/KeynoteDHTMLPlayer.html#6
16:21:51 <david_newbury> ...rather than walking through the document, I'll point to the presentation that was given at 2017 TPAC, which went over the notable changes
16:22:06 <david_newbury> ...principal is the version announcement, to activate the new processing model
16:22:28 <david_newbury> ...which announces the version 1.1.  Unfortunately, 1.0 did not call out as error conditions things like containers that were out of bounds.
16:22:45 <david_newbury> ...so new features, such as ID container, creating ID maps, requires that the version be specified as 1.1.
16:23:23 <david_newbury> ...ID maps were a requested feature, previously if you have a number of different values, and you needed to cycle through them--we had maps for non-semantic data tags, and this extends it
16:23:44 <ivan> -> https://json-ld.org/presentations/JSON-LD-Update-TPAC-2017/assets/player/KeynoteDHTMLPlayer.html#7 @id Maps
16:23:54 <david_newbury> ...similarly, type maps, which lets you index by type
16:24:06 <ivan> -> https://json-ld.org/presentations/JSON-LD-Update-TPAC-2017/assets/player/KeynoteDHTMLPlayer.html#8 Nested property
16:24:28 <david_newbury> ...nested properties--there are a number of JSON serializations that like to group properties under a non-semantic term, and there are man
16:24:43 <david_newbury> s/, and there are man//
16:25:10 <david_newbury> ...This also allows for several indefinite recursion by fallout of the design
16:25:11 <ivan> -> https://json-ld.org/presentations/JSON-LD-Update-TPAC-2017/assets/player/KeynoteDHTMLPlayer.html#9 scoped contexts
16:25:21 <david_newbury> ...scoped contexts actually solved a number of different problems
16:25:45 <david_newbury> ...it allows you to define a context within a term definition, so the processor will apply the embedded context on top of the context already there
16:26:52 <ivan> -> https://json-ld.org/presentations/JSON-LD-Update-TPAC-2017/assets/player/KeynoteDHTMLPlayer.html#10 scope for @type
16:26:57 <david_newbury> ...scoped contexts can also be used for type values, and they can also be used for objects with multiple types
16:27:05 <david_newbury> ...and if any are used, that scope is applied
16:27:43 <david_newbury> ...that addresses the primary features added by the community group
16:27:54 <david_newbury> ...you can look at the changes for a more comprehensive list.
16:28:12 <gkellogg> https://github.com/w3c/json-ld-syntax/pull/2
16:28:13 <david_newbury> ...these versions of the documents were described in the charter as the basis of this
16:28:34 <david_newbury> ...there are pull requests that the working group should consider, that would pull in the update from the community group that makes it a draft for the working group
16:28:47 <david_newbury> ...there are similar pull requests for the other documents
16:29:17 <david_newbury> ...there is the nice feature that will create a preview of the documents and the diff, against the 1.0 spec, though it might not be useful given the number of changes
16:29:43 <david_newbury> azaroth: worth going through the algorithm and framing changes?  is there a summary around that?
16:29:51 <gkellogg> https://www.w3.org/2018/jsonld-cg-reports/json-ld-api/#changes-since-1-0-recommendation-of-16-january-2014
16:29:57 <david_newbury> gkellogg: there are also changes in the API document
16:30:32 <david_newbury> ...the primary one is to separate the processing from JSON-specific to web-idle (sp?), which allows this specification to be used for alternative serializations such as YAML.
16:31:07 <david_newbury> ...you can see where it's been highlighted to be changed for 1.1, it didn't need a whole re-write, just additional steps
16:31:37 <david_newbury> ...there is support for addl. keys, to support the various features that we use, such as container having different values, prefixes explicit
16:32:24 <david_newbury> ...I'm going to digress--there is an incompatible change from 1.0--a processor running in 1.1--in term selection, when finding a prefix for a compact iris, it adheres to the intention of the 1.0 spec
16:32:46 <david_newbury> ...in 1.0, any term could be used for a prefix--if you had to find a terms for sports, but you had a term for sports_events
16:33:03 <azaroth> e.g. http://schema.org/sports and http://schema.org/sportsEvent --> sports:Event  :(
16:33:39 <david_newbury> ...so there's a change to only map the term to an iri, or in 1.1 a prefix key, which allows it to be explicitly used as a prefix
16:34:17 <david_newbury> ...there's probably too much to go into in that much detail, but there are some changes to the API section, that rely upon portions of the alg. implemented rather than the core alg. itelse
16:34:50 <david_newbury> ...there is a problem that we may run into
16:34:59 <david_newbury> ...the error codes that are defined in 9.4.2
16:35:11 <david_newbury> ...are phrases, and apparently web-idle wants them to be single words
16:35:15 <azaroth> https://www.w3.org/2018/jsonld-cg-reports/json-ld-api/#jsonlderrorcode
16:35:25 <david_newbury> ...so currently there is a RESPEC bug that when we cook this doc doesn't create IRIs for them
16:35:39 <david_newbury> ...we may want to change these error codes, though that would be an incompatibility
16:36:02 <david_newbury> azaroth: any questions about the syntax or the APIs or algorhyms?
16:36:12 <david_newbury> ...less discussion, and more understanding questions?
16:36:28 <azaroth> q?
16:36:39 <ajs6f> q+
16:36:45 <azaroth> ack ajs6f
16:36:54 <david_newbury> ajs6f:  small question--what is web-idle?
16:36:58 <leonardr> WebIDL
16:37:00 <bigbluehat> https://heycam.github.io/webidl/
16:37:20 <david_newbury> gkellogg:  it's a specification--interface definition language
16:37:48 <david_newbury> ...the idea being that you could run a tool that would translate that into the actual interface def. in whatever language you want.
16:38:00 <david_newbury> ...works well for javascript, but not other languages
16:38:03 <bigbluehat> WebIDL Level 1 Recommendation https://www.w3.org/TR/WebIDL-1/
16:38:11 <david_newbury> ...in particular, it allows us to describe promise interfaces
16:38:21 <david_newbury> ...(async interfaces)
16:38:44 <david_newbury> ...so if you look at the expand/compact/flatten interfaces, you can seem them defined
16:38:54 <david_newbury> ...webIDL lets us find these sorts of interfaces
16:39:21 <david_newbury> ...the only way that we have to signal an exceptional condition, causes a promise to fail, which raises an error
16:39:46 <david_newbury> ...otherwise, the alg. are defined to be written in a purer form that does not require any specific interface requirements
16:40:04 <david_newbury> azaroth: any questions about anything?
16:40:17 <david_newbury> ...let's go on to framing
16:40:19 <gkellogg> https://www.w3.org/2018/jsonld-cg-reports/json-ld-framing/
16:40:33 <david_newbury> gkellogg: framing doc is somewhat different, as framing was never defined as a spec.
16:40:59 <david_newbury> ...work was done, but it was not complete, and it was not of interest to 1.1, however it is widely implemented and people are dependent on it.
16:41:15 <david_newbury> ...framing was intended to be use if you have a flat representation--RDF to JSON-LD
16:41:33 <david_newbury> ...you'd get many objects defined at the top level, which is not how people tend to look at these things.
16:42:02 <david_newbury> ...JSON-LD allows you to have similar embedding rules--but how do you get from a flat representation to a embedded representation
16:42:19 <david_newbury> ...framing creates a programming by example, you create a schematic document, that can be matched on different terms
16:42:32 <david_newbury> ...if you have a document that has a specific term, it will match on the type
16:42:54 <timCole> q+
16:42:57 <david_newbury> ...if that framed object contains values, framing will then look for objects that have those values
16:43:07 <david_newbury> ...so we can get back to the types of values that we type to see
16:43:19 <david_newbury> ... it can also be viewed as a query language
16:43:45 <david_newbury> ...but 1.0 matching was somewhat constrained, but there was a lot of work to do on wildcards, literal values with language, things such as that.
16:44:07 <david_newbury> ...1.0 framing did not support named graphs, 1.1 does, either having the top level  be the union or all graphs
16:44:10 <gkellogg> https://www.w3.org/2018/jsonld-cg-reports/json-ld-framing/#changes-since-1-0-draft-of-30-august-2012
16:44:25 <azaroth> ack timCole
16:44:25 <david_newbury> ...ther are changes since the 1.0 draft, but they are based on the document published along.
16:44:26 <leonardr> q+
16:44:43 <david_newbury> timCole: Gregg, the community group has done great work
16:45:11 <david_newbury> ...in regard to framing, we did some early work with compacting, framing, and for moderately large docs it seemed framing, while powerful, was very slow.
16:45:39 <david_newbury> ...do we need to think about moving that into a recommendation, normalizing it, that the implementations be some real performance issues?
16:45:47 <ivan> q+
16:45:54 <david_newbury> ...or do we just worry about the spec, and not care about performance?
16:46:01 <david_newbury> ...the performance cost of that
16:46:03 <azaroth> ack ivan
16:46:04 <gkellogg> q+
16:46:33 <david_newbury> ivan:  from the process w3, the CR phase, the implement checking phase, the recommendation is complete and consistent
16:46:57 <david_newbury> ...which also means that there are no speed requirements by w3.  We may decide to enforce that, but it would not be a requirement.
16:47:09 <azaroth> ack gkellogg
16:47:10 <david_newbury> timCole: what has been the recent experience:
16:47:33 <david_newbury> gkellogg: there's the larger issue of performance of JSON-LD for large values.
16:47:57 <david_newbury> ...It can be used for a dump format.  A document with millions of records in it.  The alg. as defined are not kind for this.
16:48:54 <david_newbury> ... you get into the combanatorial problem--it can be used for querying, but it's not written to take advantage of fast algorithms.
16:49:19 <david_newbury> ...the specs do not require that the alg. precisely, but operate in a way consistent with them.
16:49:38 <david_newbury> ...for instance, they're perscriptive around bnodes, so you must directly implement them
16:50:29 <david_newbury> ...personally, I think that there's other mechanisms that rely on graph querying where framing is specified much more like the construct from SPARQL, and it's not required that we do that, but we should provide some level of expectations around that.
16:50:56 <azaroth> ack leonardr
16:51:06 <david_newbury> ...and the preponderance of those docs, say schema.org, webpages, it's probably perfectly adequate, but you get into cases when there are thousands of objects involved.
16:51:23 <david_newbury> leonard: this seems to be an approach like XSLT for JSON
16:51:33 <david_newbury> gkellogg:  it's similar to that
16:51:39 <bigbluehat> q+
16:51:48 <azaroth> ack bigbluehat
16:52:06 <david_newbury> bigbluehat: Gregg--can you paint a quick picture of framing vs. SHACL or SHeX
16:52:33 <david_newbury> gkellogg: they're used for matching RDF graphs, and there's a certain matching component to this, but the audiences are somewhat different
16:52:52 <david_newbury> ...SHeX can also be used for creating new docs, so it's quite similar.
16:53:06 <david_newbury> ...but they're RDF graph based, so not concerned with tppology
16:53:11 <azaroth> q?
16:53:19 <ivan> s/tppology/topology/
16:53:26 <david_newbury> azaroth: we should look at pull requests
16:53:37 <david_newbury> ... and approve them to be merged
16:53:42 <gkellogg> https://github.com/w3c/json-ld-syntax/pull/2
16:53:52 <simonstey> SHACL https://www.w3.org/TR/shacl-af/ can do that too using rules (not part of the Rec though)
16:53:56 <gkellogg> https://github.com/w3c/json-ld-api/pull/1
16:54:07 <gkellogg> https://github.com/w3c/json-ld-framing/pull/1
16:54:36 <david_newbury> azaroth: no point in reading every line, but can you describe?
16:55:30 <david_newbury> gkellogg:  nominally, the WG is moving from the CG, so we need to change those documents to no longer mention CG, etc.  These define versions of the documents for that.  Pull requests to create as editors drafts versions of these documents for doing changes the group approves of
16:55:44 <ivan> Proposed: the three PR-s (see above) define versions of the document as WG ED-s, serving as a starting point for the WG
16:55:53 <gkellogg> +1
16:55:58 <bigbluehat> +1
16:55:59 <azaroth> +1
16:56:01 <timCole> +1
16:56:05 <dlehn> +1
16:56:06 <simonstey> +1
16:56:08 <ivan> +1
16:56:08 <leonardr> +1
16:56:11 <david_newbury> azaroth: no normative changes, just changes to make the WG drafts.
16:56:12 <david_newbury> +1
16:56:26 <ivan> Proposed: the three PR-s (see above) define versions of the document as WG ED-s, serving as a starting point for the WG, hence merge them
16:56:31 <bigbluehat> +1
16:56:33 <david_newbury> +1
16:56:35 <simonstey> +1
16:56:37 <azaroth> +1
16:56:38 <ajs6f> +1
16:56:39 <leonardr> +1
16:56:40 <gkellogg> +1
16:56:40 <timCole> +1
16:56:41 <hsolbrig> +1
16:56:59 <david_newbury> azaroth:  this doesn't mean we ever need to publish these, but it gives us a starting point
16:57:04 <ivan> Resolved: the three PR-s (see above) define versions of the document as WG ED-s, serving as a starting point for the WG, hence merge them.
16:57:26 <ivan> rrsagent, pointer?
16:57:26 <RRSAgent> See https://www.w3.org/2018/06/29-json-ld-irc#T16-57-26
16:57:49 <david_newbury> azaroth: thank you, and are there any other issues or questions?
16:57:57 <david_newbury> +q
16:58:03 <azaroth> ack david_newbury
16:58:12 <dlehn> I just noted a common copy & paste typo in all the prs
16:58:15 <azaroth> scribenick: azaroth
16:58:57 <azaroth> david_newbury: We were running CONSTRUCT queries that made an index of 200k objects. The major bottleneck was framing, the docs were 1000 lines or so. 500 ms or 1second process, but with 200k objects that was a lot of processing
16:59:09 <azaroth> ... so for indexing style projects, the performance indications are very real
16:59:14 <azaroth> scribenick: david_newbury
16:59:43 <david_newbury> gkellogg: might be to much bike shedding, but maybe there's an alternative around querying...
16:59:45 <ivan> q+
17:00:00 <ajs6f> q+
17:00:06 <azaroth> q?
17:00:17 <azaroth> ack ivan
17:00:24 <ajs6f> q-
17:00:37 <gkellogg> q?
17:00:55 <ajs6f> q+
17:01:11 <david_newbury> ivan: just a remark:  it might be bikesheding, but to make sure we know the (?) to see if the framing document will make it impossible to make optimizations.  That might be vague, but
17:01:35 <david_newbury> ...the blank nodes part, for instance, specified how they are named--there are good reasons, but if that's the bottleneck we should rethink that.
17:01:53 <david_newbury> gkellogg: I agree, but I want to make sure that the complexity vs. something more precise.
17:02:17 <david_newbury> ...it might be that a note that describes an alg., or something with more detail
17:02:44 <david_newbury> azaroth:  for next call, it would be great to go through some design principles so that we have well-understood methods to assess features
17:02:53 <david_newbury> ...to help manage complexity vs. functionality, etc.
17:03:41 <david_newbury> ivan: question on process--when I read through the syntax doc, some errors, editorial, some not--should we create those issues, or should we wait until we know the process?
17:03:56 <david_newbury> azaroth:  just migrate issues, create new issues.
17:04:23 <david_newbury> ....thank you, and we'll meet next week at the same time.
17:04:33 <ivan> rrsagent, draft minutes
17:04:33 <RRSAgent> I have made the request to generate https://www.w3.org/2018/06/29-json-ld-minutes.html ivan