Split Capabilities: Making Capabilities Scale

[Ken Kahn]

Norm wrote:
>
> >I wont fight over the word "object" but I think you have an interesting
> >distinction.

And MarkM wrote:

> Although I'll fight, I won't insist that you fight ;).

In 1989 I was invited to give a talk at the European Conference on
Object-Oriented Programming and after lots of thought I wrote:

Kenneth Kahn. Objects -- a fresh look. In Stephen Cook, editor, Proceedings
of the Third European Conference on Object-Oriented Programming, pages
207--224. Cambridge University Press, July 1989.

(Sorry I don't have an on-line version.)

For the previous 3 years, we (researchers at Xerox PARC including MarkM and
Dean Tribble) had been working on what we called the Vulcan Project. We had
gotten excited about a paper by Shapiro and Takeuchi on how to do actors in
Concurrent Prolog. We designed Vulcan (and several other subsequent
languages) to hide the underlying concurrent logic programming and provide
the programmer with a powerful actor language. By 1989, I started to think
that hiding the underlying mechanism was a mistake. I argued in "Objects --
a fresh look" that objects were too limitting a way of thinking about
things. The primary notion I argued should be communication channels, not
objects. Object/actor programming takes the view that for each channel there
is a single thing that is receiving its messages. And each "thing" only
reads from a single channel. I argued there lots of other useful patterns.
If something reads from multiple channels it can treat them differently -
each channel can correspond to a facet in the current discussion. There
might be lots of "things" reading from the same channel - cooperatively or
competively responding. And a recipient might become a different kind of
thing after receiving the message or it might become several things. Or it
might terminate but pass it right to receive messages on the channel to
something else. Or...

Concurrent logic programming (and its later generalization to concurrent
constraint programming) provides a very rich substrate upon which to build
secure distributed systems (in a capability-like fashion - see Ken Kahn and
Mark S. Miller. Language design and open systems. In B.A. Huberman, editor,
The Ecology of Computation. North Holland, 1988  and Vijay A. Saraswat,
Kenneth Kahn, and Jacob Levy. Janus--A step towards distributed constraint
programming. In Proceedings of the North American Logic Programming
Conference. MIT Press, October 1990. ). Object-oriented programming is much
less rich, much more narrow view of things. Adding facets helps a bit but
why is this a good way to think about things?

Best,

-ken