Protégé VS plow

Along those lines, not Jena but useful for playing with ideas is Protege, https://protege.stanford.edu/

If you go with the Semantic Web there are many tools. The best free tool (possibly the best tool period) for creating OWL ontologies is the Protege ontology editor developed at Stanford. I wrote a tutorial that explains how to use Protege and gives more detail on OWL, SPARQL, etc. https://www.michaeldebellis.com/post/new-protege-pizza-tutorial

The case is different for more mature ontologies. The prime example is the sharing of drug information among drug vendors. They have an incentive to share because that ultimate saves them time in developing a drug that may already have been developed. It's like a prescreening for patenable drugs. They sgare knowledge in an ontology library called "Bioportal". many of the dntris are written in a form suported by the Protoge' editor. The Bioportal is open so anyone can look at the submissions. Protoge' is free and you can find tutorials on how to use it. You can find it at: https://protege.stanford.edu/

If you could put this into an ontological solver format, like Cyc or protege ( https://protege.stanford.edu/ ) then create a couple dozen translations of real laws into the format, you could turn gpt-3 loose on the entire set of United States federal, state, and local laws and regulations. Then propose a question to the solver using your model whereby a person can successfully sue or acquire property according to the letter of the law.

There are probably hundreds of obscure unintended consequences of laws not intended to have the effects they do in practice.

Figure out contract law and parse website TOS and EULAs for violations and you could probably make some money.

The biggest benefit of such a system, though, would be for actual legislators, so they could run simulations of proposals to get a sense of consequences in practice. Simulation and summarization could be very powerful.

Protege Desktop

Yes, consensus in ontology building has traditionally been a huge drag for the adoption of ontologies.

However, I don't think the core issue is consensus itself, but instead that the prevalent form of consensus in the ontology authoring space is consensus by committee rather than consensus by usage (as is usual in the open source software space).

That's why I've in the past been involved in creating Plow[0], a package manager for ontologies, with the aim of bringing the same "grassroots" nature and network effects that you find in other open source ecosystem to ontology engineering.

[0]: https://plow.pm/

I think this probably covers it the best.

In terms of the semantic web, trying to semantically interpret the URN (as OP suggests) also seem like a conceptual mismatch, as there are other mechanisms that allow for the same thing in a more "robust" way.

E.g. in RDF one could pack all the semantics into the datatype of a literal like `Norwegian account number "12345678902"` -> "12345678902"^^<http://example.com/accountNumber/NO> (where the IRI `http://example.com/accountNumber/NO` then serves as an identifier for a concept that can be enriched with more information).

> Often http is used instead, where the domain name serves the role of the namespace, because usually a suitable domain name is already registered. Of course, this latter practice has the drawback that one has to infer from context that it is a name and not an HTTP web resource.

At least in RDF-world (which admittedly isn't the only domain for URNs), this by now doesn't have to be inferred, but has over time formed into an undeniable reality.

In RDF from the beginning IRIs have been relegated to identifiers ("It only treats IRIs as globally unique identifiers" - RDF specification[0]) though it has been mixed with a lot of weak language/suggestions to also use IRIs as locators. And a lot of people/institutions did attempt to make follow that suggestion. However, since it's a lot harder to host a system in continuity that delivers content based on an URL (as evidenced by all the link-rot in the semantic web space) than it is to just coin IRIs, using IRIs as locators so rarely worked in practice that nowadays nobody even tries to do that anymore.

-----

DISCLOSURE: Self-promotion

Born out of the frustration of this issue (and some other issues, such as uncontrolled mutability when using IRIs as locators for semantics), we have built a package manager for ontologies[1] to serve as a foundation for stable semantic data systems.

In it we replace the fickle "maybe an IRI can be dereferenced to semantics" system of RDF/OWL with a package manager that allows for stable versioning and resolution of all the ontological dependencies of your system, so you end up with a stable set of documents that you can then interpret to get to the underlying semantics of an IRI.

Since there is a default registry[3] that even small projects can publish to, this also greatly reduces the barrier to entry for small projects to participate in building and publishing ontological definitions, as there isn't a burden of setting up and maintaining the hosting of the definitions.

We've been using that system for close to a year now as the underpinning for our platform[2], and it's been great so far. It allows us to offer different semantics to different customers (based on the packages they chose to import), and makes managing even a big set of often-changing semantic dependencies tractable.

[0]: https://www.w3.org/TR/rdf11-concepts/#referents

[1]: https://plow.pm

[2]: https://field33.com

[3]: https://registry.field33.com

(Warning: Personal plug incoming)

I fully agree, especially when it comes to the "semantic" part of the semantic web. Reusing and publishing ontologies that define those ontologies always seemed like an afterthought of the semantic web, when it should be part of the foundation that things on the semantic web are built on.

In most other parts that make up a website (JS and HTML) we figured out how to make reuse (mostly) work by replacing flimsy web references with package management. Ontologies never had something like that, and thus were stuck in an early 00s era of software/ontology development.

Where I work, we are building Plow, a package manager for ontologies (https://github.com/field33/plow) as part of our tech stack to improve that situation and allow people to build applications with large-scale stable semantics at the core.