Linked Data 
  (And what it can do for the JS developer) 
   
  © 2016 CC-BY-SA  Rein van ‘t Veer
   Rein.van.t.Veer@geodan.nl
 
   Rein.vanVeer@kadaster.nl
 
   Rein.vant.Veer@vu.nl
 
  
    
      Rein van ‘t Veer 
      Been working as pro JS developer for a year, but been hacking away for a few years 
      Brought several identities:
        
          My employer is Geodan 
          I am seconded to the National Cadastre, where, {you do what?} 
          I am a researcher at the Free University of Amsterdam, embedded at Cadastre 
          Today I’m giving a Semantic Web / Linked Data pres, with a twist 
          Most of the semantic web stuff can be done with JS {most, not all} 
          So what’s the SW? 
         
       
     
   
 
  What Is 
  Semantic Web? 
  A movement for changing the web from a collection of documents to a global database of semantically rich information sources; a collection of strategies for gathering and utilizing knowledge.
  Linked Data? 
  The language of the semantic web, highly interoperable, expressed in the Resource Description Framework (RDF)
  
    The web is mostly unstructured. We can structure it from text -> knowledge
    This knowledge part is pretty central. Knowledge is something you can reason about.
    A lot of the intelligence to do with the SW is about reasoning over knowledge.
    We’ll get into that.
   
 
  So… 
  What is RDF, what do you mean by ‘semantic’, what’s the interoperability, how is Linked Data a ‘language’, what collection of strategies is in the semantic web, what global database are you blabbering about?
  I could tell you 
  But then I’d have to… you know
 
  Keep you here for several weeks 
  So… we’re going to do linked data by example. With a twist. Serverless.
  
    
      So, I’m not going to do a talk where I explain all this stuff. 
      Why not: it’s a ‘framework’ - http, vocab/onto, graph analysis; 
      it supports varying use cases, from taxonomies to product SEO 
      So real catch of this talk: no ‘classical’ impression. It’s what I like about the SW 
      We’re making our own social network, with some network analysis. 
     
   
 
  Our own little social network 
  
  
    
      Actually brings people together 
      The only social network without privacy issues 
      Its USP: tell in what circle of acquaintances you participate
{fill in first row} 
      Semi-structured data: table 
      It has table headers. It’s json parsed from csv to keys and values. Semi-structured.
{second row} 
      We have a directed graph, from linked data 
      It allows us to reason over it
{third row} 
      Hey, we have a cyclical graph!
We did actual network analysis on the graph to make an application feature 
      So how does this work? 
     
   
 
  SPARQL 
  
  
  
    
      Who knows him/herself through three degrees {slash} of separation? 
      This (client side) deviates. SW is usually heavy infrastructure. Multi-node stuff. 
      Just a start of what you can do. Like SQL you can aggregate, count, subquery. It’s even more expressive than SQL. 
      This JS impl. is limited in the standard. Normally property paths can be expressed through +, * and {}.
With the used library, you can’t. There’s no support (yet, that’s only a matter of time). 
     
   
 
  Actual SPARQL 
  
  
  
    
      Who knows him/herself through three degrees {slash} of separation? 
      This (client side) deviates. SW is usually heavy infrastructure. Multi-node stuff. 
      Just a start of what you can do. Like SQL you can aggregate, count, subquery. It’s even more expressive than SQL. 
      This JS impl. is limited in the standard. Normally property paths can be expressed through +, * and {}.
With the used library, you can’t. There’s no support (yet, that’s only a matter of time). 
     
   
 
  Semantics 
  
    
        
{
    "@subject": "name",
    "@type": "foaf:Person",
    "@context": {
        "foaf": "http://xmlns.com/foaf/0.1/",
        "@base": "http://mysocialnetwork.org/id/",
        "name": "foaf:name",
        "link": {
            "@id": "foaf:knows",
            "@type": "@id"
        }
    }
}
        
     
 
  
    
      The semantics: strategy called JSON-LD - LD for JSON. It’s a sane way of expressing semantics for JSON 
      In this case, it provides a context for all JSON documents or SN relationships 
      We saw something called FOAF {explain} 
     
   
 
  JSON-LD 
  
  
    
      The JSON-LD is just JSON with some context 
     
   
 
  Some credits 
  This presentation was made using