On Mon, Dec 13, 1999 at 02:07:01PM -0500, Stephen Pair wrote:
> 
> Having experience in attempting this in another dialect, and hearing other
> experiences, my opinion is that one should aviod it.  But, rather I would do
> something like Bob suggests (or something a little tighter than sockets).
> The ultimate goal would be to have multiple VMs (one per processor), each
> with an ObjectMemory that can communicate with the other(s).  A nice load
> balancer that could shift object closer to the objects that use them would
> also be nice.
> 
> One could use the replicator and forwarder approach, but a nicely reified
> object reference scheme would make things much cleaner.
> 
> - Stephen
> 

Is it possible to extend this to cover a whole network?

I'm thinking for some time about trying to build some kind of 
"Distributed Squeak". 

OOP ---> many computers at you fingertips
-----------------------------------------

As (I think) Alan wrote somewhere, OOP is the recursion of the idea of the 
computer: instead of building a programm out of weaker sub-parts like 
procedures and datastructures, a OOP-System is build out of many little 
computers that communicate via a very fast "network".

Somehow it seems to be very interesting to extend this to cover
a real network: One VM for every processor in the Network. Then
we need 
     -> Remote messaging ("RMI")
     -> Object migration
     -> ...

Maybe we can think about this to be somewhat like an "Object ecology". 
The Objects should reason about where to live, e.g. 

 -> if it is better to move to the supercomputer when they 
    need much computing power.

 -> make backup-copies and move these to other computers
    (and keep them up to date)

 -> if no messages are received or send it may be better to live
    on the disk. 
 
 -> move towards the objects that do a lot of communication.

The objects should be somewhat like Agents that try to satisfy these
conditions.

Some examples:

--> The Web
Small object (called "WebPages") migrate to your computer and 
draw themselves on the canvas. 

--> Client <--> Server Vs. X11 Vs. local applications
 
 Today we have three kinds of apps:
 
 -> X11-like: The app runs on the server, the client has only
    a Canvas for displaying. In the OO-context this is an application
    that uses a Canvas-Object via remote-messaging.

 -> Client-Server:
    A small part (user-interface) runs on the client, the rest
    (e.g. database) is on the server. 

 -> local applications.

With the Distributed System, these three different application-designs
would be built dynamically. A computer would start with just a canvas and
a VM, but as soon as the user starts working  with the system, the objects 
start to move to his computer. If the app is small the whole application 
moves, but large systems are partitioned automatically into a client and a 
server. 

This system (if it is possible to built it) would have all positive
sides of both central (e.g."Hosted Applikations") and client-server 
systems. 

Computer Networks -- building on shifting sand
----------------------------------------------

Computer Networks are amazing ... they manage to build working systems
on top of unreliable ground. It is not garanteed that a IP-Paket reaches
the destination, but despite the unreliable base-system the next level
(e.g. TCP) manages to build a reliable connection.

It would be good if the Computer itself could be built in such a way.

Imagine a system where the "software" is *totally* abstracted from the
"hardware". Like data is transfered across an unreliable IP-Connection, 
the programm runs on a network of many, but unreliable computers (that e.g. 
can be switched off). 
 
Yes, when communicating via networks only bits are shifted from one computer
to the other, so it's simple to be fault-tolerant. (just re-send the bits).

I was very excited when I discoverd that OOP does everything via
message-passing. The state of objects only change via messages (bits
passed from one object to another...). So it may be possible to built
a reliable OOP-System on top of many unreliable computers.  

(There are *many* problems to be solved to make this work, and
the big question is if that can be made fast enough to be usefull...)

But it would be cool to have: Imagine a programm running on 15 Computers,
one computer is switched off. But the programm keeps on running... 

----

I have *no* idea if such a fault-tolerant, distributed OO System
is possible. But somehow I like the idea...


  Marcus 


-- 
Marcus Denker marcus at ira.uka.de phone at home:(0721)614235 @work:(0721)608-2749
Imitating paper on a computer screen is like tearing the wings off a 747 and
using it as a bus on the highway. -- Ted Nelson