[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: [DotGNU]Implement RDF in a Universal Data Structure

From: James Michael DuPont
Subject: Re: [DotGNU]Implement RDF in a Universal Data Structure
Date: Mon, 31 Mar 2003 07:20:42 -0800 (PST)

--- Seth Johnson <address@hidden> wrote:

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

OK, So Usage is the key abstraction. I dont understand how the shopping
cart is the use type. Purchasing would be the use case, I think. The
shopping cart is itself used. Otherwise, is the use type
ShoppingCartUsage? So the usage of the shopping cart is the thing we
are talking about. The Shampoo is what is in the cart. But what is the
relationship between the cart and the shampoo? Contains?

Why not "ShoppingCart contains Shampoo"?

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

I am slowly getting to understand this..

James Michael DuPont

Do you Yahoo!?
Yahoo! Platinum - Watch CBS' NCAA March Madness, live on your desktop!

reply via email to

[Prev in Thread] Current Thread [Next in Thread]