Re: Event-Oriented Computing

[glen e. p. ropella]

At 11:23 AM 2/4/99 -0500, you wrote:
>What list was that?

The address@hidden  It's a list run by Peter Small.
It's primarily about what I call "consensual virtual environments" rather
than either ALife or avatars, as I use the terms, of course. [grin]

>Swarm has plenty of goals - some grandiose, some simple. The main goal
>has always been a simulation toolkit, though, and so the concentration
>has been on that.

Ack!  I suppose it's my quirky understanding of simulation that brought
me the conclusion that Swarm was mainly about reifying complex systems.
I know the history and all.  I just make an explicit distinction between
*simulation* and *modeling*.  And through this quirky understanding
and explicit distinction, I come to the conclusion that simulation is 
ambiguous under common usage and can encompass both what I call
experimental mathematics (simply creating logical constructs and 
iterating them to see what they do) and modeling (mimicking some other
system).

Hence, Swarm may have as its only goal to be a simulation toolkit; but,
what KIND of simulation does it target, experimental math or modeling?
(Of course, I realize that, to some extent, my distinction is specious.
But, it helps me understand the difference between the kind of simulation
they do at a place like the SFI and the kind of simulation they do at
a place like Lockheed Martin.)

>I've been actively pursuing some of the other ideas in my research
>since leaving the Swarm project. I've been working on a paradigm I
>call "an ecology of distributed agents" - an environment that supports
>lots of agents interacting with each other, exploring their world (the
>Internet), etc.
>
>I'm deep into this stuff and haven't written enough of it up yet, but
>some of the details are in my master's thesis
>  http://nelson.www.media.mit.edu/people/nelson/research/masters-thesis/
>as well as my current application of these ideas, Hive
>  http://hive.www.media.mit.edu/projects/hive/

Thanks for the putting the links up.   Anyone who hasn't read about Nelson's
work really should.

The objections I have are that your stuff still target's "real computing".
I.e. I don't necessarily want my agents to make contact with anything
other than a virtual world.  And I'd like to be able to construct the 
virtual world in any way I want.  So, to a large extent, the kinds of 
"spaces" we have are in the right vein.  But, they require too much
explicit programming and don't really support the kind of completeness
that allows the agents to learn about the space and the contents of the
space.  The spaces are too simple, I guess.  If you know there's a 
"-depositFood" method for the space, then you know all you'll ever
know about depositing food in the space.

Where you work with a much firmer ontology, I'd like to be able to 
just toss my agents into an ontology they can gradually discover, but
I'd also like ultimately flexible ontology constructing devices.  Does
that make sense?

>Reflection in your OO language goes a long way towards enabling
>exploration. ObjC supports that reasonably well. You also need some
>sort of semantic lookup, though, and that's an open problem. We're
>using RDF, an XML document type, and developing our own schema ad hoc.

Well, reflection is a good attempt; but, it doesn't cut it.  Reflection 
provides an ignorant object a mechanism to get at the truth, so to speak
and to discover object-orientated things about its environment.  What 
I'd like is more of a perception/manipulation system for the truth.  And
I'd like there to be variant truths.  To a certain extent, one can achieve
the latter through things like interfaces and protocols where you send
the same message but you get a different behavior.  But, this still only
allows well-formed messages.  I don't know of anyone working on the 
former.  But, one way to get something like that in place would be to
define some unchanging primatives like "lookOutIntoRAM", which might
return a list of some of the active agents at that time, emphasis being on
SOME of the agents.  Or there might be a template matching technique
like "lookOutIntoRAMFor: <arg>" where arg is a protocol.

And, of course, in this context, RAM might consist of the referrents
of the objects in an ActionGroup or it might be a 2d CA space, for example.

Anyway, these primatives could be used by the agent to build an internal
understanding (that has some measurable variance from the truth) of the
world upon which it bases its actions.  And, like I said, we're already
there with Swarm, to a certain extent, because I could write an application
that did this today as long as I put the primatives into a space and 
tightly coupled the agent's discovery behavior to the spaces "being
discovered" behavior.  I'm just wondering how much lower into the 
Swarm infrastructure we could push this capability so that the user 
didn't have to do it all herself.

The other side of it is that maybe I'm missing something.  Maybe
with reflection and an object/agent registration and semantic lookup,
all this would be *possible*.  But, I still wonder about how easily 
integratable it is with the idea of building some agents and tossing
them into the pool.  I get the impression that it wouldn't be intuitive.
I know that Java reflection and JINI aren't that intuitive from the
little I've done with it.

glen


--
glen e. p. ropella                =><=          Hail Eris!
Home: http://www.trail.com/~gepr/home.html  (505) 424-0448
Work: http://www.swarm.com                  (505) 995-0818  


                  ==================================
   Swarm-Modelling is for discussion of Simulation and Modelling techniques
   esp. using Swarm.  For list administration needs (esp. [un]subscribing),
   please send a message to <address@hidden> with "help" in the
   body of the message.
                  ==================================