Building a decentralized Semantic Web

Despite our strong focus on identity,
we struggle to find our own.

• What unites a Semantic Web research community?
  • Is it Web?
  • Is it Semantics?
• We’ve emerged at the intersection of other domains.
  • databases
  • logic
  • Web
  • …
• What are the semantics we can attach
  to our own identity?

Exactly how much semantics
is enough semantics?

A little semantics
goes a long way.

Jim Hendler

Exactly how much semantics
is too much semantics?

Ontologies are like underwear.

Everyone agrees they’re a good idea,
but few people like to reuse someone else’s.

anonymous

Domain models are only as valuable as
the scope of the underlying consensus.

• Ontology engineering methodologies
  often use clean room processes.
  • formalization by domain experts
• What about parties that were not involved
  in the consensus process?
  • selective reuse (if any at all)
  • loose interpretation of semantics

Core frameworks such as RDF and OWL
are perceived as complex by developers.

• Developers want to mark up data.
  • lack of deeper understanding
  • different from existing development practice
• Ontologies are in practice often
  dumbed down to vocabularies.
  • stripping the data from semantics
  • once again leaving it up to individual applications

Schema.org fills the void for
a more pragmatic audience.

• Such markup is handy for discovery and search,
  but limited for other purposes.
• This leads to a heterogeneous
  and underspecified Web of Data.
• Great for big harvesters,
  much less so for individual agents.

There is a mismatch between ontologies
in theory and in practice.

• owl:sameAs performs great in experiments
  • …but it has so many different meanings
    that it has lost all meaning in practice.
• Reasoning bridges gaps between ontologies.
  • In practice, you better write your query in exactly
    the same ontology as the SPARQL endpoint’s
  • …because in practice, reasoning is never switched on.

If semantics do no truly set us apart,
then maybe it is the Web.

• The Web is vastly different from databases.
  • infinite domain of discourse
  • contradictions allowed and encouraged
• No single RDF document contains the truth.
  • Any sufficiently large collection of documents
    will be internally inconsistent,
    and thus allow us to derive any truth.

“Web” is our main argument in
justifications for RDF’s complexity.

• Our problems span the virtual address space
  of the globe and in fact the universe.
• Our ontologies are spread all over the place.
  • Some of them even don’t dereference anymore!
• The Web is the reason why
  we cannot all just use Schema.org.

So why are we so afraid then
to take our work to the Web?

• It works in our university basement
  is an acceptable and applauded narrative.
• We claim the Web as source of our intricacies,
  while ignoring all of the Web’s difficulties.
• The Web looks nothing like your basement.

What is the external validity
of our controlled experiments?

• Controlled experiments lead to valuable insights
  through easily reproducible findings.
• If the discrepancy with actual conditions
  becomes too large, findings become irrelevant.
• When a measure becomes a target,
  it ceases to be a good measure.
  • But was it ever?

Are we solving all the problems
we should be solving?

The Semantic Web research community
might have a habit of handwaving.

• This paper presents the (hard) research,
  engineers will do the (simple) rest.
  • If the gap between theory and practice is so big,
    much more research is likely required.

The Web is a good platform for data publication,
but a pretty bad platform for data consumption.

Frank van Harmelen

When looking for an identity
it helps to know who you are.

2012

We are totally doing Big Data.

2016

We are totally doing blockchain.

2019

We are totally doing AI.

And I agree on that last point (just not necessarily ML).

The Semantic Web teenage years
have perhaps been a bit confusing.

• We’re almost being apologetic
  about not being something else.
• Let’s not try to be the cool kid.
• What are our core strengths?
  What challenges are we best positioned to tackle?

Perhaps Linked Data is actually
more challenging than Big Data.

• An huge amount of homogeneous data in one place
  creates ideal conditions for processing and analysis.
• Size does matter, just not always
  in the way others think.
  • A small number of very large data sets is easier to manage
    than a very large number of small data sets.
  • The level of heterogeneity and distribution of Linked Data
    cannot be tackled adequately with Big Data techniques.

Big Data is finite,
no matter how big it gets.

• The Big Data fallacy disregards diminishing returns.
  • At some point, harvesting more data does not
    yield proportionally more knowledge anymore.
• Very good reasons exist
  for data to live in different places.
  • legal
  • organizational
  • economical

The Web strives to be universal
through independence of many factors.

• Anyone can use the Web, regardless of:

  hardware

  desktop

  phone

  tablet

  watch

  …

  software

  operating system

  browser

  app

  …

• Developers are free to innovate.
  • build for the Web
  • standards provide interoperability

The Web brings freedom of expression
to everyone across the world.

• Anyone can say anything about anything.
• We all have our own spaces,
  so we don’t have to agree.
• We can link to opinions of others
  to discuss about them.

A generation of social platforms
helped people interact and share.

The Web brings permissionless innovation
at a global scale.

• Anyone can build anything for any reason.
• You don’t need anyone’s permission
  to join the Web and launch a new idea.
  • not the case in app stores

Permissionless innovation has brought
unprecedented creativity to the world.

