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.
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...)