Oh look, someone reinvented semantic web again.
One thing that I experienced as a huge hurdle for semantic web technology is the lack of browser APIs to actually work with RDF/JSON-LD/Semantic Web data. There's really no complete and straightforward way to transfer, store and query semantic data in the fronted. JSON-LD works around this by exposing the graph as a tree regular old JS can work with, but that looses a lot of the flexibility and power of the original graph model, e.g. path independence and proper queries.
I'll definitely keep an eye on how your ideas and solutions evolve!
If you have any learning from your own work you'd care to share, or thoughts on ours, please drop by the repo (https://github.com/blockprotocol/blockprotocol) or Discord (https://blockprotocol.org/discord)
* There is no good build-in way for authentication and trust.
* Description Logic (the foundation of OWL) has a fundamentally prescriptive philosophy, which makes it inappropriate for most practical applications.
* No good library and tool support in general, due to the complexity.
* Blank Nodes
* No good consistency mechanism for distributed data generation, and Quads (having multiple graphs) don't properly solve this.
* Using human readable entity and attr id's leads to more bike-shedding and accidental collisions than it's worth.
* High barriers to entry.
* After years of developer disappointment the earth is pretty much salted.
It's needed because of the "readable resource name" criterion I also mentioned. Most of the complexity in RDF is actually not in the datamodel but leaks in from other parts of the web.
An abstract data definition language for structured data represented as entity relationship graphs. Basically, the same Entity-Attribute-Value model that's existed for eons plus the addition of formalized identifiers (i.e., IRIs) for denoting entities, attributes, and values.
That's it!
RDF Schema, OWL Ontology, etc.. are simply Data Dictionaries comprising terms that describe Entity Relationship Types.
Related:
[1] Understanding Data -- https://www.slideshare.net/kidehen/understanding-29894555
[2] RDF based Linked Data, Ontologies, and KnowledgeGraph -- https://www.linkedin.com/pulse/linked-data-ontologies-knowle...
What you've outlined is the common misconception by the Semantic Web community about what constitutes a living and workable software ecosystem. It's the classical architecture-astronauts fallacy of ignoring this age old truth: The medium is the message.
The "but RDF only specifies the semantics of abstract graph data, all the serialisation formats are just implementation defined incidentals" argument is at the root of why there are thousands pages of specifications and 0 high quality semantic web libraries or tools. It's like saying "no, no, no, you misunderstand JSON/XML/YAML/ASN.1 it is not a (flawed?) serialisation format, it is a data model for trees, which works on any text processing capable system", true, but a straw-man.
Developers and Ontologists flocking to Protege, OWL API and Jena, is akin to dehydrated animals flocking to the last muddy and barely drinkable water-hole. They have no choice and it's mostly sh*t.
Everybody is still editing XML files by hand, there is no maintained, complete, production ready library for any language, and most of the stuff that does exist is either the cadaverous remain of a publicly funded science grant or an obscure project developed by a lone consultant who made peddling the semantic web his livelyhood without any real community.
People have to be able to use a system, and then actually use it in order to be meaningful, theoretical what ifs are irrelevant.
In fact you are sort of arguing the opposite: Human knowledge lends itself so well to categorization that a single ontology is impossible (if it was really hard to categorize, there would be no or few ontologies).
It's easy to express "<something> isa <cat>", but significantly harder to express "<something> isa <cat> with probability 98%". And all attempts to express the later just look like you're trying to build an impromptu relational database in order to fit an n-ary relationship.
<diagnosis> <diagnosis_type> <ADHD>
<diagnosis> <diagnosis_probability> <high>