105 Matching Annotations
  1. Last 7 days
  2. Nov 2022
    1. The @id keyword allows you to give a node a URI. This URI identifies the node. See Node Identifiers in the JSON-LD spec. (The equivalent in Microdata is the itemid attribute, and the equivalent in RDFa Lite is the resource attribute.)
  3. Oct 2022
  4. Sep 2022
  5. Aug 2022
  6. Jun 2022
  7. May 2022
    1. ``` HTTP/1.1 200 OK Content-Type: application/ld+json Link: http://api.example.com/doc/; rel="http://www.w3.org/ns/hydra/core#apiDocumentation"

      { "@context": "http://www.w3.org/ns/hydra/context.jsonld", "@graph": [{ "@id": "http://api.example.com/people", "@type": "hydra:Collection", "api:personByName": "api:PersonByNameTemplate" }, { "@id": "http://api.example.com/events", "@type": "hydra:Collection", "api:eventByName": "api:EventByNameTemplate" } } ```

    1. The GS1 Web Vocabulary collects terms defined in various GS1 standards and data systems and made available for general use following Linked Data principles. It is designed as an extension to schema.org and, where relevant, mappings and relationships arising from that vocabulary are made explicit. The initial focus of the GS1 Web Vocabulary is consumer-facing properties for clothing, shoes, food beverage/tobacco and properties common to all products.
    1. ```html

      <script type="application/ld+json"> { "@context": "https://schema.org", "@type": ["MathSolver", "LearningResource"], "name": "An awesome math solver", "url": "https://www.mathdomain.com/", "usageInfo": "https://www.mathdomain.com/privacy", "inLanguage": "en", "potentialAction": [{ "@type": "SolveMathAction", "target": "https://mathdomain.com/solve?q={math_expression_string}", "mathExpression-input": "required name=math_expression_string", "eduQuestionType": ["Polynomial Equation","Derivative"] }], "learningResourceType": "Math solver" }, { "@context": "https://schema.org", "@type": ["MathSolver", "LearningResource"], "name": "Un solucionador de matemáticas increíble", "url": "https://es.mathdomain.com/", "usageInfo": "https://es.mathdomain.com/privacy", "inLanguage": "es", "potentialAction": [{ "@type": "SolveMathAction", "target": "https://es.mathdomain.com/solve?q={math_expression_string}", "mathExpression-input": "required name=math_expression_string", "eduQuestionType": ["Polynomial Equation","Derivative"] }], "learningResourceType": "Math solver" } </script>


  8. Apr 2022
  9. Mar 2022
  10. Jan 2022
    1. An extension to python markdown that takes metadata embedded as YAML in a page of markdown and render it as JSON-LD in the HTML created by MkDocs.
      • YAML input

        "@context": "http://schema.org"
        "@id": "#lesson1"
          - CreativeWork
        learningResourceType: LessonPlan
        hasPart: {
        "@id": "#activity1"
          "@type": Person
          name: Phil Barker
      • Default JSON-LD output

        <script type="application/ld+json">
        { "@context":  "http://schema.org",
        "@id": "#lesson1",
        "learningResourceType": "LessonPlan",
        "name": "Practice Counting Strategies",
        "hasPart": {
          "@id": "#activity1-1"
        "author": {
          "@type": "Person"
          "name": "Phil Barker"
    1. The metadata that we use for OCX is a profile of schema.org / LRMI,  OERSchema and few bits that we have added because we couldn’t find them elsewhere. Here’s what (mostly) schema.org metadata looks like in YAML:
          - "http://schema.org"
          - "oer": "http://oerschema.org/"
          - "ocx": "https://github.com/K12OCX/k12ocx-specs/"
      "@id": "#Lesson1"
          - oer:Lesson
          - CreativeWork
      learningResourceType: LessonPlan
        "@id": "#activity1-1"
          "@type": Person
          name: Phil Barker
    2. I’ve been experimenting with ways of putting JSON-LD schema.org metadata into HTML created by MkDocs. The result is a python-markdown plugin that will (hopefully) find blocks of YAML in markdown and insert then into the HTML that is generated.
    1. HyperGraphQL is a GraphQL interface for querying and serving linked data on the Web. It is designed to support federated querying and exposing data from multiple linked data services using GraphQL query language and schemas. The basic response format is JSON-LD, which extends the standard JSON with the JSON-LD context enabling semantic disambiguation of the contained data.
    1. {
       "@context": {
        "doap": "http://usefulinc.com/ns/doap#",
        "url": "@id",
        "name": "doap:name",
        "description": "doap:description",
        "author": "doap:maintainter",
        "license": "doap:license", // can we map values to https://spdx.org/licenses/ ?
        "homepage": {"@id": "doap:homepage", "@type": "@id"}
    1. The Annotations API is an extension to the Europeana REST API which allows you to create, retrieve and manage annotations on Europeana objects. Annotations are user-contributed or system-generated enhancements, additions or corrections to (or a selection of) metadata or media. We adopted the Web Annotation Data Model as a base model for the representation of annotations and as a format for exchanging annotations between client applications and the API, but also the Web Annotation Protocol as base HTTP protocol for the API.


        "@context": “http://www.w3.org/ns/anno.jsonld”
        "id": "http://data.europeana.eu/annotations/1",
        "type": "Annotation",
        "created": "2015-03-10T14:08:07Z",
        "creator": {
          "type": "Person",
          "name": "John Smith"
        "generated": "2015-04-01T09:00:00Z",
        "generator": {
            "type": "Software",
            "name": "HistoryPin",
            "homepage": "https://www.historypin.org/"
        "motivation": "tagging",
        "bodyValue": "MyBeautifulTag",
        "target": "http://data.europeana.eu/item/92062/BibliographicResource_1000126189360"
    1. The below illustrates a Dataset Site pointing to feeds consisting of ScheduledSessions, SessionSeries, and Events. As the presence of the webAPI attribute indicates, data items from these feeds are bookable.

      <script type="application/ld+json`/">
         "name":"Example Sessions and Events",
         "description":"Near real-time availability and rich descriptions relating to sessions and events available from Example.com",
            "Physical Activity",
            "description":"Example.com makes it easy to get active!",
            "legalName":"Example Ltd",
               "encodingFormat":"application/vnd.openactive.rpde+json; version=1",
               "totalItems": 1852
               "encodingFormat":"application/vnd.openactive.rpde+json; version=1",
               "totalItems": 361
               "encodingFormat":"application/vnd.openactive.rpde+json; version=1",
               "totalItems": 1906
            "name":"Open Booking API",
            "description":"The Open Booking API lets you to book OpenActive Opportunities. The API uses standard schema.org types and is compliant with the JSON-LD specification.",
            "provider": {
              "@type": "Organization",
              "description":"examplebooking.com makes it easy to get booking!",
            "bookingService": {
              "@type": "SoftwareApplication",
              "name": "nyExampleBookingPlatform",
              "softwareVersion": "1.2",
              "url": "https://www.example.com/myExampleBookingPlatform",
              "featureList": "https://www.example.com"
  11. Dec 2021
    1. {
        "@context": {
          "oa": "http://www.w3.org/ns/oa#",
          "dc": "http://purl.org/dc/elements/1.1/",
          "dcterms": "http://purl.org/dc/terms/",
          "dctypes": "http://purl.org/dc/dcmitype/",
          "foaf": "http://xmlns.com/foaf/0.1/",
          "rdf": "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
          "rdfs": "http://www.w3.org/2000/01/rdf-schema#",
          "skos": "http://www.w3.org/2004/02/skos/core#",
          "text": {
            "@id": "oa:hasBody"
          "target": {
            "@type": "@id",
            "@id": "oa:hasTarget"
          "source": {
            "@type": "@id",
            "@id": "oa:hasSource"
          "selector": {
            "@type": "@id",
            "@id": "oa:hasSelector"
          "state": {
            "@type": "@id",
            "@id": "oa:hasState"
          "scope": {
            "@type": "@id",
            "@id": "oa:hasScope"
          "user": {
            "@type": "@id",
            "@id": "oa:annotatedBy"
          "serializedBy": {
            "@type": "@id",
            "@id": "oa:serializedBy"
          "motivation": {
            "@type": "@id",
            "@id": "oa:motivatedBy"
          "stylesheet": {
            "@type": "@id",
            "@id": "oa:styledBy"
          "cached": {
            "@type": "@id",
            "@id": "oa:cachedSource"
          "conformsTo": {
            "@type": "@id",
            "@id": "dcterms:conformsTo"
          "members": {
            "@type": "@id",
            "@id": "oa:membershipList",
            "@container": "@list"
          "item": {
            "@type": "@id",
            "@id": "oa:item"
          "related": {
            "@type": "@id",
            "@id": "skos:related"
          "format": "dc:format",
          "language": "dc:language",
          "created": "oa:annotatedAt",
          "updated": "oa:serializedAt",
          "when": "oa:when",
          "value": "rdf:value",
          "start": "oa:start",
          "end": "oa:end",
          "exact": "oa:exact",
          "prefix": "oa:prefix",
          "suffix": "oa:suffix",
          "label": "rdfs:label",
          "name": "foaf:name",
          "mbox": "foaf:mbox",
          "nick": "foaf:nick",
          "styleClass": "oa:styleClass",
          "@base": "http://hypothes.is/api/annotations/",
          "id": "@id",
          "tags": "oa:Tag"
        "updated": "2014-09-18T21:43:16.353744+00:00",
        "target": [
            "source": "http://faculty.georgetown.edu/irvinem/theory/Berners-Lee-HTTP-proposal.pdf",
            "pos": {
              "top": 549.5,
              "height": 17
            "selector": [
                "type": "RangeSelector",
                "startContainer": "/div[1]/div[2]/div[4]/div[1]/div[1]/div[2]/div[16]",
                "endContainer": "/div[1]/div[2]/div[4]/div[1]/div[1]/div[2]/div[16]",
                "startOffset": 0,
                "endOffset": 7
                "start": 397,
                "end": 404,
                "type": "TextPositionSelector"
                "type": "TextQuoteSelector",
                "prefix": "information Hypermedia CERNDOC",
                "exact": "ENQUIRE",
                "suffix": "Tim Berners-Lee section group C"
        "created": "2014-09-18T21:32:13.492351+00:00",
        "text": "As featured in \"Weaving the Web\" by Tim Berners-Lee",
        "tags": [
        "uri": "http://faculty.georgetown.edu/irvinem/theory/Berners-Lee-HTTP-proposal.pdf",
        "user": "acct:BigBlueHat@hypothes.is",
        "document": {
          "eprints": {},
          "title": "Berners-Lee-HTTP-proposal.pdf",
          "twitter": {},
          "dc": {},
          "prism": {},
          "highwire": {},
          "facebook": {},
          "reply_to": [],
          "link": [
              "href": "http://faculty.georgetown.edu/irvinem/theory/Berners-Lee-HTTP-proposal.pdf"
        "consumer": "00000000-0000-0000-0000-000000000000",
        "id": "Gk_TW9d_SyCG5cFH4UCy9A",
        "permissions": {
          "admin": [
          "read": [
          "update": [
          "delete": [
    1. Transparent data access

      JavaScript Proxies enable LDflex processors to translate path expressions to SPARQL queries and resolve them through a query engine (e.g. Comunica)

      await [https://julianrojas.org/#me].name
      SELECT ?name WHERE {
        <https://julianrojas.org/#me> <http://xmlns.com/foaf/0.1/name> ?name.
    2. Support for data writing

      LDflex allows for writing/updating knowledge graphs that support SPARQL UPDATE operations such as SPARQL endpoints and Solid pods.

      For example this expression:

      await [https://julianrojas.solid.org/profile/#me].add('foaf:givenName' , 'Julian');

      Will be translated to this SPARQL UPDATE query:

          <http://xmlns.com/foaf/0.1/givenName> "Julian".
    3. How does it work? Thanks to JSON-LD contexts and JavaScript Proxies we can treat Linked Data graphs as local objects The await keyword allows waiting for remote HTTP requests
    4. Traverse Linked Data as JS objects

      await [https://julianrojas.org/#me].name // "Julián Rojas"
      await [https://julianrojas.org/#me].friends.name // ["Ruben Verborgh", "Ruben Taelman", ...]
  12. Nov 2021
  13. Oct 2021
  14. Oct 2020
    1. Over the years, Google has gone from recommending uploading a text file, to parsing RDFa with a slightly modified Microformats vocabulary, to going all-in on Microdata, to then replacing Microdata with JSON-LD and the new Schema.org vocabulary. In the mean time, the Microformats hReview vocabulary hasn't changed, and has continued to be parsed by Google since it is so widely deployed. It would seem there is some advantage to using a format that was developed externally from Google, since they are unable to simply turn their backs on it and replace it with a new format whenever they want. For this reason, I'm sticking with publishing the Microformats 1 hReview markup for my reviews.
  15. Jul 2020
  16. Oct 2018
    1. Components.js is a dependency injection framework for JavaScript applications. Instead of hard-wiring software components together, Components.js allows these components to be instantiated and wired together declaratively using semantic configuration files. The advantage of these semantic configuration files is that software components can be uniquely and globally identified using URIs. Configurations can be written in any RDF serialization, such as JSON-LD. This software is aimed for developers who want to build modular and easily configurable and rewireable JavaScript applications.
    1. If you want to make the Semantic Web a reality, stop making the case for it and spend your time doing something more useful, like actually making machines smarter or helping people publish data in a way that’s useful to them.

      Soooo true !

  17. Sep 2018
    1. RDF Translator is a multi-format conversion tool for structured markup. It provides translations between data formats ranging from RDF/XML to RDFa or Microdata. The service allows for conversions triggered either by URI or by direct text input. Furthermore it comes with a straightforward REST API for developers.
    1. 1 down vote unaccept It's necessary that the term match the IRI you use for the property. For example, schema.org defines name as http://schema.org/name. In your example, you have http://www.schema.org/name. There are also several places where values which should be IRIs (URLs) are treated as text, for this you want to use something like "http://schema.org/image": {"@id": "/static/track_images_200/lr1734_2009720_1372375126.jpg"} Part of term selection looks to be sure that a value matches the appropriate @type definition within the context. For example, image is set to {"@type": "@id"}, so it will only match things that look like that.
    1. { "@context": "https://schema.org/docs/jsonldcontext.json", "@type": ["Article", "NewsArticle", "TechArticle", "ScholarlyArticle"], "author": { "@embed": "@always" }, "creator": { "@embed": "@always" } }
    1. <script type="application/ld+json"> { "@context": "http://schema.org", "@type" : "WebPage", "name" : "The Name of the Webpage", "author" : { "@type" : "Person", "@id": "#tim", "name" : "Tim" }, "creator": { "@id": "#tim" }, "copyrightHolder": { "@id": "#tim" } } </script>
    1. Pitfalls of Framed JSON-LD The choice to provide framed JSON-LD does have some downsides, though. Any entity within the graph that is repeated is only fully referenced in the flattened, framed JSON-LD. This behavior is most evident when viewing an autobiographic work, such as "The autobiography of Benjamin Franklin, 1706-1757". In the example below, you can see that the entity representing Benjamin Franklin is both a schema:creator and a schema:about. However, Benjamin Franklin’s full details only appear in one place in the framed JSON-LD. This is problematic for someone using the data in an object-oriented manner rather than treating it as a graph.
    1. A JSON-LD document is a representation of a directed graph. A single directed graph can have many different serializations, each expressing exactly the same information. Developers typically work with trees, represented as JSON objects. While mapping a graph to a tree can be done, the layout of the end result must be specified in advance. A Frame can be used by a developer on a JSON-LD document to specify a deterministic layout for a graph.
    1. <link rel="alternate" href="manifest.json" media-type="application/webpub+json"/>
  18. Nov 2016
    1. Services rely on the interfaces between them to communicate and for this to work flawlessly, messages must have a format and semantics that every interface can read.

      This makes JSON-LD (JSON for Linking Data http://json-ld.org/) and Hydra (A Vocabulary for Hypermedia-Driven Web APIs) interesting, see http://www.programmableweb.com/news/how-to-build-hypermedia-apis-json-ld-and-hydra/analysis/2015/07/30

  19. Mar 2015