I have worked quite extensively within various domains where claims are made regarding the usefulness of ontologies, however, I have yet to see any real evidence for these claims. I cannot really have seen the full extent of what has been achieved with ontologies, so I want examples of where ontologies are actually applied and used for real-world work.
From my own experience, it's quite clear in fact that many of these claims are simply unfounded; I worked particularly with one large scale ontology on industrial projects where it was widely claimed as a poster child for ontological approaches, however, within the domain itself (outside the group making the claims) the level of success was not only zero, but was actively harming take-up of anything related to semantics because it had failed to deliver at every level in many projects.
It should be noted that I am talking about the logical concept of ontology, expressed in OWL, and not the general concept of ontology where we cherrypick a few terms from say FOAF. Perhaps a variant of this question is: where are the real-world applications of reasoning?
I think the nicest use of ontologies and reasoning to do something useful is the SADI framework.
Here reasoning is used to connect many webservices and databases into a single SPARQL endpoint i.e. allowing you to SPARQL against computable results.
Another nice example is Uberon that is used by multiple groups to talk about multi species anatomy in a formalized manner.
The Gene Ontology is a well know example in Biology. Even though it started out as a tag collection it has become more of a full featured OWL ontology in recent times. For example the GO and Chebi link is very powerful and a good usecase of reasoning to get a lot more out of the combined ontologies.
But to be honest many public ontolgies are of awfull quality and have nearly no relation to the data in the field. Many are mere collections of tags that you can attach to data. i.e. they are dictionaries of terms but no sentences using the terms exist in the wild.
The paper @Fabian Cretton, so kindly mentions shows how SPIN can be used to detect errors in RDF encoded data. I would not call UniProtKB an ontology (as it has quite a few modeling issues, and I know working on it and having written that paper). Having said that it does use ontology parts. Mixing a formally defined schema with
All in all, the reason that a lot of ontology work did not pay off is that the distance between ontology and data was to far. With RDF/OWL the format of the data is the same as the Ontology. This makes it much easier to use Ontologies to model the data.
Much like strongly typed functional languages are only now becoming popular while early work on those happened in the 70's as well. As multi-core programming calls for functional programing, multi-data sources ask for RDF/OWL ;)
There are major issues that hamper the success of ontological work. The first is the strong philosophical bent (especially in the upper ontologies like BFO) (the less said about ontologies of unicorn's or planet shapes the better). The second is the low standards of engineering. Taking again BFO as an example. This upper ontology has not been updated since 2009. No examples improved. No Comments and definitions split from their text blocks. No attempts to correct mistakes(or improve unclear ones) in their examples (or expand upon them). This shows that a 'key' piece of infrastructure is not maintained (no errata). The third problem in the community is the lack of modularisation. For example EDAM has 4 major parts that are all maintained in a single file. This limits the use of the ontology to a single field and makes it difficult to contribute.
Might it happen that SPARQL and SPIN finally prove to be more useful (for real cases) than OWL reasoning ?
Here is a paper that could be of interest, a real-world application in the UniProt project.
I also think that OWL reasoning can be of interest when doing some operation on data, as changing from one T-Box to another, working on Ontology alignment, or merging data with different representation (and thus using for instance inverse properties to finally have the same representation for a all set coming from differently modeled sources), isn'it ?
The EPIM ReportingHub project is a real-world application in which ontologies play a central role. For background you can find a presentation online. This is a complex multi-year joint effort by several companies including my employer TopQuadrant.
In a nutshell, this is a system that is used by oil producing companies to upload daily/weekly/monthly reports and a central RDF-based repository is collecting this data. Other types of reports, views and business intelligence can then be generated from the RDF triples. One of the motivations for chosing an RDF/OWL ontology as the central representation format was data longevity - an ontology is arguably more flexible than approaches with fixed schemas such as relational databases when requirements change.
Once the ReportingHub ontologies had been built we have added data transformations that import background knowledge (here, the NPD Fact Pages) from external web services on a nightly basis, creating some master data that drives the application. For example this background knowledge manages which well bores exist and which company currently has licenses for them. We are using SPINMap (a graphical notation for SPIN rules) to transform the tabular input data into the background knowledge ontology. Similar (albeit more complex) SPIN-based mappings are used to translate the incoming XML reports into RDF.
The reports that are generated and presented to the user are produced using SPARQL Web Pages (SWP), again using SPIN (templates, functions and magic properties) for the heavy lifting of turning RDF data into tables. Even the web user interfaces that drive navigation through the data sets is entirely implemented with SWP.
Whether you want to call these use cases reasoning or not, they demonstrate that RDF-based technologies can be an efficient means of implementing data transformations, and SPARQL and SPIN do provide a suitable language for this. We are not using OWL (DL) reasoning but we do use the OWL vocabulary to express things like cardinalities.
Could this have been implemented with conventional technology? Yes of course - everything can. But it's a matter of how maintainable such a system would be and whether the data format is a natural match for the domain, and whether the data format will still be useful in ten years from now. The fact that ontology-based data can be linked and repurposed for different applications indicates that ontologies are indeed the best choice for a large family of applications.
I think reasoning is one of those things that works very well conceptually. The idea makes a lot of sense and you can even apply it to very specific real world data, and obtain interesting results.
However, as you state yourself, for large scale things where you can't really obtain and mashup "specific data", it's hard to obtain clear results that prove whether reasoning is useful or not.
The fact that you can't apply reasoning for large amounts of real-world applications, doesn't mean it isn't useful. Reasoning has a very specific need, and it may never serve real-world applications purposes. It may just always continue to exists as this interesting concept that works for specific data... it doesn't make it useless.
It could be that a lot of the use cases for ontologies are actually emerging or not yet realized. Rule of least power, don't use OWL unless you can get away with RDFs or RDF, but I actually feel that there are a lot and a lot of systems that can be greatly (and I really mean greatly) simplified by using OWL. My current and most prime example is using OWL to compliment event driven architectures. A lot of the MMI standards and architectures promulgated by the W3C actually are greatly augmented and improved by using OWL + reasoner (SCXML has limitations) as an Interaction Manager. Sensors networks are also becoming a lot more ubiquitous i.e face recognition, motion recognition, voice recognition, gesture detection; and in order to make sense of all the data from these sensors (relying on one sensor to provide an experience has major shortcomings), you are going to translate things to RDF and use a reasoner to raise all sorts of events (and a event listener to execute them).
So I think OWL has massive potential and ultimately will feature in a lot of systems.