- The Web is an open world model
- RDF explicitly uses this open world model: you can never be sure that you have all the facts (the an aside that scutters could become a valuable commodity; the better the search/retrieval/inferencing (to deduce missing/extra data) the better the conclusions)
- Databases are closed worlds
- API primitives shared by the Web and databases are CRUD
- Databases allow discovery of relationships (where might that extra data live?) through a data dictionary. Doesn't type the links, just that there's a relation.
- The web allows for discovery of relationships by hyperlinks between resources. HTML links don't allow typing, XLink does
- RDF allows for relationships using triples (these tie the data) but rdfs:seeAlso is the main way of associating one document with another (there's more over there)
- XLink allows for linkbases so that relationships can be stated out of live. RDF overlaps quite a bit with XLink (typed relationships). For any two RDF resources, one can create a third that links them together
- The web supports discovery using a search engine.
- Is there a missing primitive? DISCOVER?
There's certainly not a requirement for a single central point of discovery (brittle; non-weblike) and there's not really a requirement for a single means of discovery, although one would have to argue pretty strongly to suggest that HTTP doesn't allow that.
Surely our desktop applications should start supporting this open world model -- and couldn't one argue that this is actually more important than Web Services; indeed couldn't one also argue that a fundamental goal of the Semantic Web must be to bring an open world model to all applications? Inferencing and cute agents might be the pinnacle of the semweb, but those applications need to use an open world model.
So does RDF give us everything we need? No. It provides the framework for loose coupling of data, but it doesn't have anything to say about application structuring to allow this.
Digression into annotations:
We can annotate web pages (Annotea, Critlink) and view those annotations in various ways, e.g. inline. These annotations are kept out of line, we just look them up. We can also annotate pages by linking to additional info, or embedding it.
We can annotate images, etc (JPEG, XMP) by embedding extra metadata inside them. But what about out-of-line annotations? I should be able to associate commentary with a movie for example.
Arguably all applications should allow:
- indirection in resource accesses (I might want to subsitute an alternative, find a mirror, etc.)
- annotation of a resource at point of access, or during access
- discovery of annotation sources at point of access, or during access.
It's NOT enough to have just linking, if it were then we wouldn't have had bookmarks, yahoo, google, etc. If linking were the only method then one would have to scutter the whole web to find useful data. What one needs is a resource discovery hook in _every_application_. And not just a Google lookup, something meaningful for the context.
When I open my DVD player on my laptop I should be able to choose not only from the commentaries, soundtracks and subtitles bundled with the actual disk, I should be able to choose from fan-subs, alternative soundtrack mixes, media studies lectures, etc.
It's not the content that necessarily closed, although obviously there are copyright and licensing issues, its more that the applications are assuming a closed world model -- they have all the data they require -- and thats explicitly not the case anymore.
So how to drive that to the desktop?
What about a local annotation server, configured to talk to one or more peers. We can then exploit a distributed peer-to-peer model for not only getting the content (Kazaa; Gnutella) but finding annotations as well. As a proxy the annotation server can be adapted to understand more than one discovery mechanism whilst providing a common interface (HTTP) for those applications that want/need one. Maybe there's a role for BEEP or something here as well.
Would be interesting to find Java frameworks for playing movies/music and see what access they allow to the underlying content (e.g. substituting the soundtrack at a specific point) or viewer (e.g. adding a subtitle, etc).