comp.agents? (was: Dylan Agents)

Steven D. Majewski (
Thu, 25 Aug 1994 17:56:50 -0400

in Message-Id: <> in comp.lang.dylan
"Richard M. Emberson" <> wrote:

> Mr. Stephen McConnell had asked me last week if my interest in being able
> to ship Dylan code around a network had to do with agents.
> After replying that at best I was interested in very dumb agents
> I got to thinking about the more general problem of implementing
> agents with Dylan a la telescript/General Magic.
> The folks at General Magic have thought long and hard about how
> one would implement agents (at least harder and longer than I have)
> and have come up with criteria that have to be addressed in order to
> have a useful agent (a useful agent is not just one that you
> can write but, more importantly, one that someone will let onto their
> machine). The following issues are based upon my meager knowledge of
> telescript and 10 minutes of random neural activity:

[ ...excellent summary deleted... ] - Thanks!

Someone else who has thought about distributed agents from a different
language perspective is Luca Cardelli at Digital SRC, who has developed
a object-oriented language for distributed applications: Oblique.

[quoting from his paper at that site:]

| The guiding principle that separates Obliq from other distributed
| procedural languages is the adherence to lexical scoping in a
| distributed higher-order context. This principle is conceptually
| simple and has a number of interesting consequences: it supports a
| natural and consistent semantics of distributed computation, and it
| enables elegant techniques for distributed programming.

[ ... ]

| Lexical scoping has many interesting implications in a distributed
| context. One is that, together with strong run-time typing and
| interpreted execution, it can provide network security guarantees.
| Consider the situation of a server executing incoming foreign agents.
| Because of lexical scoping, these agents have access only to the data
| and resources that they can reference via free variables or that they
| explicitly receive in the form of procedure parameters. In particular,
| foreign agents cannot access data or resources at the server site that
| are not explicitly given to them. For example, operations on files in
| Obliq require file system handles that are available as global
| lexically bound identifiers at each site. A foreign agent can operate
| on the file system handle of its originating site, simply by referring
| to it as a free identifier. But the file system handle at the server
| site is outside its lexical scope, and hence unobtainable except with
| the cooperation of the server. Degrees of file protection can be
| represented by file system handles with special access rights.

Nathaniel Borenstein has also thought about this from the perspective
of emabled mail applications and safe-tcl:

[ from the tcl-faq: ]

| 63. The following are a series of references to papers
| relating to the Safe TCL package.

However, I'm not convinced that the safe-tcl method would work well
for other, more general types of agents. ( I haven't studied it in
depth, but there does seem to be too much dependence on pop up
warning dialogs, etc., but maybe that's not as essential to the core
facility as it looks. )

Even if safe-tcl were a completely acceptable general solution, there
is still reason to consider ways to add safe distributed agent
capability to other languages: This topic came up on the python mailing
list, not primarily as an effort to duplicate the functionality of
safe-tcl, but to allow distributed and cooperative programming and
eliminate the need for central management of a program/module library.

Perhaps COBRA/OMG/DSOM/IDL is the way to provide these capabilities
in a language neutral manner. I don't know - I haven't had time to
read up on the protocols in detail. I don't get the impression that
they SOLVE any of these problems, but perhaps they provide another

I have also seen this topic come up on www-talk, and other WWW
related lists: there is interest in allowing servers to send code
to be executed on the client side, as well as providing more general
programmable agents on the server side. The WWW protocols also seem
to be headed towards trying to provide the same sort of functionality
as OpenDoc promises.

From the cross posting in the newsgroups line, you can probably guess
I'm trolling for more examples & citations. ( Maybe we need a new group
to discuss programming systems for safe distributed agents ? )

Of course, what is particularly unique in the Telescript seems to be that
negotiation of the cost of resources is built in at a low level. The
typical direction of agents is for clients to be sending agents to
various servers. ( Is there any facility to go the other way? )

-- Steve Majewski (804-982-0831) <sdm7g@Virginia.EDU> --
-- UVA Department of Molecular Physiology and Biological Physics --
-- Box 449 Health Science Center Charlottesville,VA 22908 --
[ "Cognitive Science is where Philosophy goes when it dies ...
if it hasn't been good!" - Jerry Fodor ]