Henry Story wrote:
On 17 Jun 2011, at 22:42, Nathan wrote:
You could use the same name for both if each name was always coupled to a
universe, specified by the predicate, and you cut out type information from
data, such that:
<x-sasha> :animalname "sasha" ; :created "2011...." .
was read as:
Animal(<x-sasha>) :animalname "sasha" .
Document(<x-sasha>) :created "2011...." .
the ability to do this could be pushed on to ontologies, with domain and range
and restrictions specifying universes and boundaries - but it's a big change.
No its quite simple in fact, as I pointed out in a couple of e-mails in this
thread. You just need to be careful when creating relations that certain
relations are in fact inferred relations between primary topics.
I'd agree, but anything that involves being careful is pretty much
doomed to failure on the web :p
really, different names for different things is quite simple to stick to,
yes, but there are a lot of people who say it is too complicated. I don't find
it so, but perhaps it is for their use cases. I say that we describe the option
they like, find out what the limitations are they will fall have, and document
it. Then next time we can refer others to that discovery.
So limitations to look for would be limitations as to the complexity of the
data created. The other limitations is that even on simple blog pages there are
at least three or four things on the page.
there's also a primary limitation of the programming languages
developers are using, if they've got locked in stone classes and
objects, or even just structures, then the dynamics of RDF can be pretty
hard to both understand mentally, and use practically.
and considering most (virtually all) documents on the web have several
different elements and identifiable things,
indeed.
the one page one subject thing isn't worth spending too much time focusing on
as a generic use case, as any solution based on it won't apply to the web at
large which is very diverse and packed full of lots of potentially identifiable
things.
agree. But it is one of those things that newbies feel the urge to do, and will
keep on wanting to do. So perhaps for them one should have special simple
ontologies or guides for how to build these ObjectDocument ontologies. In any
case this seems to be the type of thing the microformats people were (are?)
doing.
hmm.. microformats seems to be pretty focussed on describing multiple
items on one page, however the singularity is present in that they
focussed on being described using a single Class Blueprint style, one
class, a predetermined set of properties belonging to the class, and a
simple chained heirarchy - this stems from most OO based languages.
With a bit of trickery you can use RDF and OWL the same way, it just
means you have different "views" over the data, where you can see
Human(x) with a set of properties, or Male(x) with another set, or
Administrator(x) with yet another set. This is less about the data
published and more about how it's consumed viewed and processed though.
Quite sure something can be done with that, where the simple version of
the data uses a basic schema.org like ontology, and advanced usage is
more RDF like using multiple ontologies. The "views" thing would be a
way to merge the two approaches..
Best,
Nathan
