150 Matching Annotations
  1. Sep 2022
  2. Aug 2022
  3. Jun 2022
  4. 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>

      ```

  5. Apr 2022
  6. Mar 2022
  7. Feb 2022
    1. Contemporary digital learning technologies generate, store, and share terabytes of learner data—which must flow seamlessly and securely across systems. To enable interoperability and ensure systems can perform at-scale, the ADL Initiative is developing the Data and Training Analytics Simulated Input Modeler (DATASIM), a tool for producing simulated learner data that can mimic millions of diverse user interactions. view image full screen DATASIM application screen capture. DATASIM is an open-source platform for generating realistic Experience Application Programming Interface (xAPI) data at very large scale. The xAPI statements model realistic behaviors for a cohort of simulated learner/users, producing tailorable streams of data that can be used to benchmark and stress-test systems. DATASIM requires no specialized hardware, and it includes a user-friendly graphical interface that allows precise control over the simulation parameters and learner attributes.
    1. The video profile of the xAPI was created to identify and standardize the common types of interactions that can be tracked in any video player.
  8. 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"
        "@type":
          - CreativeWork
        learningResourceType: LessonPlan
        hasPart: {
        "@id": "#activity1"
        }
        author:
          "@type": Person
          name: Phil Barker
        
      • Default JSON-LD output

        <script type="application/ld+json">
        { "@context":  "http://schema.org",
        "@id": "#lesson1",
        "@type":["CreativeWork"],
        "learningResourceType": "LessonPlan",
        "name": "Practice Counting Strategies",
        "hasPart": {
          "@id": "#activity1-1"
        }
        "author": {
          "@type": "Person"
          "name": "Phil Barker"
        }
        }
        </script>
        
    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:
      "@context":
          - "http://schema.org"
          - "oer": "http://oerschema.org/"
          - "ocx": "https://github.com/K12OCX/k12ocx-specs/"
      "@id": "#Lesson1"
      "@type":
          - oer:Lesson
          - CreativeWork
      learningResourceType: LessonPlan
      hasPart:
        "@id": "#activity1-1"
      author:
          "@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. xAPI Wrapper Tutorial Introduction This tutorial will demonstrate how to integrate xAPI Wrapper with existing content to capture and dispatch learning records to an LRS.

      roll your own JSON rather than using a service like xapi.ly

    1. Storyline 360 xAPI Updates (Winter 2021)Exciting xAPI update for Storyline users! Articulate has updated Storyline 360 to support custom xAPI statements alongside a few other xAPI-related updates. (These changes will likely come to Storyline 3 soon, though not as of November 30, 2021.)
    1. Making xAPI Easier Use the xapi.ly® Statement Builder to get more and better xAPI data from elearning created in common authoring platforms. xapi.ly helps you create the JavaScript triggers to send a wide variety of rich xAPI statements to the Learning Record Store (LRS) of your choice.

      criteria for use and pricing listed on site

    1. Here you will find a well curated list of activities, activity types, attachments types, extensions, and verbs. You can also add to the registry and we will give you a permanently resolvable URL - one less thing you have to worry about. The registry is a community resource, so that we can build together towards a working Tin Can data ecosystem.

      **participant in the Spring 2022 XAPI cohort suggested that 'Registry is not maintained, and they generally suggest using the Vocab Server (which is also the data source for components in the Profile Server).'

  9. www.json.org www.json.org
    1. JSON (JavaScript Object Notation) is a lightweight data-interchange format. It is easy for humans to read and write. It is easy for machines to parse and generate. It is based on a subset of the JavaScript Programming Language Standard ECMA-262 3rd Edition - December 1999. JSON is a text format that is completely language independent but uses conventions that are familiar to programmers of the C-family of languages, including C, C++, C#, Java, JavaScript, Perl, Python, and many others. These properties make JSON an ideal data-interchange language.
    1. The xAPI Vocabulary and Profile Server is a curated list of xAPI vocabulary concepts and profiles maintained by the xAPI community.
    1. xAPI Foundations Leverage xAPI to develop more comprehensive learning experiences. This on-demand e-learning course is available online immediately after purchase. Within the course, you will have the opportunity to personalize your learning by viewing videos, interacting with content, hearing from experts, and planning for your future. You will have access to the course(s) for 12 months from your registration date.
    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. Learning program analytics seek to understand how an overall learning program is performing. A learning program typically encompasses many learners and many learning experiences (although it could easily contain just a few).
    2. Learning experience analytics seek to understand more about a specific learning activity. 
    3. Learner analytics seek to understand more about a specific person or group of people engaged in activities where learning is one of the outputs.
    4. There are many types of learning analytics and things you can measure and analyze. We segment these analytics into three categories: learning experience analytics, learner analytics, and learning program analytics.
    5. Learning analytics is the measurement, collection, analysis, and reporting of data about learners, learning experiences, and learning programs for purposes of understanding and optimizing learning and its impact on an organization’s performance.
    1. Social learning This is a feature the LXP has really expanded. Although some of the more advanced LMSs boast social features, the Learning Experience Platform is better formatted for them and far more likely to provide.  Firstly, the LXP caters for a broader range of learning options than the LMS. It’s usually not difficult to use your LXP to set up an online class or webinar.  LXPs also provide a chance for learners to share their opinions on content: liking, sharing, or commenting on an article or online class. Users can follow and interact with others, above or below them in the organisation. Sometimes LXPs even provide people curation, matching learners and mentors.  Users also have a chance to make the LXP their own by setting up a personalised profile page. It might seem low-priority, but a sense of ownership usually corresponds with a boost in engagement.  As well prepared as Learning & Development leaders are, there’ll be things that people doing a job every day will know that you won’t. They can use their personal experience to recommend or create learning content in an LXP. This helps on-the-job learning and gives employees a greater chance of picking up the skills they need to progress in their role. 
    1. How, exactly, can we design for engagement and conversation? In comparison to content-focused educational technology such as the Learning Management System (LMS), our (not so secret) recipe is this:1. Eliminate the noise2. Bring people into the same room3. Make conversation easy and meaningful4. Create modularity and flexibility

      Spring 2022 #xAPICohort resource

    1. To learn more, there are two books I highly recommend. "Digital Body Language," by Steve Woods, and "Big Data: Does Size Matter?" by Timandra Harkness. If you would like a deeper dive into data-driven learning design, there's a free e-book and toolkit you can download from my blog. You can also reach me there at loriniles.com. Remember, start with the data you have readily available. Data does not have to be intimidating Excel spreadsheets. Be prepared with data every single time you meet with your stakeholders. And before you design any strategy, ask what data you have to support every decision. You're on an exciting journey to becoming a more well-rounded HR leader. Get started, and good luck.

      Spring 2022 #xAPICohort resource

    1. LXPs and LMSs accomplish two different objectives. An LMS enables administrators to manage learning, while an LXP enables learners to explore learning. Organizations may have an LXP, an LMS or both. If they have both, they may use the LXP as the delivery platform and the LMS to handle the administrative work.

      Spring 2022 #xAPICohort resource

    2. 4. Highly intuitive interfaces

      Spring 2022 #xAPICohort resource

    3. 3. Supports various types of learning

      Spring 2022 #xAPICohort resource

    4. 2. Rich learning experience through deeper personalization

      Spring 2022 #xAPICohort resource

    5. Here are some other characteristics that set LXPs apart from LMS’s: 1. Extensive integration capabilities

      Spring 2022 #xAPICohort resource

    6. The gradual shift, from one-time pay to cloud-based subscription-based business has lead learning platforms to also offer Software-as-a-Service (SaaS) models to their clients. As such content becomes part of digital learning networks, they are integrated into commercial learning solutions and then become part of broader LXPs. Looking back at all these developments, from how new data consumption platforms evolved, to the emergence of newer content development approaches and publishing channels, it’s easy to understand why LXPs naturally evolved as a result of DXPs.

      Spring 2022 #xAPICohort resource

    7. The growth of social learning has also created multiple learning opportunities for people to share their knowledge and expertise. As they socialize on these platforms (Facebook, LinkedIn, YouTube, Instagram and many others), individuals and groups learn from each other through various types of social interactions – sharing content, exchanging mutually-liked links to external content. LXP leverage similar approaches in corporate learning environments, and scale learning experience and opportunities with such user-generated content as found in social and community-based learning.

      Spring 2022 #xAPICohort resource

    8. Integrations are also possible with AI. If you integrate LXP and your Human Resource Management (HRM) system, the corporate intranet, your Learning Record Store (LRS) or the enterprise Customer Relationship Management (CRM) system, and collect the data from all of them, you can identify many different trends and patterns. And based on those patterns, all stakeholders can make informed training and learning decisions. Standard LMS’s cannot do any of that. And though LMS developers are trying to get there, they’ve still got a long way to go to bridge the functionality gap with LXPs. As a result, there was an even greater impetus to the emergence of LXPs.

      Spring 2022 #xAPICohort resource

    9. Another driver for the emergence of LXP’s is the standards adopted by modern-day LMS’s – which are SCORM-based. While SCORM does “get results”, it is limited in what it can do. One of the main goals of any corporate learning platform is to connect learning with on-the-job performance. And SCORM makes it very difficult to decide how effective the courses really are, or how learners benefit from these courses. Experience API (xAPI) on the other hand – the standard embraced by LXPs – offers significantly enhanced capabilities to the platform. When you use xAPI, you can follow different parameters both while you learn and perform on the job tasks. And, what’s even better is that you can do that on a variety of digital devices.

      Spring 2022 #xAPICohort resource

    10. LMS’s primarily served as a centralized catalog of corporate digital learning assets. Users of those platforms often found it hard to navigate through vast amounts of content to find an appropriate piece of learning. LMS providers sought to bridge that gap by introducing smart searches and innovative querying features – but that didn’t entirely address the core challenge: LMS’s were still like huge libraries where you should only go to when you have an idea of what you need, and then spend inordinate amounts of time searching for what you specifically want!

      Spring 2022 #xAPICohort resource

    1. Experience API (xAPI) is a tool for gaining insight into how learners are using, navigating, consuming, and completing learning activities. In this course, Anthony Altieri provides an in-depth look at using xAPI for learning projects, including practical examples that show xAPI in action.

      Spring 2022 #xAPICohort resource

    1. The xAPI Learning Cohort is a free, vendor-neutral, 12-week learning-by-doing project-based team learning experience about the Experience API. (Yep, you read that right – free!) It’s an opportunity for those who are brand new to xAPI and those who are looking to experiment with it to learn from each other and from the work itself.

      Spring 2022 #xAPICohort resource

    1. If your current course development tools don't create the activity statements you need, keep in mind that sending xAPI statements requires only simple JavaScript, so many developers are coding their own form of statements from scratch.

      Spring 2022 #xAPICohort resource

    2. An xAPI activity statement records experiences in an "I did this" format. The format specifies the actor, verb, object: the actor (who did it), a verb (what was done), a direct object (what it was done to) and a variety of contextual data, including score, rating, language, and almost anything else you want to track. Some learning experiences are tracked with a single activity statement. In other instances, dozens, if not hundreds, of activity statements can be generated during the course of a learning experience. Activity statements are up to the instructional designer and are driven by the need for granularity in reporting.

      Spring 2022 #xAPICohort resource

    3. xAPI is a simple, lightweight way to store and retrieve records about learners and share these data across platforms. These records (known as activity statements) can be captured in a consistent format from any number of sources (known as activity providers) and they are aggregated in a learning record store (LRS). The LRS is analogous to the SCORM database in an LMS. The x in xAPI is short for "experience," and implies that these activity providers are not just limited to traditional AICC- and SCORM-based e-learning. With experience API or xAPI you can track classroom activities, usage of performance support tools, participation in online communities, mentoring discussions, performance assessment, and actual business results. The goal is to create a full picture of an individual's learning experience and how that relates to her performance.

      Spring 2022 #xAPICohort resource

    1. For any xAPI implementation, these five things need to happen:A person does something (e.g., watches a video).That interaction is tracked by an application.Data about the interaction is sent to an LRS.The data is stored in the LRS and made available for use.Use the data for reporting and personalizing a learning experience.In most implementations, multiple learner actions are tracked by multiple applications, and data may be used in a number of ways. In all cases, there’s an LRS at the center receiving, storing, and returning the data as required.

      Spring 2022 #xAPICohort resource

    2. Experience API (also xAPI or Tin Can API) is a learning technology interoperability specification that makes it easier for learning technology products to communicate and work with one another.

      Spring 2022 #xAPICohort resource

    1. Instructional DesignerWhen implementing xAPI across an organization, there isn’t usually a need for instructional designers to take on new roles or duties. However, they may experience a learning curve that presents an opportunity to understand how to best package and effectively deploy xAPI in newly created content. Your learning designer(s) is a key partner in getting good data, so keep them in the loop regarding your strategy, goals, and expected outcomes.

      Spring 2022 #xAPICohort resource

    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.

      Example:

      {
        "@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`/">
      {
         "@context":[
            "https://schema.org/",
            "https://openactive.io/",
            "https://openactive.io/ns-beta"
         ],
         "@type":"Dataset",
         "@id":"https://data.example.com/",
         "name":"Example Sessions and Events",
         "description":"Near real-time availability and rich descriptions relating to sessions and events available from Example.com",
         "url":"https://data.example.com/",
         "dateModified":"2019-08-25T11:23:27+00:00",
         "keywords":[
            "Courses",
            "Sessions",
            "Events",
            "Activities",
            "Sports",
            "Physical Activity",
            "OpenActive"
         ],
         "schemaVersion":"https://www.openactive.io/modelling-opportunity-data/2.0/",
         "license":"https://creativecommons.org/licenses/by/4.0/",
         "publisher":{
            "@type":"Organization",
            "name":"Example.com",
            "description":"Example.com makes it easy to get active!",
            "url":"https://example.com/home",
            "legalName":"Example Ltd",
            "logo":{
               "@type":"ImageObject",
               "url":"https://cdn.example.com/assets/logo.png"
            },
            "email":"support@example.com"
         },
         "discussionUrl":"https://github.com/example/repo/issues",
         "datePublished":"2019-07-11T00:00:00+00:00",
         "inLanguage":[
            "en-GB"
         ],
         "distribution":[
            {
               "@type":"DataDownload",
               "name":"ScheduledSession",
               "additionalType":"https://openactive.io/ScheduledSession",
               "encodingFormat":"application/vnd.openactive.rpde+json; version=1",
               "contentUrl":"https://example.com/api/openactive/scheduledsessions",
               "totalItems": 1852
            },
            {
               "@type":"DataDownload",
               "name":"SessionSeries",
               "additionalType":"https://openactive.io/SessionSeries",
               "encodingFormat":"application/vnd.openactive.rpde+json; version=1",
               "contentUrl":"https://example.com/api/openactive/sessionseries",
               "totalItems": 361
            },
            {
               "@type":"DataDownload",
               "name":"Event",
               "additionalType":"https://schema.org/Event",
               "encodingFormat":"application/vnd.openactive.rpde+json; version=1",
               "contentUrl":"https://example.com/api/openactive/events",
               "totalItems": 1906
            }
         ],
         "backgroundImage":{
            "@type":"ImageObject",
            "url":"https://cdn.example.com/images/background.jpg"
         },
         "documentation":"https://developer.openactive.io/",
         "accessService":{
            "@type":"WebAPI",
            "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.",
            "documentation":"https://openactive.io/open-booking-api/EditorsDraft",
            "termsOfService":"https://example.com/api/booking/documentation/terms-of-service",
            "provider": {
              "@type": "Organization",
              "name":"examplebooking.com",
              "description":"examplebooking.com makes it easy to get booking!",
              "url":"https://examplebooking.com/home",
              "email":"support@examplebooking.com"
            },
            "endpointUrl":"https://example.com/api/booking/",
            "conformsTo":[
               "https://www.openactive.io/open-booking-api/2.0/"
            ],
            "endpointDescription":"https://www.openactive.io/open-booking-api/2.0/swagger.json",
            "bookingService": {
              "@type": "SoftwareApplication",
              "name": "nyExampleBookingPlatform",
              "softwareVersion": "1.2",
              "url": "https://www.example.com/myExampleBookingPlatform",
              "featureList": "https://www.example.com"
      
      
            }
         }
      }
      </script>
      
  10. 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": [
          "web",
          "history"
        ],
        "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": [
            "acct:BigBlueHat@hypothes.is"
          ],
          "read": [
            "acct:BigBlueHat@hypothes.is",
            "group:__world__"
          ],
          "update": [
            "acct:BigBlueHat@hypothes.is"
          ],
          "delete": [
            "acct:BigBlueHat@hypothes.is"
          ]
        }
      }
      
    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:

      INSERT DATA {
        <https://julianrojas.solid.org/profile/#me> 
          <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", ...]
      
  11. Nov 2021
  12. Oct 2021
  13. 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.
  14. Jul 2020
  15. Jun 2019
  16. Nov 2018
    1. Towards teaching as design: Exploring the interplay between full-lifecycle learning design tooling and Teacher Professional Development.

      This article explores the theory of training teachers as learning designers to promote innovate and creativity. Included in the article are studies of designers with little teaching experience compared with those that are full-cycle teachers and the effect of TPD and LD upon training.

      RATING: 5/5 (rating based upon a score system 1 to 5, 1= lowest 5=highest in terms of content, veracity, easiness of use etc.)

  17. 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 !

  18. 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"/>