Xref: utzoo comp.object:1489 comp.lang.eiffel:1016 comp.lang.c++:8531
Path: utzoo!utgpu!news-server.csri.toronto.edu!cs.utexas.edu!usc!apple!voder!pyramid!athertn!joshua
From: joshua@athertn.Atherton.COM (Flame Bait)
Newsgroups: comp.object,comp.lang.eiffel,comp.lang.c++
Subject: Re: integrating RPC into an Object-oriented system
Message-ID: <27463@joshua.athertn.Atherton.COM>
Date: 20 Jul 90 00:04:48 GMT
References: <1990Jul18.210701.2679@swbatl.sbc.com>
Reply-To: joshua@Atherton.COM (Flame Bait)
Organization: Atherton Technology, Sunnyvale, CA
Lines: 40

> = stuff written by gilstrap@aslan.sbc.com (Brian Gilstrap)

> The subject [integrating RPC into an Object-oriented system]
> 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.

I'm not aware of any papers describing this, so if you do this well, please
write a paper for the rest of us.  I do have some ideas and thoughts:

Ideally OO, which is a design and implementation methodology, should not
conflict with (or interact with) RPC, which is a communications service
provided by the environment.  Unfortunately, both deal with data structures.
RPC must know about data structures so that it can translate them from
machine to machine, and OO implementations handle data structures differently
from other systems.

There are two problems making an RPC system work with an object oriented 
system.  First, many OO systems are dynamic; they change at run time, often 
adding new methods or data types.  Second, the describe data differently, 
often saying this data structure is just like that data structure except 
for....

The second problem can be solved by changing the language used to describe
RPC calls, giving it a more OO feel.  This is especially easy to do with
Sun RPC, but can be done with other RPCs.  The first problem may not 
exist at all if all of your methods and object types are described at
compile time.  It they are changed at run time, then there are two possible 
solutions.  If you are using Sun RPC, an autoloader could be used to update 
the RPC system for each new method or object type, or a general interpreter
could be written to handle all cases.  I'm not sure if these solutions 
would work for other RPC systems.  I suspect that they could work, but it
would be harder.

> Related thoughts (e.g. integrating TCP with OO systems) are welcome as well.

This is a much simpler question, since TCP does not deal with data typing,
it is just a library which can be called from any application, independant
of what methodology or language was used to implement the application.

Joshua Levy  (joshua@atherton.com)