JSON-LD > Teleconference Logs

Joining Teleconferences

All JSON-LD teleconferences are open to the public. Anyone may join and participate in the discussion. All teleconferences are announced at least 24 hours in advance on the JSON-LD mailing list.

Make sure you have a good headset with a microphone as any background noise is distracting to others during the call. If there is excessive noise on your connection, you will be muted until you need to speak. Make sure you join the IRC channel as links and code examples are usually shared over the chat channel.

Text and Audio Logs

The public JSON-LD teleconferences and all of the decisions made in those meetings are listed below. Click on each link to take you to the full text and audio log of the meeting:

  • Text and Audio Minutes for 2014-01-07
  • Text and Audio Minutes for 2013-12-17
    1. Propose that the RDF WG petition the Director to take JSON-LD to Recommendation immediately after the publication of the Proposed Recommendations for the RDF 1.1 work. [permalink]
  • Text and Audio Minutes for 2013-10-22
    1. Apply the fix to the @reverse algorithm as detailed by Markus and merge the fix into the JSON-LD Algorithms prior to Proposed Recommendation publication. [permalink]
  • Text and Audio Minutes for 2013-10-15
    1. Make the JSON-LD WebIDL API non-normative and refer to the Promises specification written by Domenic Denicola and proceed straight to Proposed Recommendation. [permalink]
    2. Allow blank nodes to be used as graph name or property. [permalink]
    3. Support conversion of lists of lists to list objects by preserving the blank node head of the inner list. This resolves feature-at-risk #4 in the JSON-LD API specification. [permalink]
    4. Make an editorial update to the JSON-LD specification to clarify that the @type keyword is context sensitive and make its various usages more clear in the specification. This addresses issue at risk marker #9 in the JSON-LD syntax specification. [permalink]
    5. Keep the @base: null feature in the JSON-LD specification as it is defined in the Candidate Recommendation specification. [permalink]
    6. When processing free-floating nodes, if there is an @index keyword in the node, it is not a free-floating node. [permalink]
    7. The Candidate Recommendation period for JSON-LD is closed as of October 15th 2013. [permalink]
  • Text and Audio Minutes for 2013-10-08
  • Text and Audio Minutes for 2013-10-01
    1. JSON-LD 1.0 and the API will remain in Candidate Rec for an additional week to fix a bug in the spec related to the useRdfType flag and add an additional test. After the spec text has been fixed, and a test created, implementers will be required to file new implementation reports. Once they have done so, the specs will exit CR. [permalink]
  • Text and Audio Minutes for 2013-08-27
  • Text and Audio Minutes for 2013-08-20
    1. Add an issue marker for the "@base": null feature in the JSON-LD API CR specification - it may be modified or removed. [permalink]
    2. Drop relative IRI in the serialize to RDF algorithm. JSON-LD processors are free to include an option that preserves relative IRIs when serializing to RDF. [permalink]
    3. Request that the RDF WG transition the JSON-LD 1.0 and JSON-LD 1.0 API specs to CR, using the shortest possible CR period (don't skip CR) [permalink]
  • Text and Audio Minutes for 2013-08-13
    1. Add an issue marker for @type stating that we may introduce a new keyword to do literal type coercion. [permalink]
    2. Request that the RDF WG publish the JSON-LD 1.0 Candidate Recommendation on August 22nd with a CR period of 4 weeks. [permalink]
    3. Request that the RDF WG publish the JSON-LD 1.0 API spec as a Candidate Recommendation on August 22nd with a CR period of 4 weeks. [permalink]
  • Text and Audio Minutes for 2013-08-06
    1. Interpret objects that do not have a @context entry as the JSON-LD Context when passed into the API functions (via any context parameter). When passing in an array of objects and strings, the same rule applies. Remote context documents specified via a URL are still required to contain an @context key to be a valid JSON-LD Context. [permalink]
    2. RDF WG issue 129, 130, 132, 133, 134, and 135 have been addressed by the group and are resolved. Manu will send out official responses. [permalink]
    3. The JSON-LD test suite will be a living test suite (updated as needed). The version of the test suite when we transition into Candidate Recommendation will be assigned a git tag, so that others can test and report against a static version of the test suite. [permalink]
  • Text and Audio Minutes for 2013-07-23
    1. Adopt Markus' algorithmic change to convert partial lists from RDF to JSON-LD. [permalink]
    2. Make it clear in the specification that objects can be provided to the context parameter can either be JSON-LD Contexts, or objects containing JSON-LD Contexts. [permalink]
    3. The JSON-LD API should process all documents labeled with media types using the application/json or any media type with a +json suffix. Implementations must not follow an HTTP Link Header if you encounter an application/ld+json media type. [permalink]
    4. A remote context MUST be served as application/ld+json. [permalink]
  • Text and Audio Minutes for 2013-07-16
    1. Convert normative appendices A, B, and C to normal normative sections, leaving them at the same location in the document. [permalink]
    2. Fix a bug in the flattening and fromRDF algorithm by not promoting undescribed nodes or datatypes to subjects during the flattening/fromRDF algorithms. [permalink]
    3. Graphs are not free-floating nodes and should not be removed during the flattening or fromRDF algorithm. [permalink]
    4. Add an option to produce "extended RDF", which defaults to false. If the option is true, "extended RDF" will be produced, retaining triples that have blank nodes as predicates. If the option is false, standard RDF will be produced and triples with blank node properties will be discarded. [permalink]
    5. When mapping properties, if the author is not yet ready to commit to a stable IRI, suggest mapping the property to an IRI that is documented as unstable. [permalink]
    6. Link all Basic concept sections to the Advanced Concepts section to ensure that readers understand that there are more advanced concepts associated with the basic features of JSON-LD. [permalink]
  • Text and Audio Minutes for 2013-07-09
  • Text and Audio Minutes for 2013-07-02
    1. Create an issue in the RDF WG to formalize a way to express lists that need to be identified with a URL and annotated using properties. [permalink]
  • Text and Audio Minutes for 2013-06-25
    1. Do not support blank nodes as data types. [permalink]
    2. Raise an error if a blank-node-typed literal is detected. [permalink]
    3. Generalize the LoadContextCallback feature into a LoadDocumentCallback feature and use it for loading both remote contexts and remote documents when necessary. [permalink]
  • Text and Audio Minutes for 2013-06-18
    1. Adopt proposal 2g and replace the first paragraph in the JSON-LD Syntax Introduction with: Linked Data[LINKED_DATA] is a way to create a network of standards-based machine interpretable data across different documents and Web sites. It allows an application to start at one piece of Linked Data, and follow embedded links to other pieces of Linked Data that are hosted on different sites across the Web. [permalink]
    2. In the security considerations section, reference RFC4627 and add text explaining that evaluating the data as code can lead to unexpected side effects compromising the security of a system. [permalink]
    3. Add the following text to the Security Considerations section: When processing JSON-LD documents, links to remote contexts are typically followed automatically, resulting in the transfer of files without the explicit request of the user for each one. If remote contexts are served by third parties, it may allow them to gather usage patterns or similar information leading to privacy concerns. Explain that this can be controlled through effective use of the API. [permalink]
  • Text and Audio Minutes for 2013-06-11
    1. Allow "@container": "@set" for reverse properties. [permalink]
    2. Remove the @type restriction for reverse properties. This also means that a reverse property won't be implicitly type-coerced to @id anymore. [permalink]
    3. Add the following normative text to the JSON-LD Syntax specification: The normative algorithm for interpreting JSON-LD as RDF is specified in the JSON-LD Processing Algorithms and API specification [JSON-LD-API]. [permalink]
    4. Make David Booth's bullet-point addition to the JSON-LD Syntax spec: " * Software developers who want to generate or consume Linked Data, an RDF graph or an RDF Dataset in a JSON syntax." [permalink]
    5. Add spec text to the following effect into the JSON-LD Syntax specification: JSON-LD was designed to be usable directly as JSON, with no knowledge of RDF, but was designed also to be usable as RDF (if desired), for use with other Semantic Web technologies like SPARQL. People intending to use JSON-LD with RDF tools will find it can be used as another RDF syntax, like Turtle. Complete details of how JSON-LD relates to RDF are in Appendix C. [permalink]
    6. Make other editorial changes as needed to avoid implying that JSON-LD is not necessarily RDF. [permalink]
    7. Add spec text to JSON-LD Syntax. Appendix C: JSON-LD is a _concrete RDF syntax_ as described in [RDF11_CONCEPTS]. Hence, a JSON-LD document is both an RDF document and a JSON document and correspondingly represents both an instance of the RDF data model and an instance of the JSON-LD data model. [permalink]
  • Text and Audio Minutes for 2013-06-04
    1. Support reverse properties in JSON-LD 1.0. [permalink]
    2. The default value of the useNativeTypes flag should be set to 'false' in the JSON-LD API. [permalink]
    3. Add explanatory text to the JSON-LD API specification explaining the risks of the useNativeTypes flag and how to do proper conversion to/from native types using the to/from RDF method call. [permalink]
  • Text and Audio Minutes for 2013-05-28
  • Text and Audio Minutes for 2013-05-21
    1. Adopt the language for content negotiation above where the server should try to comply with the request MIME type and profile from the client. [permalink]
  • Text and Audio Minutes for 2013-05-14
    1. Add issue markers to the 2nd Last Call for JSON-LD Algorithms and API to warn about how the useNativeTypes flag and algorithm might change, and to also warn about the details of referencing the DOM-WHATWG spec wrt. Futures may change. [permalink]
  • Text and Audio Minutes for 2013-05-07
    1. Support relative IRIs in @base. [permalink]
    2. @base is always resolved against the current documents URL. @base when set in a remote context document does not apply to the document that imports the remote context. [permalink]
    3. Accept the new Base Resolution Algorithm, which supports setting @base: null (no base value). [permalink]
    4. The API option for 'base' is not set by default. [permalink]
  • Text and Audio Minutes for 2013-04-30
  • Text and Audio Minutes for 2013-04-23
    1. Address ISSUE-125 by adopting a Futures-based approach for the JSON-LD API. [permalink]
    2. When re-defining a term 'A', any previous definition for term 'A' is removed before the right hand side for the new re-definition is evaluated. [permalink]
  • Text and Audio Minutes for 2013-04-16
  • Text and Audio Minutes for 2013-04-09
    1. Express the WebIDL for functions with optional parameters using the method overloading WebIDL pattern. [permalink]
    2. If the result of compaction is an array at the top level, always wrap it in @graph (default graph). This means that the result of compaction will always be an object. [permalink]
    3. When a context is passed into the .compact() function call, it MUST NOT be the 'null' value. If a null value is detected, an error must be thrown. [permalink]
  • Text and Audio Minutes for 2013-04-02
    1. When compacting IRIs @vocab should take precedence over Compact IRIs. This reverses the previous order of precedence. [permalink]
    2. Specify what canonical lexical form is for xsd:integer and xsd:double by referencing the XML Schema 1.1 Datatypes specification. When processors are generating output, they are required to use this form. [permalink]
  • Text and Audio Minutes for 2013-03-26
    1. Publish the JSON-LD Syntax and Algorithms specifications as Final Community Group Specifications (FCGS) and prep the RDF WG Last Call (LC) documents for publication on April 4th 2013. [permalink]
    2. The term selection algorithm should use the '@null' token to specify the null value and the '@none' token to specify the none value. [permalink]
    3. Do not drop empty arrays (sets) and empty lists in expansion and compaction. [permalink]
    4. Remove blank node re-labeling during expansion since it is no longer required. The flattening algorithm must still re-label blank nodes. [permalink]
    5. Change 'optimize' flag to be a 'processingMode' option. The default value for JSON-LD 1.0 processors is 'json-ld-1.0'. Implementers may accept other values, but must ensure that those values are not prefixed with the string 'json-ld'. If the processingMode is set to 'json-ld-1.0', the outcome must be the same as the algorithms. [permalink]
  • Text and Audio Minutes for 2013-03-19
    1. Add the JSON-LD in HTML feature to the JSON-LD Syntax specification without support for @data-context. We are still discussing @data-context and the danger of it forcing a JSON-LD initial context. [permalink]
  • Text and Audio Minutes for 2013-03-12
  • Text and Audio Minutes for 2013-03-05
    1. Remove Property Generators from JSON-LD before Last Call due to no developers needing the feature, the feature having a high potential of misuse, and because of the complexity it adds to the specification. [permalink]
    2. Put JSON-LD Inverse Properties into the JSON-LD 1.0 specification as an at-risk feature. [permalink]
    3. 'base' (passed in via the API) sets the document base, @base (in the document) overrides any value set by 'base' (passed in via the API). [permalink]
    4. Allow @base to be set to the empty string. If @base is set to the empty string, relative IRIs are processed according to RFC 3986 Section 5.2.2 (which is how they're always processed in JSON-LD). [permalink]
  • Text and Audio Minutes for 2013-02-26
    1. Add @base to the JSON-LD syntax as an at-risk feature. [permalink]
    2. Support @base and @language declarations in the @context. Warn developers that JSON-LD contexts that are to be used as remote contexts probably shouldn't include @language or @base. [permalink]
    3. JSON-LD will continue to support blank node identifiers for properties and graph names. When converting data to RDF 1.1, the specification will not introduce any special checks to handle these specific cases. It is up to the implementations to figure out how to convert this data to something conformant to RDF 1.1. [permalink]
    4. Mark property generators as an at-risk feature in JSON-LD 1.0. [permalink]
  • Text and Audio Minutes for 2013-02-19
    1. This group re-affirms that the common practice when naming a graph is to use either an IRI or a blank node identifier. The JSON-LD specification remains unchanged. When expressing graphs in Linked Data, the graph name SHOULD be an IRI. [permalink]
    2. Publish the JSON-LD 1.0 syntax specification as of February 19th 2013 as a Final Community Group Specification. [permalink]
  • Text and Audio Minutes for 2013-02-12
    1. Base future JSON-LD Algorithms 1.0 specification work on Dave Longley's alternate2.html specification, keeping in mind that the group is not suggesting that all algorithms are finalized. Algorithms will need to be clarified further after the base document is picked. [permalink]
    2. Add a JsonLdUrlDereferencer option to the JSON-LD API calls. It can be a function that takes a URL and a callback, and calls the callback with an error or the result of dereferencing that URL. If the option is provided, then the implementation MUST use it to dereference remote contexts. [permalink]
    3. If "@type": "@vocab" is specified for a term in the active context, then processing for the value associated with the term attempts to resolve it as an IRI - first processing it as a term, then a CURIE, then an absolute IRI, then against the active @vocab (if present), then a document-relative IRI. [permalink]
    4. The value space for terms tagged with "@type": "@id" is compact IRI, absolute IRI, relative IRI, the value space for "@type": "@vocab" is term, compact IRI, absolute IRI, @vocab, relative IRI. [permalink]
    5. Within a term definition in the JSON-LD context, document-relative IRIs are not supported. [permalink]
  • Text and Audio Minutes for 2013-02-05
    1. Adopt the 'purpose' and 'general solution' language in Dave Longley's (alternate2.html) specification. [permalink]
  • Text and Audio Minutes for 2013-01-29
    1. "Remove Example 51: Data annotations" and provide different examples showing how data annotations survive expansion/compaction. [permalink]
    2. Rename @annotation to @index and update the prose in section 6.14 to reflect the change. [permalink]
    3. Remove 'form' from the optional parameters for application/ld+json. Add four URL values for 'profile': http://www.w3.org/ns/json-ld#expanded http://www.w3.org/ns/json-ld#compacted http://www.w3.org/ns/json-ld#expanded-flattened http://www.w3.org/ns/json-ld#compacted-flattened [permalink]
  • Text and Audio Minutes for 2013-01-22
  • Text and Audio Minutes for 2013-01-15
    1. Add an at-risk issue on compacting IRIs as relative. [permalink]
    2. Use IRI in the JSON-LD specifications instead of URL. [permalink]
  • Text and Audio Minutes for 2013-01-08
    1. Accept the JSON-LD API spec text on error handling with a few modifications - remove the issueCallback mechanism from JsonLdOptions, remove severity fromJsonLdProcessorIssue, rename JsonLdProcessorIssue to JsonLdError. [permalink]
    2. Rename JSON-LD syntax spec to "JSON-LD 1.0 - A JSON-based Serialization for Linked Data" and the API spec to "JSON-LD 1.0 Processing Algorithms and API (no subtitle)" [permalink]
    3. Do not allow terms as values for @id. [permalink]
    4. The following value types are supported for @id - document relative IRIs, absolute IRIs, and CURIEs. [permalink]
    5. When compacting, attempt to compact absolute IRIs to document-relative IRIs. [permalink]
    6. Include the text "Throughout this specification, the term 'URL' means IRI as defined in RFC3987. The reason we use URL is because it is more familiar to Web developers." and use the term URL everywhere in both specifications. [permalink]
    7. JSON-LD Processors do not modify URLs other than to translate between relative and absolute URLs. Specifically, they do not implement the URL processing rules as outlined in the HTML5 specification. [permalink]
    8. Disallow free-floating values and IRIs in the JSON-LD Data model. If a free-floating value/IRI is detected during expansion, drop the value/IRI. [permalink]
  • Text and Audio Minutes for 2012-12-18
    1. Rename all blank node identifiers when doing expansion. [permalink]
    2. JSON-LD Processors MAY issue validation warnings for malformed IRIs and BCP47 language strings, but they MUST NOT attempt to correct validation errors. [permalink]
    3. Add a .flatten() method to the JSON-LD API, which returns all data in flattened, compact form. Remove the flatten flag from the .expand() and .compact() methods. Ensure that the .flatten() method preserves data in named graphs. [permalink]
    4. Any input to JSON-LD API methods MUST NOT be modified. [permalink]
  • Text and Audio Minutes for 2012-12-11
    1. Remove the .toRDF() and .fromRDF() WebIDL API calls into a separate document that will not be a part of the JSON-LD 1.0 work. The to/from RDF algorithms will still be a part of the JSON-LD API 1.0 work. [permalink]
    2. Add a note to the "Relationship to RDF" section to specify that if clients that do not understand Datasets are to be supported using JSON-LD, that the primary information should go in the default graph. [permalink]
    3. Keep values of @graph that are arrays consisting of just one element as arrays. [permalink]
    4. Do not compact "node references" that are values of @graph to strings. [permalink]
  • Text and Audio Minutes for 2012-12-04
    1. The JSON-LD API specification will define two products: 1) A JSON-LD Implementation, and 2) A JSON-LD Processor, which is dependent on a valid JSON-LD Implementation and implements the asynchronous API. [permalink]
    2. Simplify the error handling mechanism by passing an error object to the callbacks which only consists of an error code and an optional error message containing additional information for debugging. [permalink]
    3. State in the syntax spec that JSON-LD can be used as a RDF graph source. A consumer would just use the default graph and ignore all named graphs in that case. This would allow a server to use, e.g., both Turtle and JSON-LD in content negotiation. [permalink]
  • Text and Audio Minutes for 2012-11-27
    1. When compacting lists, the most specific term that matches all of the elements in the list, taking into account the default language, must be selected. [permalink]
    2. The callback signature for the .toRDF() method should accept Quad[]. That is, the callback is called once after all processing has been completed. [permalink]
  • Text and Audio Minutes for 2012-11-20
    1. Close ISSUE-159 by referencing ISSUE-133: no further actions required. [permalink]
    2. Clarify why the @set keyword exists in the JSON-LD Syntax specification. Namely, it exists if developers want to selectively ensure that a term's values will always be compacted to an array in compacted form. For the avoidance of doubt, @set is allowed in the body of a JSON-LD document and the spec should explain it's use within the @context and the body of the document. [permalink]
    3. Normatively define the concept of a JSON-LD Dataset. In the context of a Dataset, a JSON-LD document including only a default graph serializes a Dataset with only a default graph. A JSON-LD document describing a default graph and/or one or more named graphs serializes a Dataset with default and named graphs. [permalink]
    4. Normatively define the concept of a "JSON-LD document", including description of the scope of blank nodes, which is the scope of the document. [permalink]
    5. Add in the RDF-mapping section Richard is writing a statement that JSON-LD documents serialize datasets (which may contain only a default graph) [permalink]
    6. Align with RDF WG ISSUE-105 (once there is a final decision from the RDF WG) regarding graphs, datasets, authoritative representations, and content negotiation. [permalink]
    7. Retain the ability to specify a JSON-LD context via the 'Link' HTTP header. [permalink]
    8. The rel=http://www.w3.org/ns/json-ld#context relationship replaces the 'describedby' relationship as the mechanism that is used to instruct the JSON-LD processor on which context it should use to interpret the document. [permalink]
    9. Defer creation of a .graphify() mechanism until after JSON-LD 1.0. [permalink]
    10. Place the Algorithms section in the JSON-LD API document before the API section. Make the API section normative, but clarify that implementers MAY provide their own API that is compliant with the Algorithms. [permalink]
    11. State in the definition of each applicable algorithm that the input is a (well-formed) JSON-LD document. State in the conformance section of theAPI/Algorithms/Proce ssing document that the spec does not constrain the behaviour of JSON-LD processors for JSON documents that are not (well-formed) JSON-LD documents. [permalink]
    12. Define "JSON-LD processor" in a Conformance section in the JSON-LD API. [permalink]
  • Text and Audio Minutes for 2012-11-13
    1. If '@container': '@annotation' is added to the JSON-LD Syntax, the feature MUST be round-trippable from .compact() to .expand() back to .compact() [permalink]
    2. Add '@container': '@annotation' to the JSON-LD Syntax. [permalink]
    3. Push the addition of '@container': '@graph' to the JSON-LD Syntax specification off to a later version of JSON-LD. [permalink]
    4. Allow a term to be mapped to null (either directly or by setting @id to null). This mapping is stored in the active context and also overwrites a @vocab mapping meaning that the term does not expand to an IRI and will thus be dropped when expanding. [permalink]
    5. Add a conformance section to the JSON-LD Syntax specification by merging pull request 194. [permalink]
    6. Remove the term node reference as it is not needed; one term (currently node definition) is sufficient. [permalink]
    7. Rename node definition to node object because 1. it doesn't actually “define” a node, and 2. to make more explicit that it is a kind of JSON object [permalink]
    8. Add a statement in the introduction of the JSON-LD syntax specification saying that JSON-LD is a serialization of the RDF data model. [permalink]
    9. Add the following statements to the specs: a) "Authors SHOULD NOT use unconnected nodes (a node definition that does not contain any properties) in JSON-LD documents." b) "Authors SHOULD NOT use blank nodes as edge labels." c) "JSON-LD processors MUST normalize all language tags to lowercase when processing documents via the JSON-LD Algorithms." d) "Blank node labels are scoped to the JSON-LD document." [permalink]
    10. Do not support constructs like "@type":{"@id":"A"} in the spec as that would suggest to developers that they could include other properties of the type there as well. [permalink]
    11. The values of the key-value pairs of a language map MUST be strings or arrays of strings. When expanded, the strings are tagged with the language specified by the key. When compacting, only language-tagged strings will match a term that has a "@container": "@language" mapping. Terms that have a "@container": "@language" mapping MUST NOT be type-coerced. [permalink]
  • Text and Audio Minutes for 2012-11-06
    1. A feature freeze is in effect for JSON-LD 1.0 Syntax and JSON-LD 1.0 API effective November 06th 2012. [permalink]
  • Text and Audio Minutes for 2012-10-23
    1. Move the optional expansion context parameter in the .expand() call into the last JsonLdOptions parameter. [permalink]
    2. Process the 'expandContext' option when performing .compact(). When expanding during the .compact() call, the 'expandContext' is applied first, followed with any other contexts held in the document being processed. [permalink]
    3. When resolving IRIs for @type, first use a term/prefix if that exists, if not use @vocab, if @vocab does not exist, use the BASE IRI to resolve @type. [permalink]
    4. Do not define @vocab as base IRI but as prefix. [permalink]
  • Text and Audio Minutes for 2012-10-16
    1. Add an optional parameter to the application/ld+json mimetype called 'profile' where the value associated with it SHOULD be an IRI. [permalink]
    2. Move all examples in the JSON-LD Grammar section of the spec to the main body and point to them with links. [permalink]
  • Text and Audio Minutes for 2012-10-09
    1. Table issue-140 for the time being, delay discussion until all other issues for JSON-LD 1.0 have been addressed. [permalink]
    2. Adopt Gregg Kellogg's property generator algorithm when expanding/compacting with the following modifications; 1) use node definitions everywhere when expanding, 2) generate bnode IDs for all node definitions without an '@id', 3) use deep comparisons when eliminating node definitions during compaction. [permalink]
    3. Add warning language to the JSON-LD Syntax and API specs noting the most problematic issues when working with property generators. [permalink]
    4. Add a non-normative note to tell implementers that their implementations may have a feature that allows all but one node definition created by a property generator to be collapsed into a node reference. [permalink]
  • Text and Audio Minutes for 2012-10-02
  • Text and Audio Minutes for 2012-09-25
  • Text and Audio Minutes for 2012-09-18
  • Text and Audio Minutes for 2012-09-11
  • Text and Audio Minutes for 2012-09-04
    1. Do not support id-maps via 'container'; '@id' in JSON-LD 1.0. [permalink]
    2. Rewrite the introductory portions of the JSON-LD document to explain JSON-LD in JSON terms first, then describe the advantages of JSON-LD, then rework the Linked Data section as the JSON-LD data model section. [permalink]
    3. Support a 'flatten' option to .expand() and .compact(). The value of the option will be the graph to flatten and return. The default value will be false, to ensure that that the JSON-LD input document is not flattened. [permalink]
    4. Do not support .frame() in JSON-LD 1.0 API. [permalink]
  • Text and Audio Minutes for 2012-08-28
    1. Rename "subject definition" to "node definition" and "subject reference" to "node reference" [permalink]
    2. Change the 'nest'ed terminology to 'scope'ed when referring to @contexts that exist inside of JSON objects. [permalink]
    3. Add a flag to the .compact() and .frame() algorithms that turns off optimization of arrays with single items in them to single values in the output. [permalink]
  • Text and Audio Minutes for 2012-08-21
    1. The group is committed to support language maps and property generators in JSON-LD 1.0. [permalink]
    2. Support optional features in .compact(). Any optional feature that is implemented, MUST be implemented in a specific way as outlined in the JSON-LD API. [permalink]
  • Text and Audio Minutes for 2012-08-14
    1. Do not support an initial context in JSON-LD 1.0. [permalink]
    2. Continue to support 'useNativeDatatypes' in .fromRDF(), specifying how the native type conversion happens. Do not support options for overriding each native datatype with a different value. [permalink]
  • Text and Audio Minutes for 2012-08-07
    1. Do not support a pre-processing step option in the JSON-LD API to transform incoming JSON. [permalink]
    2. Do not support a declarative mechanism that is capable of mapping array position to an RDF property. [permalink]
    3. The JSON-LD API method signatures across all languages are exactly the same. If a developer wants synchronous behavior, they MUST NOT add the callback parameter. Add an issue marker to the JSON-LD API spec stating that this functionality is at risk. [permalink]
  • Text and Audio Minutes for 2012-07-31
    1. Add support for language maps via the "@container": "@language" annotation in @context. For example: "tags": { "@id": "http://example.com/vocab#tags", "@container": "@language"}. The value of the term MUST be an associative array. All associative array keys MUST be BCP47 language strings. [permalink]
  • Text and Audio Minutes for 2012-07-24
    1. When @id is found as a value in an object associated with @type, a handler callback is called to handle the issue. [permalink]
    2. Express the JSON-LD Grammar in prose with supporting tables/examples. Clarify that violating the grammar does not necessarily mean that a JSON-LD processor will not process the document. [permalink]
    3. Support a single term expanding to multiple IRIs when an array of @ids are associated with a single term in the @context. [permalink]
    4. Do not support embedding @contexts within a @context to re-define the IRI that a term maps to. [permalink]
  • Text and Audio Minutes for 2012-07-17
    1. Do not change the prefix-suffix separator from COLON ':' to anything else. [permalink]
  • Text and Audio Minutes for 2012-07-10
  • Text and Audio Minutes for 2012-07-03
    1. Support language-maps via the "@container": "@language" pattern in @context. [permalink]
  • Text and Audio Minutes for 2012-06-26
  • Text and Audio Minutes for 2012-06-19
    1. Support the @vocab keyword for setting a default vocabulary URL for a JSON-LD document. [permalink]
    2. Remove text relating to removing duplicates when expanding JSON-LD documents [permalink]
    3. Do not add any normative language relating to IRI templates or other transformations [permalink]
  • Text and Audio Minutes for 2012-06-12
    1. Attempt to add other @container options, such as "@container": "@language" to support Wikidata's language-map use case. [permalink]
    2. When operating on @type, the result of the expansion algorithm MUST always result in an array of strings that are IRIs. [permalink]
    3. In the expansion algorithm, when expanding the value associated with @type, extract only @id from that value. Any value that does not expand to an absolute IRI MUST be discarded. [permalink]
  • Text and Audio Minutes for 2012-06-05
  • Text and Audio Minutes for 2012-05-29
  • Text and Audio Minutes for 2012-05-22
    1. Defer @graph and, in general, value matching from the framing algorithm. [permalink]
  • Text and Audio Minutes for 2012-05-15
    1. JSON-LD will support a JSON-LD Processor Event mechanism that will report certain events (to be decided later) via a callback given through JSON-LD API calls. [permalink]
    2. The JSON-LD Processor Event callback would be registered for every JSON-LD API call, and would provide the type of event and the data associated with the event for the callback. This mechanism would be used to report potential errors, warnings and when the processing of the document was complete. [permalink]
    3. When a JSON-LD processor processes input that would result in an exception, it should instead call the JSON-LD Processor Event callback with data concerning the issue that was detected. [permalink]
    4. Do not support the @extension keyword at this point in time. [permalink]
  • Text and Audio Minutes for 2012-05-08
    1. In general, for expansion, ensure that all property values are expressed in expanded value form (e.g. {"@value": 5}, {"@value": "foo"}, {"@id": "http://example.com/"}) with the exception of @id and @type. [permalink]
    2. In expanded form, @graph must be expressed in expanded value form (e.g. "@graph": [{"@id": "http://example.com/foo#graph}]) [permalink]
    3. In general, if the author's intent is clear, we should transform the input into proper JSON-LD (keeping the processor mode, if any, in mind - in strict mode, throw exceptions, in lax mode, attempt to interpret the value). [permalink]
    4. When converting toRDF(), any value that is a JSON number that has a fractional value MUST be treated as an xsd:double using the printf("%1.15E", number) representation. [permalink]
    5. There are no mandatory options in the JSON-LD API. Defaults must be specified for all options passed to JSON-LD API methods. [permalink]
    6. The default for the base IRI for JSON-LD API methods is the current document IRI if in a browser context, or the empty string if there is no document context. [permalink]
  • Text and Audio Minutes for 2012-05-01
    1. The result of framing MUST be an object with a @context and @graph property. The value of @graph is always an array containing zero or more results. [permalink]
    2. For framing, use a combination of @preserve and @null, which are replaced in post-processing to avoid the problem of them disappearing during expansion or compaction. [permalink]
    3. If JSON-LD has an initial context, it MUST be specified external to the JSON-LD Syntax specification at a well-known location. [permalink]
    4. In JSON-LD a fragment identifier MAY identify a node in the linked data graph expressed in the document. This idiom, which is also used in RDF [RDF-CONCEPTS], gives a simple way to "mint" new, document-local IRIs to label nodes and therefore contributes considerably to the expressive power of JSON-LD. [permalink]
    5. When round-tripping xsd:boolean values from JSON-LD through expansion and back through compaction, a JSON-native boolean value with xsd:boolean datatype coersion will remain a JSON-native boolean value. [permalink]
    6. @value supports native JSON datatypes such as number, boolean, string. [permalink]
    7. During expansion, a native JSON value with type coercion applied gets expanded to the expanded object form where the value of @value is still in the native JSON form and @type is the type in the type coercion rule. [permalink]
    8. When compacting, if there is a direct match for @type for the property and @type for the property in the context, then the value of the property is replaced with the value of @value. [permalink]
    9. Introduce a 'useNativeTypes' flag for the fromRDF algorithm which, when set, attempts to convert xsd:boolean, xsd:integer, and xsd:double to native JSON values. If the conversion fails the value will be converted to the expanded object notation form. [permalink]
  • Text and Audio Minutes for 2012-04-24
    1. Adopt the 6 points in ISSUE-106 along with Gregg and Longley's proposal for @graph processing in framing as the way we approach named graph support in JSON-LD. [permalink]
    2. JSON-LD keywords MUST NOT be re-defined in the @context. If a JSON-LD processor detects that a JSON-LD keyword is being re-defined, it MUST throw an exception. [permalink]
    3. Do not re-introduce typing JSON-LD @value via something like @datatype or @valuetype. [permalink]
    4. If the result of IRI compaction has an @container @list and there are multiple @list values, throw an exception. When doing IRI compaction do not select terms (other than absolute IRIs) that have @container @list if the value has more than one list. [permalink]
    5. JSON-LD allows sets of lists except where it conflicts with the previous resolution. [permalink]
    6. Remove step #1: "If iri is rdf:type, return @type." from the Compact IRI algorithm. [permalink]
    7. Add an option to the fromRDF algorithm to skip step 5.6 "If the property is rdf:type use @type" to support the use of a term in place of the @type keyword during conversion from RDF to JSON-LD. [permalink]
  • Text and Audio Minutes for 2012-04-10
    1. When performing expansion properties that are coerced to a @container type of @list MUST be placed in an array in expanded form. For example, "prop-iri": [{"@list": [1, 2]}] is correct, "prop-iri": {"@list": [1, 2]} is not. [permalink]
    2. JSON-LD supports multiple aliases for a JSON-LD keyword. [permalink]
    3. Re-affirm that the aliasing of @context is disallowed due to algorithmic complexity/ambiguity and lack of a compelling use case. [permalink]
    4. A @context is processed without regard to keyword aliases. Keyword aliases are taken into account when processing the body of a JSON-LD document. [permalink]
    5. If @graph is the only property in the document's top level object, it MUST be dropped in expansion and compaction. In all other cases (which includes @graph at the document's top level object when there are other properties other than @context at the same level), @graph MUST NOT be dropped in expansion and compaction. [permalink]
    6. The first input parameter for all JSON-LD API methods MAY be an object, an array of objects, or an IRI (DOMString). [permalink]
    7. The second input parameter to the .compact() method is the context that should be used for compaction. The value can be either an object or an IRI. [permalink]
    8. The second input parameter to the .frame() method is the frame that should be used for compaction. The value can be either an object or an IRI. [permalink]
    9. If the optimize flag is not set, the context used for compaction MUST be included without modifications in the resulting document. This applies to both context objects as well as contexts specified by passing an IRI. If the optimize flag is set, a processor is free to modify the context in order to optimize the resulting document body. [permalink]
    10. Remove the normalization algorithm and API from the JSON-LD API specification. The normalization algorithm will be placed into a separate RDF Graph Normalization specification which contains an API for retrieving a set of normalized statements. [permalink]
  • Text and Audio Minutes for 2012-04-03
    1. Do not remove @graph from the JSON-LD syntax. [permalink]
    2. Do not support controlled probing of unlinked objects for this version of JSON-LD. [permalink]
  • Text and Audio Minutes for 2012-03-27
    1. Terms MAY be defined as any valid JSON string. Terms starting with an '@' character SHOULD NOT be used as they may createforward-compatibilit y issues. [permalink]
  • Text and Audio Minutes for 2012-03-20
    1. Using "@list" and "@set" as keys in JSON-LD values that are expressed in expanded form is allowed. [permalink]
    2. During compaction "@set" expressed in expanded form MUST be optimized away if it is not coerced to a "@list". During expansion "@set" MUST be optimized away. [permalink]
    3. The use of "@container" is ignored in the body of a JSON-LD document. [permalink]
    4. The value of the @value key is always transformed to a string by the JSON-LD processor. [permalink]
    5. Unless there are type coercion rules in the @context that apply, native JSON numbers and strings are not modified in compacted or expanded form. [permalink]
    6. Support the use of @language in term definitions to specify the associated @language for the term. If both @type and @language are specified, @language is ignored. [permalink]
    7. If @language is specified at the top-level of a @context, then it applies to all native strings that would be interpreted as plain literals in the JSON-LD body. The @language can be overridden in term definitions by specifying a different @language value, including @language: null, or by specifying a @type for the term. [permalink]
    8. Do not support the direct naming of lists using IRIs in this revision of JSON-LD. [permalink]
    9. Convert all values coerced to xsd:double to strings using the C-syntax formula of "%1.16e". [permalink]
    10. Conform to the requirements of RFC3986, Section 5 (Reference Resolution), when processing IRIs. [permalink]
  • Text and Audio Minutes for 2012-03-13
    1. Unless otherwise specified, when 'null' is used in the @context, it removes any definition associated with the key. [permalink]
    2. If @context is set to 'null', then the active context is cleared or set to the initial context (depending on the resolution to ISSUE-80) [permalink]
    3. Unless otherwise specified, if 'null' is associated with a key in the body of a JSON-LD document, then the JSON-LD processor MUST act as if the key-value pair was never declared. If @value or @list is set to null in expanded form, then the entire JSON object is ignored. [permalink]
    4. If an empty array ([]) used as a value is not subject to @list coercion, then the value MUST be removed from normalized output. The empty array MUST be preserved in compacted and expanded output. [permalink]
    5. When normalizing, anything that is not coerced to a @list container type that has an empty array for its value is removed from the normalized output. [permalink]
    6. When compacting and expanding, anything that is coerced to a @set or a @list container type that has an empty array for its value is preserved in the compacted and expanded output. [permalink]
    7. Unless otherwise specified, when performing the expansion algorithm all values must be contained in a JSON array structure. This does not apply to values for syntactic keys such as @value, @language, @id, and @type when used to specify a datatype. [permalink]
    8. When compacting, anything that is coerced to a @set or a @list container type has its values put into an array in the compacted output, even if there is only one value. [permalink]
  • Text and Audio Minutes for 2012-03-06
    1. Adopt the "@container": "@set" syntax when used in a JSON-LD context to specify that a term is associated with a set of values. [permalink]
    2. When the "@container": "@set" syntax is used in a JSON-LD context for a term definition within the framing algorithm, the resulting term will be associated with a JSON array. [permalink]
    3. Lists of lists are not allowed for JSON-LD 1.0. If a list of lists is detected, the JSON-LD processor MUST throw an exception. [permalink]
  • Text and Audio Minutes for 2012-02-28
    1. For non-JSON-LD values in @context, in general, they are ignored by JSON-LD processors. When compacting, the non-JSON-LD values can be removed. When expanding, the entire @context is removed and thus the non-JSON-LD values are removed. [permalink]
    2. Override part of the decision made in ISSUE-56 - When performing expansion, non-JSON-LD values are not dropped from the document, but are ignored. [permalink]
    3. The @graph keyword is used to express a collection of one or more JSON objects (to express a graph which may or may not be fully connected) [permalink]
  • Text and Audio Minutes for 2012-02-21
    1. If a string is found in an array that is the value of the "@id" key, a JSON-LD Processor MUST throw an exception. [permalink]
    2. Put the discussion of Provenance on hold until the RDF WG produces a proposal for provenance. [permalink]
    3. When expanded form is used, no coercion rules apply to the value expressed in the expanded form. [permalink]
    4. Setting @language to null in the @context clears any coercion rules for language for the JSON subtree. [permalink]
    5. When "@context": null is specified, it clears the active context. [permalink]
    6. If "@language": null is specified in a local context, language coercion is removed from the active context. [permalink]
    7. If '{}' is used as a value in a JSON-LD document, then a blank node identifier MUST be generated for the object during normalization. [permalink]
    8. Remove "form=compacted" from the MIMEType for JSON-LD. [permalink]
  • Text and Audio Minutes for 2012-02-07
    1. If a key in a JSON-LD document contains a colon, it is a CompactIRI if the prefix is defined as a term in the active context, otherwise it is an AbsoluteIRI. The only exception to this rule is if "//" follows the first colon, and in that case, the value is an AbsoluteIRI. [permalink]
    2. If a key in a JSON-LD document contains a colon and the first colon is not followed by "//", it is a CompactIRI if the prefix is defined as a term in the active context, otherwise it is an AbsoluteIRI. [permalink]
    3. Adopt "@container": "@list" syntax to specify container coercion to an ordered list when specified via the @context. [permalink]
  • Text and Audio Minutes for 2012-01-31
    1. When processing keys in a JSON-LD document, ignore keys and do not process the subtree for keys that do not have a mapping in the @context. When compacting and expanding, drop keys that do not have mappings from the output. [permalink]
    2. Mapping a key to _null_ removes a mapping for that key active context [permalink]
    3. A term can only be redefined, never partially reconfigured [permalink]
  • Text and Audio Minutes for 2012-01-24
    1. Constrain the left-hand side of JSON-LD key-value statements by only allowing terms, or prefixed-values, or absolute IRIs. [permalink]
    2. Allow terms, or prefixed-values, or absolute IRIs or relative IRIs on the right-hand side of JSON-LD key-value statements. [permalink]
    3. The lexical space for keys in JSON-LD key-value statements is - if a term - NCName, if a prefix - NCName for the prefix, otherwise the lexical space for an absolute IRI. [permalink]
    4. The lexical space for keys in JSON-LD Context key-value statements is - if a term - NCName, if a prefix - NCName for the prefix, otherwise the lexical space for an absolute IRI. [permalink]
  • Text and Audio Minutes for 2012-01-17
    1. Decouple the JSON-L

      Tools

      • Scribe Tool - The scribe tool makes it easy to clean up minutes recorded in IRC.