[unrev-II] William Kent's book "Data & Reality" / Tuplespaces

From: Paul Fernhout (pdfernhout@kurtz-fernhout.com)
Date: Fri Jan 21 2000 - 20:25:42 PST

From: Paul Fernhout <pdfernhout@kurtz-fernhout.com>

William Kent wrote an excellent book around 1978 called "Data &
It has many ideas that are interesting to think about in the context of
constructing an OHS/DKR.

I've been working on my own knowledge storage system for years based on
ideas similar to those in William Kent's book "Data & Reality",
implementing it mainly in Smalltalk and now Python (with earlier
versions in C/C++, Pascal, Lisp, and Forth).

Kent's work has links at:

Kent defines a relational model (not relational database!) similar in
some ways to Gelernter's tuplespaces, but more AI-ish in its knowledge
representation abstraction.

Here is some tuplespace related work:

Basically, most of "Data & Reality" is a long discussion of the
difficulty of representing knowledge as the needs to use it change over
time, and thus the preferred representations.

Near the end of the book, Kent suggests an abstract model called ROSE
for Relation, Object, String, and Executeable. [He also calls it STAR
for Strings, Things, and Relations.] This ROSE model consisting of
* objects (without attributes),
* strings containing binary data,
* executeable processes (like a database trigger), and
* relations (linking any of these types including other relations).
Using these concepts, one can build up arbitrarily complex knowledge

It is difficult to explain easily the power of this abstraction
(compared say to class based OO models, although prototype systems come
close). In short, it is capable of endless elaboration. It is in this
sense more flexible than typical object-oriented models, although it can
be used to do OO programming and modelling.
(I have a simpler variant of it, but in general it does what Kent's
It is somewhat like Prolog in some respects, but less "forced".
One big drawback for the ROSE system is it is so flexible, that the
integrity of the data rests very heavily on the code that manipulates it
or which maintains it.

Let me provide an example (simplifying things somewhat).

Let us say I wish to encode in a Kent-ian ROSE-based OHS/DKR that:
  "Doug Engelbart works at the Bootstrap Institute"

Assume each line here defines a binary relation (the type defined by the
middle node):
  node552111 represents "Doug Engelbart"
  node552111 works-at node552112
  node552112 is-called "The Bootstrap Institute"

where, "represents", "works-at", and "is-called" are also abstract nodes
  node1245 represents "represents" (Yed, this is somewhat cyclic...)
  node1246 represents "works-at"
  node1247 represents "is-called"

So, more correctly:
  node552111 node1245 "Doug Engelbart"
  node552111 node1246 node552112
  node552112 node1247 "The Bootstrap Institute"

And those symbols might actually be:
  node43247 is-a symbol
  node43247 has-text "The Bootstrap Institute"
  node43248 is-a symbol
  node43248 has-text "The Bootstrap Institute"

So, again:
  node552111 node1245 node43247
  node552111 node1246 node552112
  node552112 node1247 node43248

Or, even more compactly:
  552111 1245 43247
  552111 1246 552112
  552112 1247 43248
(with the previous mentioned supporting information and more.)

Various other information might later be elaborated, like:
  node552112 is-a non-profit-organization
  node552112 has-url "http://www.bootstrap.org"

Since relations are also objects, they can be related to, such as:
 (node552112 is-a non-profit-organization) is false

or assuming: node552112 is-a non-profit-organization -> node89822
  node89822 is false

While I showed binary relations here, the Kent model can handle
arbitrary size relations (thus, tuples). In Kent's model, something
  node552111 represents "Doug Engelbart"
might be better shown as:
  represents(object: node552111, representer: "Doug Engelbart")
since this better accomodates more complex relations, like:
  ships(firm: Acme, object: Gravel, destination: Ohio, origin: Iowa)
Underlying his model is the concept of using triads to build relations.

Object-oriented systems can do many of these things (and all of Kent's
types could be modelled using conventional objects), but the closest in
feeling to this sort of system is probably modifying AI datastructures
in Lisp.

Bill Kent was (and is) definitely a thinker ahead of his time. He
eventually left pursuing these sorts of KR systems and now works as a
technical writing at HP (he was at IBM when he wrote that book). He
wrote: "Discouraged by enormous resistance in OMG and similar public
forums, ... I've returned to what has always been my first and real
love, writing." Again, another example (like Atanasoff/Berry, Tesla, and
Engelbart) of the difficulty of being ahead of the dominant paradigm.

-Paul Fernhout
Kurtz-Fernhout Software
Developers of custom software and educational simulations
Creators of the Garden with Insight(TM) garden simulator

--------------------------- ONElist Sponsor ----------------------------

  Hey Freelancers: Find your next project through JobSwarm!
  You can even make money in your sleep by referring friends.
<a href=" http://clickme.onelist.com/ad/jobswarm1 ">Click Here</a>


Community email addresses:
  Post message: unrev-II@onelist.com
  Subscribe: unrev-II-subscribe@onelist.com
  Unsubscribe: unrev-II-unsubscribe@onelist.com
  List owner: unrev-II-owner@onelist.com

Shortcut URL to this page:

This archive was generated by hypermail 2.0.0 : Tue Aug 21 2001 - 18:56:37 PDT