Sometime this week I was reading a blog post that was giving some statistics related to Schema.org‘s usage on the Web. It states:
36.6 percent of Google’s search results include “at least one snippet with information derived from Schema.org.”
only about 0.3 percent of domains are using the markup code on their websites.
Someone may be surprise to see how that little number of domains produces that much snippet uses in Google searches. But this is not what interest me in this blog post. What I am interested in is that considering that 36.6% of the Google search appears to be returning structured information that uses Schema.org microdata, why is there only 0.3 percent of the domains that are using the markup?
Introduction of a new paradigm on the Web
I think that what is happening at the moment is the emergence of a new paradigm on the Web: publication of structured data. Some may say that this is happening for a long time and I agree with them. However, what is happening is that this structured data starts to emerge to the end users. This is not something that happened until recently (the last year or so).
What the major search engines, which participate to Schema.org, are doing is to push (to force?) this new paradigm to emerge. The thing is that to my experience the management of structured data to be published on the Web needs a different set of
specifications and more importantly
It is true that current tools and techniques can be used to publish Schema.org markup in HTML Web pages, but to me, they are sub-optimal for the task at hands. This is probably one of the reasons why the authors of this blog posts stated:
Not surprisingly, the study also found that “larger sites” are more likely to use Schema markup. There’s no definition given in the study on what makes a site big or small, but this has long been one of the concerns about Schema.org – whether small businesses/websites would have the technical chops to take advantage of the rich snippet opportunity, or if that would be left to bigger companies with more skilled webmasters and more organized online marketing efforts.
I tend to agree with that. However, this shouldn’t be the case. I think that the reason for that is that people doesn’t tend to use the proper frameworks (CMS, programming API, etc.) and data management systems that are optimized for that task. Another reason is that there is no widespread understanding and adoption of the new underlying concepts, technologies and techniques that are emerging with this new paradigm.
Coping with the evolution of Schema.org
One of the core concept introduced by this new paradigm is the
Open World Assumption. This assumption basically means that we don’t know if something exists or not, if something is true or not, until it is explicitly stated. This means that it is not because we (our systems) doesn’t have some information, that this information doesn’t exists.
This is really important to understand, and this assumption has a dramatic impact on how we develop the systems that will publish this structured information on the Web. On the Web, there is no one system that has complete control over the information that may exists. Major search engines such as Google have this Open World Assumption at the core of their system. It is why they are pushing initiatives such as Schema.org, of their Knowledge Graph. Because this is how they can try to cope with the constantly evolving Web.
How does this relate to Schema.org?
Right now, there is 585 types and 807 properties in schema.org. and there are even ways to extend the vocabulary.What that means is that this vocabulary is constantly evolving, changing, improving and increasing. If the vocabularies (ontologies) changes that often, it means that the data may should as well. However, the way most of the data management systems are currently used to publish content on the Web (mostly relational databases) can hardly cope with these kind of changes in the data, and its structure.
This is the reason why I am stating that new concepts, techniques, technologies, methods and tools needs to be used in order to be able to cope with these constant changes.
With traditional (relational) systems, every time someone would want to add new micro-data in their webpage, they would have to do an analysis of their relational data, and then to map it to different Schema.org types and properties, and then to create all the code to perform this linkage, and generate the enhanced HTML code which includes the Schema.org micro data.
Then once this is done, what happens if the vocabulary changed? If the data to publish changed? Well, all this analysis and work will need to be done again to reflect the changes in the vocabulary and the data.
However, what if a different set of concepts, techniques and tools are used to publish structured content on the Web?
What I am proposing here is a system, a framework, that manipulate entities as its core: things that are described with attributes and values. Then, these entities descriptions are carried around within your code. The logic required to handle the use case I outlined above is embedded into the ontologies, the system, the framework, the API… The only thing a developer should need to do is to care about its code and the functionalities of the system.
In such an information system, all the entities are described using internal and external ontologies. All these ontologies concepts (types and properties) need to be linked to the ones of Schema.org (or any other sources of information). Every time something change, the changes should be reflected, accounted for, into these ontologies, not into the code, the templates, or whatever. It need be transparent to the developers.
In the next section, I will show you how this can be done using the Open Semantic Framework (OSF). However keep in mind that what I am discussing in this blog post is much more general than that, and can be implemented using different tools. I used the Schema.org example, but the same minding can be applied to lot of different use cases.
Care about the code, not the data
To make my point, I will demonstrate how publishing Schema.org microdata in a Web portal can be done using a new set of techniques, concepts and tools.
The initial goal is to split the concerns:
ontologists should care about the ontologies and their linkage, and
developers should care about the code and the functionalities of the system. The best way to make sure that a developer cares about the code, is to abstract this complexity of the Open World Assumption behind a programming API. In this example, we will demonstrate that using the
OSF PHP API.
Such a API should use the resources provided by the framework to determine if the properties and types that are used to describe a given entity can be expressed/serialized in Schema.org microdata. All this mechanic should be hidden the the developer, and should be driven by the ontologies.
This is the
crux of the matter. We want to manage this complexity where it is much easier to manage: at the level of the ontologies . These Ontologies Driven Applications (in this case, the Ontologies Driven Frameworks or Systems) will abstract this complexity to the developers.
Let’s take this PHP [nearly pseudo] code as an example. It uses the
OSF PHP API to retrieve information about an entity from a OSF Web Services instance by querying the
CRUD: Read web service endpoint. Then it uses the
Subject class to determine if the property(ies) and type(s) of the entity can be serialized in Schema.org microdata. In this example, the Subject class is using non-existing function calls. The goal is to show how such a basic programming API can abstract all the complexity of an evolving Schema.org vocabulary.
Let’s take that pseudo PHP code:
// Specify the unique identifier (URI) of the entity
$entityIdentifier = 'http://foo.com/datasets/movies/Avatar';
// Use the CRUD: Read web service endpoint to get the
// description of the record from OSF
$crudRead = CrudRead();
$resultset = $crudRead->getResultset();
// Get the entity (instance of the class Subject) from the resultset
$entity = $resultset->getSubject($entityIdentifier);
// Get the first type of the entity
$type = current($entity->getTypes());
// Get the name of the entity
$name = $entity->getPrefLabel();
// Get the genre of the entity
$genre = $entity->getDataAttribute('http://purl.org/ontology/movies#genre');
// Get the director of the entity
$director = $entity->getDataAttribute('http://purl.org/ontology/movies#director');
// Then run this template to generate the HTML which will embed,
// or not, some Schema.org microdata
<div <? print $type->serializeMicroformat(); ?>>
<h1 <? print $name->serializeMicroformat(); ?>><? $name->getValue() ?></h1>
<span>Director: <? print $director->serializeMicroformat(); ?>><? $director->getValue() ?></span> (born August 16, 1954)</span>
<span <? print $genre->serializeMicroformat(); ?>><? $genre->getValue() ?></span>
What this template does, is to generate the HTML code, enhanced with Schema.org microdata. The
serializeMicroformat($format) function does:
- Get the URI reference of the type/property
- Query the ontology to check if the type/propertyis linked to a Schema.org concept
- If it is not, then an empty string is returned
- If it is, then it serializes the micro data to add to the HTML and return it
It is as simple as that. All the “complexity”, all the work, is done at the level of the reference structure (the ontology). The result would be something like:
<div itemscope itemtype ="http://schema.org/Movie">
<span>Director: <span itemprop="director">James Cameron</span> (born August 16, 1954)</span>
<span itemprop="genre">Science fiction</span>
Here is another example that does exactly the same, but that produces RDFa Lite markup:
<div vocab="http://schema.org/" <? print $type->serializeRDFaLite(); ?>>
<h1 <? print $name->serializeRDFaLite(); ?>><? $name->getValue() ?></h1>
<span>Director: <? print $director->serializeRDFaLite(); ?>><? $director->getValue() ?></span> (born August 16, 1954)</span>
<span <? print $genre->serializeRDFaLite(); ?>><? $genre->getValue() ?></span>
This would produces that HTML code with RDFa Lite embedded:
<div itemscope typeof="Movie">
<span>Director: <span property="director">James Cameron</span> (born August 16, 1954)</span>
<span property="genre">Science fiction</span>
What happens there is that the API uses the Ontology (which is linked to Schema.org concepts) to determine if the entity can be rendered in Schema.org microdata. What it does is to check if the type used to describe the entity we retrieved from OSF is linked to a Schema.org concept. If it is, then the API get that reference to Schema.org, and properly serialize the Schema.org microdata snippet. The only thing the developer need to do, is to properly use the API functions. Nothing else need to be determined by him, the system will take care of the rest.
The beauty of this is that you don’t have to worry about any kind of mapping between the vocabulary (ontology) you use for describing your entities, and the Schema.org types and properties. The only thing you have to do is to re-use such a mapping with your ontologies. The PHP API will take care to produce the proper Schema.org microdata, only if the linkage exists between the content you are publishing and the schema.org vocabulary. The only thing you have to worry about is to use the API when you create your code to publish your content on the Web.
Is this vision possible? The platform that manipulates entities that way is already existing: it is the Open Semantic Framework. Everything you manipulate are such entities descriptions. Then you have the PHP API available to query the web services to get the descriptions of your entities. The only missing piece is the glue that map your entities’ types and properties to the schema.org vocabulary.
The good news is that this glue already exists, but will greatly improve in the coming months. We are currently working on a completely new version of UMBEL (Upper Mapping and Binding Exchange Layer) that will include, amongst other things, a fully updated Schema.org mapping between UMBEL and Schema.org. Note that UMBEL and its linkages is meant to be that reference structure to be used in the code I outlined above.
A new Web paradigm is being pushed, is being forced, by the major search engines. However, the issue that is emerging is that the current systems that are used by 98% of the people are not geared toward that kind of data management and these new development concepts and techniques. If this paradigm shift continues, then it will force developers to adopt completely new platforms, which rely on new technologies, concepts and specifications such as the Open Semantic Framework. The way people of that field are working will change quite significantly.
This blog post focused on the Web, and companies that are publishing content on the Web. However, to my experience with multiple different kind of organizations (municipalities, governments, Fortune 500 companies, etc.) are now experiencing the influences of the Open World Assumption in what they thought to be a Closed World. The data they are using to give different kind of services, changes, evolves. New acquisitions and new projects challenge their Close World Assumption. These changes have dramatic impacts on their infrastructure, their data and their ability to evolve and adapt to the constantly (fast) changing World .
The leap is big since the minding is quite different, investments will be required in terms of software and data migration and training of the staff. But in my view, it is essential, things are changing and organizations will need to adapt.
To conclude, how many time in a day can I read blog posts, tweets and forums where naysayers state that the Semantic Web never worked, never existed and it is doomed to be used by academicians only? Multiple… but who cares?
This is the Semantic Web. This is Linked Data. And it is changing the way people works.