JSON-LD and Why I Hate the Semantic Web (2014)
manu.sporny.org
manu.sporny.org
The semantic web is a colossal waste of time and money. It does more harm than good. Unless you're a savvy PI (probably in a European country) who has used it to lasso a big fat grant from clueless committees who think in terms of buzzwords.
Every successful project which is linked in any way to semantic web, would have been successful without the semantic web.
The only original thing to come out of semantic web, RDF, causes more harm than good. Anyone who has had to deal with encoding sequences in RDF, or any other kind of nontrivial structured data, which is only possible with incredibly asinine "blank node" trickery, either knows this or is deceiving themselves.
Semantic reasoners are either limited to EL ontologies, which defeats the whole purpose of OWL's expressiveness; or else take dozens of gigabytes of RAM to reason over any ontology more complicated than "the pizza ontology". Utterly, thoroughly irrelevant in today's VPS-based world.
The semantic web "community" is about 75% made up of invalid URLs because all these academic geniuses are too busy theorizing about ontologies to realize that all the links into their department webpage are going to stop working when their one-year postdoc expires. Various URL-standardizing services try to address this, unfortunately the number of these services is approximately 1 per semantic web researcher, and in the long run they're no more stable than the department webpages.
The semantic web is a horrific waste of (mostly EU) grant funds that could be used on far more worthy research. The world would be a better place if the whole idea had never been invented.
I was thinking many times of it. For most of the time it is true, but not always. I still can find few good examples. Look at dbpedia. It may look messy, but there is vast amount of data there, that is taken advantage of by many projects (also commercial). While i can imagine making a database with the same data, it is the "linked data" initiative that gave it such possibilities.
I agree that there were huge loads of money spent on it, and many projects simply didn't deliver what was promised. But anyway, does research always succeeds in 100% of the cases?
It's like saying J.K. Rowling couldn't have written Harry Potter if not for Bloomsbury Publishing's in-house style rules.
That's semantic web for you. Dbpedia is a project whose value is 99.9999999999% comprised of its content, 0.00000000001% comprised of semantic web scaffolding, and semantic web comes along and claims full credit for the entire thing.
For the rest I would say this holds true for to much of any CS research e.g.: Grid, Cloud, P2P and GPU compute. Looking at the vast sums spend on this the practical benefits are from outside the academic labs. I.e. all those other buzzwords that are used to justify grants.
OWL reasoning at least standardised the format of many logical constructs and allowed for competitive improvements. Now you can at least change your prover while maintaining your axioms. So you get something like StarDog which is vastly better than the Pellet you are probably familiar with.
If you pry beneath the surface the life science ontologies are garbage. Full of subtle errors, disagreement between different ontologies, incorrect changing of namespaces which causes backward incompatibility. You have to have 100% knowledge of the ontology's idiosyncrasies in order to use it with confidence (i.e.: you can't).
Funny you mention StarDog. Semantic web is supposedly this great open data thing that's going to unite the world. Except it's such a miserable community there aren't even any decent non-proprietary tools to satisfactorily fulfill the most basic premises of semantic web, after all these years.
This may become even more relevant with trends like the IoT (how smart can that be if every company uses its own home-bred standards and the devices can't automatically understand (and react to) each other? This also applies to Robotics / AI.
I'm really not sure the Semantic Web is on a good road there, but they are actually thinking about those hard (and interesting) problems.
There is at least one project where I can see true value, even today: Schema.org (http://schema.org/). And if you're only creating semantic annotations, it really isn't that difficult. Sadly, to smartly combine and make real value out of Semantic Web Data you probably need to be a BIG company like Google.
Growing up in the 80s, I was mostly too young to remember the rise of XML. (Or more: too young to care much about work around a data format.) Presumably a similar thing happened then? I.e. there were existing formal and ad-hoc standards for representing a variety of concepts, and entirely new formal and ad-hoc standards were created to represent the same concepts in XML?
Why not create standards around abstract representations of things, and then create standards for serializing those into concrete formats?! So then we'd already have e.g. Abstract-LD and XML-LD; and JSON-LD would be new. That seems less wasteful than throwing everything out when a different data representation format becomes the new hotness.
(Certainly we learn things about the abstract representations as time goes on. That could be handled by versioning. So maybe there'd be XML-LD 1.0 and 2.0, but JSON-LD would only exist in 2.0 form because nobody was interesting in doing the work to define the JSON serialization of Abstract-LD 1.0...)
Semantic web is quite easy when it comes to Linked Data (and RDF/S subset), but is becoming painful when more expressiveness is necessary.
Unfortunately, in many cases using only RDF/S is not enough, and some more heavyweight reasoning is required. This is both hard and not scalable for bigger sets of data. Then there is the Open World Assumpltion, which is somehow contrary to what a typical person would expect. You can't easily validate your data for some missing property, because of what OWA assumes: we don't know so we can't tell if it's false...
Anyway Semantic Web has left a nice and mature technology stack, that is great for many tasks. Most of knowledge modelling use cases can be done with RDF and with multiple tools that supports it's creation, editing, reasoning, querying, visualisation, etc.
OWL is powerfull but hard like all description logics, they ar e tools that very very few developers really master. Yet can be used for very interesting things.
Validation is not the goal of OWL and is therefore not well supported. ShACL or whatever comes out of W3C for schema descriptions and constraints will be easier and more performant for this use case.
On the last para: yes, yes and yes. Very mature stack with a lot of competition and innovation.
Cheers!
Still, this was a great wrap-up discussion, and the specification is easy to read, which is an achievement in its own right and should be recognized.
That's RDF in a nutshell.
The parent post said "they provide" but it was referring to multiple fields.
So out of all of that, RDF and MathML are the only things that even attempt to define any kind of semantic encoding, and as far as I can tell they completely fail at that in the real world. For the vast majority of real world services, if you want to extract semantic data out of them you use JSON.
JSON is just the encoding, not the data model; it doesn't work at the same level. That's why RDF/JSON and JSON-LD exist.
Without disputing the idea that the implementation of the Semantic Web is a failure, this idea that JSON (or XML, for that matter) is a data format is holding us back. Every provider is saying that they output in a "standard" format (JSON), while we keep writing new clients for each and every service out there, because every data format is different and it's impossible to write common handlers.
Except for a few attributes, a Github user and a HN user could have the same structure, since conceptually they're quite similar concepts. Yet, try handling [1] and [2] with the same code.
The regular claim that programmers can handle more abstraction than regular people just sounds like a sad joke whenever I think about the shortsightedness and lack of self-awareness that has led to the current situation.
[1] https://hacker-news.firebaseio.com/v0/user/jl.json?print=pre...
The only piece of data that seems in common is that they both have user names.
There is no reason user data should be similar across different systems. Products are generally unique, or they don't have much value. That means the data tied to a user is often also unique.
This is what RDF allows you to do: instead of designing a custom format, or being tied to a rigid standard one, you can simply add standard attributes to the element in an ad-hoc fashion, so the client can use whatever attributes it supports while allowing for the ones it doesn't. And if there is no standard attribute, fine, you can add custom ones as well.
There's no reason the same code shouldn't be able to process HN, Slashdot and Reddit threads, for example - and even a Github issue.
Foundations such as query federation, graph compression (HDT), reasoning, data integration and much much more.
Semantic Web is a field that is obsessed with theory, without producing any useful theory, nor any practical artifacts that can be used.
Hating entire fields is an entirely reasonable thing to do when they are not productive and when they draw attention away from more useful activities. And it's quite possible for social dynamics to do that, for the wrong thing to become en vogue, and for really wrong paths to be followed for long periods of time. And it's entirely possible to study something that's actually nothing, such as alchemy. Perfectly fine to hate the field of alchemy.
http://linkeddatafragments.org/ - allows to query several "semantic web" datasets at runtime by issuing several concurrent HTTP requests
http://www.rdfhdt.org/ - allows to store graph-like data in a very compressed format that is queryable directly in memory
http://events.linkeddata.org/ldow2015/papers/ldow2015_paper_... - (shameless plug) allows you to query and browse semantic datasets (hosted by different people on different servers) on the web using keywords
The fact that they're not useful to you does not make the entire field useless.
http://www.shirky.com/writings/herecomeseverybody/semantic_s...
US citizens are people
The First Amendment covers the rights of US citizens
Nike is protected by the First Amendment
I'm sure this guy is very clever, and has plenty of great qualities - but he has built his argument around the failure of logic, when it is clear that he doesn't know very much about it. The use of very poorly defined terms makes it look like he is aware of this...
F=m*a is a great rule most of the time that happens to stop working at various edge cases. Sadly, you can say the same of all of physics and just about every other rule. Even things as 'simple' as living vs dead can get really complicated with lots of odd edge cases.
http://en.m.wikipedia.org/wiki/HeLa new species?
Well, automated systems constructed by people - as ontology construction and semantic reasoner writing is primarily a human activity (... yeah I see it). It would be pretty funny if we end up with a semantic web, where logic is king, having ontologies mapped by a probabilistic AI though.
As far as edge cases are concerned, that is why you use an open world assumption [0], allowing the reasoner to return "Unknown". Which would act as a compiler error for human understating. Of course that won't save you from reclassifications, but nothing will. I haven't done much thinking on the matter, but I can't think of anything that would better handle the expansion of a knowledge graph than an OWA semantic reasoner. I've done a bit of work with neural networks, and changes in the domain are not well handled by neural networks. I imagine the results of a large graph change would create in the neural network something that would look very human - confirmation bias :)
If you've set things up with that sort of constraint, then you've set yourself up for failure - Gödel's incompleteness theorems [0]. I think OWA is the only way around that, you just need to gracefully handle unknowns. Of course, you can convert an unknown into a known pretty easily with: ¬u :)
> For instance in the case of cardinality problem.
That is exactly when I'd want my reasoner to ignore a graph edge, or else you get a non sequitur that ends with Nike belonging in the human set. Measure twice, cut once.
[0] http://en.wikipedia.org/wiki/G%C3%B6del%27s_incompleteness_t...
The problem with author's thesis is that he want's semantic web to universally describe the whole world. This is impossible because the world is changing and sometimes contradictory.
OWL for instance doesn't cover such assumptions, and in general most knowledge representation frameworks are monotonic, so it's impossible for instance to withdraw some fact by adding a new one. That what might be a real limitation of the Semantic Web as we know it.
> the world is changing and sometimes contradictory
If you think ontologies don't change and will not require constant maintenance I have a bridge to sell you.
Also, he mentions Google in this essay; this was written after the emergence of Google, when Google was trouncing all of these other services that tried to use metadata embedded in webpages or tried to classify all websites into some big hierarchy.
A world of exhaustive, reliable metadata would be a utopia. It's also a pipe-dream, founded on self-delusion, nerd hubris and hysterically inflated market opportunities.
The comment at the end of the essay about Google looks to be half throw-away. It's like he showed the essay to someone before he published and they said, "but Google", so he put a comment about Google in there without acknowledging that they were wrecking his essay.
Additionally, he never mentions the positive feedback loop created by companies like Google that tend to encourage good meta data creation by punishing the obvious crap.
My favorite expression from it: "the lab-coated guardians of epistemology".
More fully: "In meta-utopia, the lab-coated guardians of epistemology sit down and rationally map out a hierarchy of ideas..."
There is a ton of great work in knowledge engineering using RDFS and OWL, and tossing that seems like a bad idea.
It's good that conversion from and to RDF is now standardized, but it's probably not something that your average dev is going to be taking advantage of. They'll likely continue to ingest, process and store the data in JSON.
I am still trying to wrap my head around using JSON-LD. One advantage of RDFS (or OWL) is being able to integrate different data sources using different schemas. That probably is just not a typical JSON-LD use case. BTW, I have written a couple books on the semantic web, so that shows my prejudices :-)