Attribution tuples (was Re: HLL Primitives)

Brian T Rice
Thu Feb 6 23:15:01 2003

Branching the topic for specificity...

On Thu, 6 Feb 2003, Francois-Rene Rideau wrote:
> As for a conceptual model for attributes, etc. - in Tunes,
> I think that what I had in my mind when I wrote this page
> was that the "state" of the system at any moment could be seen as a set
> of (attribute, object(s), value(s)) tuples that are known to hold.
> This view of the world is that of various knowledge-based systems,
> and it might also satisfy our relational database loving Mad70.
> As opposed to an simple relational databases, however,
> our semantics integrates dynamism deep inside the knowledge base,
> whereas relational databases are static stuff that are modified
> by external dynamic agents. (This statement begs for formalization.)

So to add my editorial or maybe refine this explanation a bit, let's say
we call these tuples "attribution" tuples, and give the elements with
these names:

<key, object(s), value(s)>

I relabelled "attribute" to "key" to give it the notion of access, as well
as the fact that we seem to be agreeing on capability-like security, which
relies on such access to be like a physical key: not handed out without
proof or user assumption of trust (imagine a dialog popping up).

(I am very amused at how similar this idea is to what I had in mind for
Arrow, but this is not the time for that. Nevertheless I am bringing my
experience with Arrow to this discussion necessarily.)

There's still an issue with distinguishing object and value
conglomerations as conglomerations rather than the objects that the
conglomerations *are* (yes, that's really confusing. Just imagine a
collection object of any kind). So this kind of tuple would specially
treat a certain type of object, but there would need to be some quoting
mechanism in order to treat that object itself as an object.

Finally, the nature of this tuple concept as it relates to active
annotations or annotations that are computational is not precise, or at
least it doesn't relate to our concrete idea of a tuple. I suppose that a
meta-object protocol for attribution tuples would handle this nicely. But
that is ignoring the issue. We'll just assume that there is some rewrite
specified, which is trivial in the intuitive cases.

I am putting together a new and need to
survey the whole concept. I'll use those expanded basics to work out the
primitives in greater detail.

Does this make more sense to everyone?

Brian T. Rice
LOGOS Research and Development