Subject: peer-to-peer

From: [email-masked]
Date: Wed, 25 Aug 1993 10:27:29 -0700

After seeing the stalk client, which has a language much like MOO, I
experimented with using a MOO client for Lambda.  A network connection
is made from the client moo to lambda and all the processing is done
with client moo-code.  Of course I had to telnet in to the client to
minimize my hacking of the client moo C code.  I put in a system()
call builtin to make it easy to do local editing by calling up emacs
with the proper text.  Worked like a champ.  There are a number of
issues that should be thought about:

      Escaping from the read loop to do hacking on the client db

      Large process size, not a problem for me, but for students...

      Handshaking with external processes

      Communicating with external processes

      Appropriate and complete client-only builtin set

      Allowing owners-only inbound connections

      Security of local filesystem

An interesting possibility came to me that by running the client moo
as an ordinary one, ie always in the background, it could act as the
player's agent when the player was not actually present.  For
AstroVR that raised some interesting possibilities regarding data
searches, etc.

Another interesting idea popped into my head and that is if the server
moo can know that it is connected to a client moo then it is easy to
always have client moo-code updated automatically, so one always has
the latest and greatest client software.  There are some security
issues here, but they are probably solvable, certainly so on
application-oriented non-wide-open public moos.

I like the stalk client alot, but it has some immediate limitations
once you think up the idea of a moo client.  It does not have an
object oriented archtecture, so building a smart client is lots harder
than it needs to be.  There is only a tiny "core", we already have the
LambdaCore, why not use it?  There are also some sytactic differences
with moo that are annoying and lead to a lot of coding errors in the
first few hours of the learning curve.  The stalk client still has a
few bugs (for example fork()) and needs more documentation on how to
put in new built-ins too.  It does have a system() builtin though, and
it took me only a few minutes to get a protoype of local editing to work.
On the whole, I recommend it for people to play with.  Undoubtedly
some of these limitations will be removed in time.

My moo-client experiment took about 2 hours to do, so anyone
interested might want to repeat the experience and then sit back and
think about what they learned. I assure you it will be interesting.