[DotGNU]Implement RDF in a Universal Data Structure

[Seth Johnson]

RDF benefits from the generalization that knowledge can be represented by
assertions of a common, universal form.  All assertions have a subject, a
predicate and an object.  This generalization enables the creation of tools
that draw inferences from knowledge represented in this common form.

I want to take this to a higher level.  Instead of stopping at the assertion
structure of RDF, I propose that we implement a similarly universal
generalization about relations (among data entities).  This generalization
reflects the purpose of representing what the most fundamental universal
data structure is, which supports all the information access and retrieval
functions necessary for any application (and any web service).

RDF represents relations as a series of statements.  It's really a form of
many-to-many key table.  We can put RDF into this universal data structure,
along with anything else we please, because putting things into the
universal data structure makes interoperability implicit and automatic.

The universal data structure represents all relations as Use Types that are
related to Link Types, each of which may be particularized into specific
Uses and Links.  A particular Use of a certain Use Type represents the
parent record of a relation, and the particular Links of a certain Link Type
represent the children records related to that parent record:

   Use Type: Shopping Cart
   Link Type: Products Selected
   Use: Seth's Cart
   Links: Soap, Shampoo, Milk, Butter, etc.

(This is only a piece of the structure, but it represents the core
generalization that all the rest stems from)

Once you have a universal data structure, you can define a fundamental
protocol that says everything you need to know about any application, and
you can store everything for all applications in one universal structure
that inherently lets all elements in any particular such type of relation,
be used freely in any other such type of relation.

I refer to this fundamental relation as a "context."  It can also be
referred to as an atomic application.  A context is an extended version of
the traditional idea of relations among data entities, turning that concept
into the core of the idea of what an atomic universal application is
necessarily made up of and must be able to do.  More complex applications
are simply made by combining such atomic contexts.

RDF can be stored in this data structure as follows:

   Use Type: Subject
   Link Type: (Various predicates, like "has" "contains," etc.)
   Use: Whatever particular subject
   Links: Whatever particular "objects" asserted to relate in the link type
way to the particular subject.

   Use Type: Subject
   LinkType: Has
   Use: Seth Johnson
   Links: arms, legs, a receding forehead

What you can do with this is generalize about the universal functions that
must be built into such a representation of a universal, atomic
application.  This includes the query functions that the RDF area focuses
on.

Build this into DotGNU.  Make a language that speaks in terms of these
abstractions.  I call the language CCL, or Context Control Language, and I
call the basic structure of a context "packet" or "message" CTP, or Context
Transfer Protocol.  CTP can either be defined as something immediately above
TCP and immediately below the application layer, in a binary way, or we
could define it as something correlative with HTTP, in a more textual way.

There's more to it, but maybe this ramble will interest some of you . . .

Seth Johnson

-- 

DRM is Theft!  We are the Stakeholders!

New Yorkers for Fair Use
http://www.nyfairuse.org

[CC] Counter-copyright: http://cyber.law.harvard.edu/cc/cc.html

I reserve no rights restricting copying, modification or distribution of
this incidentally recorded communication.  Original authorship should be
attributed reasonably, but only so far as such an expectation might hold for
usual practice in ordinary social discourse to which one holds no claim of
exclusive rights.