Like other systems at the time,
the Web was designed decentrally.

• Internet
• email
• NNTP
• …

Its novelty was universality.

The first threat to universality
were the browser wars.

• No Internet Explorer?
  • you’re out of luck!
• People needed a certain computer.
  • no mobile devices
• Developers depended on Microsoft’s pace.
  • browsers were not very powerful

This battle was replaced by another:
the search engine wars.

• Not on Google?
  • you’re out of luck!
• Ranking high became more important
  than high-quality content.
• The reach of your innovations
  depended on one crawler.

This battle was also replaced by another:
the platform wars.

• Not on Facebook?
  • you’re out of luck!
• Clicks became more important
  than high-quality content.
• You either compete for innovation
  with Facebook, or depend on it.

The current massive centralization
hurts diversity, innovation, and choice.

• If you can build 1 API integration
  • will it be facebook.com or private-identity-provider.org?
• Developers depend on centralized platforms
  for data and identity.
  • …or they have to become such a platform themselves
• People lose control of their data
  and cannot easily switch to other apps.
  • innovation cannot attract locked-in customers

Ironically, permissionless innovation
even allows platforms that prevent it.

The Facebook founder has no intention of
allowing anyone to build anything on his platform
that does not have his express approval.

Having profited mightily from the Web’s openness,
he has kicked away the ladder that elevated him
to his current eminence.

John Naughton, The Guardian

People choose where they store
every single piece of data they produce.

They can grant apps and people access
to very specific parts of their data.

Separating app and storage competition
drives permissionless innovation.

Solid is not a company or organisation.
Solid is not (just) software.

• Solid is an ecosystem.
  • standards enable interoperability
• Solid is a movement.
  • shifting the app builder mindset
• Solid is a community.
  • different people, companies, and organisations

The Solid server acts as a data pod
that stores and guards your data.

• a regular Web server
  • with support for access control
  • with support for Linked Data
• application-agnostic
  • build any application
  • application-specific logic resides in clients
• just like your website
  • your data can be opened with any app

A typical data pod can contain
any data you create or need online.

• profile 👤
• photos 🖼
• comments 🗣
• likes 👍
• … ✨

Solid clients are browser or native apps
that read from or write to your data pod.

• You give apps permission.
  • Choose very precisely what they can access.
• Friends give you permission.
  • Choose very precisely what you can access.
• Apps deliver a unified experience.
  • Browse your friends’ pictures along with yours.

Any app you can envision,
you can build with Solid.

• calendar 📅
• social feed 👥
• photo sharing 📸
• conference organization system 🎤
• … ✨

The Solid server and several apps exist
and are usable for developers.

• Solid server
  • store your data online with access control
  • free storage at solid.community and inrupt.net
• apps
  • data browser
  • contacts
  • photos
  • meeting organizer
  • …
• libraries
  • authentication
  • data processing
  • …

Decentralized apps have many back-ends. Back-ends work with many apps.

Interoperability challenges in Solid
are solved through Linked Data in RDF.

• If we all store our own data,
  how do we connect it to others’ data?
• How can apps share data,
  without too many prior agreements?
• How do we integrate data
  from multiple data pods?

With JSON-LD, every piece of data
can link to any other piece of data.

{
  "@context":  "https://www.w3.org/ns/activitystreams",
  "id":        "#ruben-likes-ldac2019",
  "type":      "Like",
  "actor":     "https://ruben.verborgh.org/profile/#me",
  "object":    "http://linkedbuildingdata.net/ldac2019/#this",
  "published": "2019-04-25T08:00:00Z"
}

Data shapes and their semantics
enable layered compatibility.

{
  "@context":  "https://www.w3.org/ns/activitystreams",
  "id":        "#ruben-likes-ldac2019",
  "type":      "Like",
  "actor":     "https://ruben.verborgh.org/profile/#me",
  "object":    "http://linkedbuildingdata.net/ldac2019/#this",
  "published": "2019-06-19T08:00:00Z"
}

Different source data
can be concatenated.

{
  "@context":  "https://www.w3.org/ns/activitystreams",
  "@graph": [{
    "type":      "Like",
    "actor":     "https://ruben.verborgh.org/profile/#me",
    "object":    "http://linkedbuildingdata.net/ldac2019/#this",
    "published": "2019-06-19T08:00:00Z"
  },{
    "type":      "Like",
    "actor":     "https://example.org/people/rui#me",
    "object":    "http://linkedbuildingdata.net/ldac2019/#this",
    "published": "2019-06-19T08:05:00Z"
  }]
}

The developer experience is the most
crucial factor for Solid success.

• Front-end developers build
  the apps people see.
• Together with UX designers,
  they bring Solid to people.
• Enabling developers
  means enabling ourselves.

Simple tasks should be simple,
complex tasks should be manageable.

People think RDF is a pain
because it is complicated.
The truth is even worse.

RDF is painfully simplistic,
but it allows you to work with real-world data
and problems that are horribly complicated.

Dan Brickley & Libby Miller