Xref: utzoo comp.object:1506 comp.lang.eiffel:1023 comp.lang.c++:8591
Path: utzoo!utgpu!news-server.csri.toronto.edu!cs.utexas.edu!usc!zaphod.mps.ohio-state.edu!sdd.hp.com!apollo!mishkin@apollo.HP.COM
From: mishkin@apollo.HP.COM (Nathaniel Mishkin)
Newsgroups: comp.object,comp.lang.eiffel,comp.lang.c++
Subject: Re: integrating RPC into an Object-oriented system
Message-ID: <4bc94a8a.20b6d@apollo.HP.COM>
Date: 24 Jul 90 18:38:00 GMT
References: <1990Jul18.210701.2679@swbatl.sbc.com>, <2274@east.East.Sun.COM>
Sender: root@apollo.HP.COM
Reply-To: mishkin@apollo.HP.COM (Nathaniel Mishkin)
Organization: Hewlett-Packard Apollo Division - Chelmsford, MA
Lines: 50

In article <1990Jul18.210701.2679@swbatl.sbc.com>, gilstrap@aslan.sbc.com (Brian Gilstrap) writes:
|> The subject pretty much says it all.  Does anyone have any experiences
|> (or pointers to papers or whatever) which they would like to share?
|> I'd greatly appreciate it.

NCS, the RPC system developed by HP (Apollo) is founded on object-oriented
ideas.  There are three references you might want to look track down:

    The Network Computing Architecture and Systems:  An Environment
        for Developing Distributed Applications.  Dineen, et. al.  Summer
        1987 Usenix Proceedings.
    Network Computing Architecture.  Zahn, et. al.  Prentice-Hall, 1989.
    Network Computing System Reference Manual.  Kong, et. al.
        Prentice-Hall, 1990.

While NCS can be used as a conventional RPC system (which is what we
expect people to be doing, at least for now), some of the OO basics are
there.   [Aside:  Since I don't regularly read this group, I'm going
to use Smalltalk's terms as the lingua franca.] In particular, we define
a 128 bit unique ID format (UUID) for use as an object handle.  Objects,
types (Smalltalk's "classes"), and interfaces (a collection of Smalltalk
"message" names) are all identified by UUID.  The system is designed
to support multiple "managers" (i.e., implementations of a set of
interfaces for a particular type) to coexist within a single server.
In fact, the system is really oriented to thinking not of directing calls
to servers, but rather directing "operations" (Smalltalk's "messages")
to objects, the code which manipulates those objects happening to be
loaded in a process (the process being an implementation artifact not
visible to the applier of the operation (caller of the remote procedure).
NCS includes a "Global Location Broker", which can be used to locate
objects by their UUID.

Also, above the low-level RPC system, we (the NCS developers) have tried
to be careful to define (at least the more important) network interfaces
to be generic -- to allow for the possibility of multiple implementations
that can interoperate.  For example, the network naming system (not yet
a product) defines network interfaces for operating on things that are
like directories (i.e., symbol tables that map a component of a pathname
into object UUIDs, and possibly more directory entry attributes).  The
idea is that any object type that handles these interfaces can participate
in the resolution of network-wide pathnames.

Much of this sort of thing has been done before, at least in non-product
form.  BBN's Chronus system and U. of Washington's Eden system come to
mind.

                    -- Nat Mishkin
                       Cooperative Object Computing Operation
                       Hewlett-Packard Company
                       mishkin@apollo.hp.com