How to Coordinate Internet Applications based on Mobile Agents Giacomo Cabri, Letizia Leonardi, Franco Zambonelli (*) Dipartimento di Scienze dell’Ingegneria Università di Modena Via Campi 213/b – 41100 Modena – ITALY Phone: +39-59-376735 Fax: +39-59-376799 E-mail: {giacomo.cabri, letizia.leonardi, franco.zambonelli}@unimo.it (*) Corresponding Author Abstract Internet applications can take advantage of a new design paradigm based on mobile agents. However, the presence of mobile active computational entities introduces peculiar problems in the coordination of the application components. The paper surveys the possible coordination models for mobile agent applications and evaluates them in the context of a widely distributed application in the area of WWW information retrieval. The analysis outlines the advantages and the drawbacks of each coordination model and shows how reactivity of the coordination media can provide the degree of flexibility and adaptivity required by mobile agent applications. Keywords: Mobile Agents, Coordination, Reactive Blackboards, WWW Information Retrieval
1
Introduction The shift from intra-net environments to Internet of several application areas, together with the
raise of several new Internet-oriented applications, requires new design and programming paradigms. Traditional distributed applications are designed as a set of processes statically assigned to a given execution environment (therefore acting as managers of local resources) that cooperate in a (mostly) network-unaware fashion [Adl95]. Instead, the mobile agent paradigm defines applications composed by network-aware entities (agents) capable of actively changing their execution environment by transferring themselves while executing (mobility) [Cug97]. 1
The current interest in the mobile agent paradigm is widely justified by the advantages it provides over traditional approaches in Internet applications [Wal97]: (i) mobile agents can dramatically save bandwidth, by moving locally to the resources they need, instead of requiring the transfer of possibly large amounts of data; (ii) mobile agents can carry the code to manage remote resources without needing the remote availability of a specific server and thus leading to a more flexible application scenario; (iii) mobile agents do not require continuous network connection, because interacting entities can be moved to the same site when the connection is available and interact without requiring further network connection; as a consequence (iv) the mobile agent paradigm intrinsically suits mobile computing systems. In the last few years, several systems and programming environments have appeared or been proposed to support the development of Internet applications based on mobile agents [MOS97, MA97]. Nevertheless, there are still several issues to be solved to make the mobile agent technology widely accepted: definition of appropriate programming languages and coordination models, security, efficiency and standardisation [Cug97]. In mobile agent applications, one of the fundamental activities is coordination between agents and the entities they encounter during execution, let these entities be other agents or resources on the hosting execution environments. However, mobility of application components and wideness of the distribution area imply different problems than traditional distributed systems. The paper introduces a simple taxonomy of the coordination models that can be adopted in mobile agent applications and systems. Four main categories are identified, classified depending on the degree of coupling (either spatial or temporal) they induce on the cooperating entities [GelC92]. A distributed application in the area of WWW information retrieval is used as a testbed example to evaluate the advantages and the drawbacks of different coordination models and their impact in the application design. The paper shows that coupled coordination models, though widely adopted by several systems and environments, do not suit mobile agent applications and force complex design schemes in applications. Instead, fully uncoupled coordination models have the necessary adaptivity to suit the wide and heterogeneous Internet scenario and, moreover, lead to simple application design. In addition, the paper shows how further flexibility and safety can derive from the introduction of a reactive coordination model, that can be programmed to react to the actions of mobile agents [Bau97, DenNO98]. The paper is organised as follows: section 2 introduces the case study application. Section 3 presents and evaluates the possible coordination models for mobile agent applications. Section 4 discusses how reactivity can enhance the coordination models. Section 5 concludes the paper by outlining open research directions. 2
2
The Case Study Application The application we assume as testbed to evaluate the impact of different coordination models in the
design of widely distributed mobile agent applications relates to WWW information retrieval. Let information be stored in HTML pages spread over Internet and let the user be interested in all HTML pages that include one specific keyword. The user knows one site (to be used as starting point for the search) where to find interesting (i.e., matching the keyword) documents. From there, other sites containing further interesting information can be found by following the links contained in the HTML pages. A traditional (non mobile) design for this application could be based on a client-server mechanism: a local process asks for a page to the WWW server, retrieves and analyzes it and repeats the same process following the links found in the document that are supposed to be of interest (i.e., pointing to other pages that are likely to match the keyword). The mobile agent design is based on searching agents that move locally to a site, locally analyse the stored documents and follow the interesting links by cloning themselves. The application starts by making the user create a first agent (root agent) and send it to the starting site, with the goal of analysing the HTML pages there allocated and yielding back the URL of interesting pages. If the root agent finds interesting documents containing links to other sites, the agent clones itself (i.e., it creates a new agent with the same code) for any link to follow (see figure 2) and, then, comes back to the user site with the found information1. The higher efficiency and reliability of this design over the non-mobile one is evident: (i) it saves bandwidth by avoiding the transfer of a large amount of data; (ii) it does not require continuous network connection to proceed. Agent To user site
Agent
Cloned agent
Agent
Link Link
HTML
Link
Link
HTML
Link
HTML
Link
Cloned agent
a
b
c
Figure 1. An agent arrives to a site (a), accesses to the local HTML pages (b) and creates a new agent for any link to be followed before returning to the user site (c)
1
Because agents are organised in a tree, we can take into account the depth of the agents’ tree via a non-negative integer value, to fix a maximum depth and avoid endlessly agent creation.
3
3
A Taxonomy of Coordination Models for Mobile Agent Applications During its nomadic life, an agent is in need to coordinate its activities with other active entities, let
them be resources on the hosting execution environments or other mobile agents. More in particular: •
an application may be composed of several mobile agents that cooperatively perform a task and, then, are in need of coordinating their activities.
•
a mobile agent is usually in need to roam across Internet to access to remote resources and services allocated on some node of the network; In the application example, inter-agent coordination is needed to avoid multiple visits on the same
site. It is common to find cross-references in HTML pages: if sites A and B contain similar information, it is highly probable that pages in A contain links to pages in B and viceversa; in some cases, more complex circular chains (i.e., composed of several intermediate links) can be found. These references would make application agents visit several times the same sites, thus duplicating searches and wasting time and resources. Agent-to-local execution environment coordination aims to define a precise protocol to retrieve information on a site. The trivial solution of letting an agent directly accesses the local HTML page is not advisable: on the one hand, because of its evident security lacks; on the other hand, because agents may have no knowledge of the local file system structure; While the above coordination issues have been extensively studied in the past [Adl95, GelC92], mobility and the openness of the environment introduce new problems and needs. In this section, we define a simple taxonomy of the possible coordination models for mobile agent applications, together with a brief survey of the proposals of several mobile agent systems. Two main characteristics distinguish different coordination models: spatial and temporal coupling. In particular: •
spatially coupled coordination models require the involved entities to share a common name space; conversely, spatially uncoupled models enforce anonymous interactions;
•
temporally coupled coordination models implies synchronisation of the involved entities; conversely, temporally uncoupled coordination models achieve asynchronous interactions;
From the above two characteristics, four main categories of coordination models can be derived (see figure 2): (i) direct, both spatially and temporally coupled; (ii) meeting-oriented, spatially uncoupled and temporally coupled; (iii) blackboard-based, spatially coupled and temporally uncoupled; (iv) Linda-like, spatially and temporally uncoupled. The following of this section details the above four models, evaluates the advantages and the drawbacks of different coordination models – w.r.t. the peculiarities of mobile agent applications – and shows how the adoption of each model impacts in the case study application. 4
Temporal
Coupled
Spatial Uncoupled
Coupled
Uncoupled
Direct
Blackboard-Based
Odissey Agent-TCL
Ambit ffMain
Meeting-Oriented
Linda-like
Ara OMG Events
Jada MARS TuCSoN
Figure 2. Coordination Models for Mobile Agents
3.1 Direct Coordination In direct coordination models, agents initiate a communication by explicitly naming the involved partners (spatial coupling). In the case of inter-agent coordination, two agents must agree on a communication protocol, typically a peer-to-peer one. In the case of the access to the hosting environment local resources, coordination usually occurs in a client-server way: the hosting environment provides local servers for the management of its resources; the agent requires a given service supplying the needed parameters (among which, if needed, the code of the service itself [StaG90]) and waits for a reply. Direct coordination usually implies synchronisation of the involved entities (temporal coupling). The general adoption of direct coordination models in Internet applications is not suitable. Making two mobile agents directly communicate at wide scale, in fact, introduces the need of localising them, by means of complex and highly informed routing protocols. In addition, repeated interactions require a stable network connection, making communication highly dependent on network reliability and possibly leading to failure or unpredictable delays. Finally, several mobile agent applications are intrinsically dynamic (because of dynamic agent creation), thus making it difficult to adopt a spatially coupled model that require to identify the partner of the communication. In the application example, adopting a direct coordination model is not trivial: agents cannot know how many other agents are there in the application, because agents are dynamically created depending on the found links. Exploiting broadcast to all application agents is clearly not feasible in a world-wide scale because of its cost. In addition, to establish a communication session, agent must be forced to synchronise their activities that are, instead, intrinsically asynchronous and autonomous. The adoption 5
of a direct coordination model in the application example forces odd design choices, i.e., one must introduce some “ad hoc” application entities to deal with inter-agent communication. For example, we could choose a site, let it be the user site, where a fixed entity assumes the role of communication management server. Whenever an agent arrives to a site, it asks this server if the site has already been visited; in positive case, the agent comes back to the user site without further investigation in that site, otherwise its duty is to inform the communication server to mark the site as visited. It is clear that this solution produces high traffic on the network, makes the communication server a bottleneck and requires stable network connections, thus nullifying most of the advantages deriving from the adoption of the mobile agent paradigm. In presence of widely mobile agents, direct coordination models can be effectively exploited only for the access to the local resources: a local server is provided as manager and an agent interacts with it in a client-server way. In the application example, local WWW servers may supply HTML pages to agents. Most of the Java-based agent-systems – like Sumatra [AchRS97] and Odyssey [Gen97] – adopt the client-server style typical of object systems. At a higher level, the client-server coordination model typical of the object-oriented paradigm can be exploited for all kinds of interactions, even between remote objects via RMI. At a lower level, they can directly exploit TCP/IP that, though very flexible, is complex to program and requires the precise definition of a message exchange protocol. Agent Tcl [Gra96] provides direct communication between two agents, based on message-passing, and also provides asynchronous communication modes.
3.2 Meeting-Oriented Coordination Meeting-oriented coordination aims to define a spatially uncoupled model, in which agents can interact with no need of explicitly naming the involved partners. Interactions occur in the context of meetings. Apart from always-opened meeting – that can abstract the role of servers in an execution environment – an active entity must assume the role of meeting initiator to open and define a meeting point. Agents join (either explicitly or implicitly) known meeting points and can then communicate and synchronise with the other agents participating in it. Often, meetings are locally constrained: to avoid the problems related to non-local communication (i.e., unpredictable delay and unreliability), a meeting takes place at a given execution environment and only local agents can participate in it. Clearly, to permit meetings, full spatial uncoupling cannot be permitted: agents must, at least, share the common knowledge either of the meeting names or of the events that force them in joining a meeting. While the meeting model partially solves the problem of exactly identifying the involved partner, it 6
has the drawback of enforcing a strict synchronisation between agents. Because in many applications the schedule and the position of the agents cannot be predicted, the risk of missing interactions is very high. In addition, if the meeting is not locally constrained, it has to be implemented by messagepassing, thus inheriting all the drawbacks (in terms of efficiency and unreliability) of direct coordination models. In the testbed application, a tentative solution to avoid multiple visits on the same site with a meeting-oriented model could be to make an agent enter a meeting as soon as it arrives to a new site. This would permit it to “meet” there all the other agents that have eventually visited the site. However, the agent has no way of knowing if other agents will ever enter that meeting and how many: if it is the first one that visit the site, no other agent will join the meeting. In addition, an agent that has already visited some site, has no way on knowing when its presence is needed in a meeting on previously visited sites. The only feasible way to exploit this coordination model in the application is via a locally constrained meeting, by introducing an additional agent for each visited site. When an agent has explored a site, instead of leaving the site unattended, it creates a “meeting” agent before coming back to the user site. The meeting agent is forced to reside on the creation site: as any other agent arrives to this site, it locally checks the presence of the meeting agent to detect whether the site has been already visited or not. This design solution produces less network traffic and is fully distributed. In addition, the solution could lead to sophisticated policies for agent coordination. The meeting agent, for example, instead of acting as simple notifier of an already occurred visit, could keep track of the last visit time. This can give the capability to further incoming agents of incrementally retrieving data, i.e., retrieving only the HTML pages that have been modified or added since the last visit. Nevertheless, the rendezvous solution forces one meeting agent to remain on each visited site. This leads to several drawbacks: an agent intrudes on the host system and tends to consume resources even when idle; a malicious agent can exploit the time it is on a site to furnish private information to the external. In addition, in the case study application, there is no possibility for the meeting agent of knowing when to die. Meeting-oriented coordination is implemented in Ara [PeiS97]: one agent can assume the role of meeting server and announces a meeting point at one hosting environment; local client agents can enter the meeting to coordinate each other. The concept of event-based communication and synchronisation, defined by the OMG group [OMG94] and analysed for application to mobile agents in [Bau97], achieves spatial uncoupling by associating meetings to events, i.e., accesses to synchronisation objects of a specific type, of which agents must share the reference to, as if it were the name of the meeting.
7
3.3 Blackboard-based Coordination In Blackboard-based coordination, agents interact via shared data spaces, associated to each hosting environment and local to it, used as common repositories to store and retrieve messages. In this sense, interactions are fully temporally uncoupled but, as far as agents must agree on a common message identifier to communicate and exchange data via a blackboard, they are not spatially uncoupled. The most significant advantage of indirect coordination models derives directly from temporal uncoupling: messages can be left on blackboards, without needing to know neither where the corresponding receivers are nor when they will read the messages. This clearly suits a mobile scenario in which the position and the scheduling of the agents can be easily neither monitored nor granted. In addition, being any inter-agent interaction forced to be performed via a blackboard, hosting environments can easily monitor and control all interactions, thus leading to an execution model more secure than the one of direct coordination. The drawback of the blackboard-based models stems from spatial coupling, which requires interacting entities to agree on common message names. Our application example can effectively exploit the blackboard model for inter-agent coordination. When an agent arrives on a site, it firstly checks in the blackboard for a “marker” message, coming from another agent of the same application. For example, a message could be a tuple in the following format: (User “
[email protected]”, keyword “word_to_search”, visit_time 09/27/1997:23.51)
where the first field uniquely identifies either an application or a user, the second field is the keyword string upon which the search has been based, the third field specifies the date and time of the last visit. If the agent obtains the message, it knows that the site has already been visited. If the message is not found, the agent itself is in charge of leaving a marker message in the blackboard. With regard to agentto-local execution environment interactions, a blackboard can be exploited to let agents retrieve the needed information without requiring the presence of a specialized resource manager and to let the local environment provide in the blackboard all the data it wants to publish while protecting private data. In the application example, the local execution environment could provide, in form of tuple message, the pathnames of all its publicly accessible files. However, because of spatial coupling, the blackboard cannot be effectively exploited for accessing the information about the local html pages. If no associative access to the blackboard is permitted, there is not way for an agent to retrieve only the pathnames of the html files but at the price of retrieving all messages and to successively select only those ones corresponding to html files. 8
Several systems propose and implement blackboard-based coordination models for mobile agent applications. In Ambit [CarG97], a recently proposed formal model for mobile computations, agents can "attach" a named message to a blackboard on a given system, like a post-it; another agent can retrieve and read this message. The ffMAIN agent system [DomLD97] defines mobile agents that interact – both with other agents and with the local resources of the hosting execution environment – via an information space accessed through the HTTP protocol, where data can be stored, read and extracted. In the access to the information space, a unique key identifies each data item.
3.4 Linda-like Coordination In Linda-like coordination models, the accesses to the local blackboard are based on associative mechanisms [CarG89]: information is organised in tuples, retrieved in an associative way via a patternmatching mechanism. Associative blackboards enforce full uncoupling, requiring neither temporal agreement nor mutual knowledge to let agents coordinate. Associative coordination suits well mobile agent applications. In a wide and dynamic environment as Internet, having a complete and updated knowledge of the hosting execution environments and of the other application agents may be difficult or even impossible. Then, because agents would somehow require pattern-matching mechanisms to adaptively deal with uncertainty, dynamicity and heterogeneity, it is worthwhile to integrate these mechanisms directly in the coordination model itself, to simplify agent programming and to reduce application complexity. In our application example, associative mechanisms may not be necessary for inter-agent interactions, because agents know which message to retrieve from the blackboard to avoid multiple visits, as shown in the previous sub-section. However, let our application be composed of several kinds of agents, with each kind devoted to the search for a different keyword. In this case, an associative mechanism would be necessary: an agent has to check in the blackboard for the presence of marker messages with the keyword field that matches the agent’s own keyword; instead, it has to ignore those messages that (though belonging to the same application) have been left by agents searching for different keywords. With regard to agent-to-local execution environment interactions, if the pathnames of all public readable files are available in the blackboard, agents can simply look for tuples corresponding to pathnames matching the “html” extension. The concept of associative blackboard has been implemented, atop of Java, in the Jada system [CiaR97]: the so-called ObjectSpace abstraction can be used by mobile agents to store and associatively retrieve object references; furthermore, agents can create private ObjectSpaces to privately interact 9
without affecting hosting execution environments.
4
Adding Reactivity to the Coordination Model All above described coordination models can be enriched with reactivity. In this context, reactivity
of the coordination model stems from the capacity of embodying computational capacity within the coordination media to let it issue specific programmable reactions that can influence the behaviour of the interactions between agents [DenNO98]. In a reactive tuple space model, the tuple space is no longer a mere tuple repository with a built-in and stateless associative mechanism. Instead, the tuple space can also have its own state and can react with specific actions to the accesses made by mobile agents. Reactions can access the tuple space, change its content and influence the semantic of the agents’ accesses. This kind of reactivity can provide several advantages. Reactions can be used to implement specific local policies for the interactions between the agents and the hosting execution environment, to achieve better control and to defend the integrity of the environment from malicious agents. In addition, reactions can adapt the semantics of the interactions to the specific characteristics of the hosting environment, thus simplifying the task of agent programming much more than the fixed pattern-matching mechanism of Linda. Furthermore, the reactive space can embody inter-agent coordination rules to simplify the task of agent programming and to achieve a clear separation of concerns between algorithmic and coordination issues [GelC92, Cia96, Weg97] In our application example, the presence of a reactive blackboard could find several interesting applications, let us suppose that one hosting execution environment is a local WWW server whose HTML pages are replicated in one or several mirror sites. In this case, when an agent visit this site, not only the other agents of the same application must avoid further visit on the same site, but they should also avoid visits to the mirror sites. A reactive blackboard can be programmed by the local administrator to react to the local insertion of marker messages in order to coordinate with mirror sites and there replicate the agents’ marker messages. The administrator of a site could also decide to exploit blackboard reactivity to delete the marker messages locally left by agents, on the basis of a maximum allowed lifetime. In our application, this could be very useful because of the intrinsic difficulty for application agents to know whether a marker message on a visited site is further needed to other application agents. As another example, by recalling that the Linda model defines a disruptive “in” operation that extract matching tuples from the space, let us suppose a malicious attempt to extract html tuple from one site. In this case, the local administrator can decide not to raise any exception but, 10
instead, to program its local tuple space in order to transform a disruptive operation performed by a foreign agent into a non-disruptive read. In this way, the agent proceeds without being aware of the innocuous effect of its access; the administrator has preserved the safety of the local environment. By giving agents the capability of deciding their own coordination rules (that could assume, for example, the form of simple high-level directives separated from the application), to be installed as reactions in the tuple spaces of the visited sites, could provide further advantages in the application. For example, a directive associated to the agent could provide to install in the visited blackboard a reaction that denies to further incoming agents the access to those HTML files whose corresponding pages have not been modified since the last visit. Different proposals in different contexts aim to integrate some degree of reactivity in the coordination models. Researches in the area of active networks [Ten97] and of active messages [Van92], can somehow categorised as effort to build dynamic and programmable direct coordination models. In the event-base meeting-oriented coordination model [Bau97], synchronisation objects can embody specific policies to influence the interactions between the agents involved in a meeting. The TuCSoN model [OmiZ98], derived from the ACLT coordination media [DenNO98], defines programmable logic tuple centres for the coordination of knowledge-oriented mobile agents. The Tuple space defines a Linda-like interface; reactions are programmed as first-order logic tuples. The MARS system implements a portable reactive blackboard for the coordination of Java-based agents [CabLZ98]. The tuple space interface is defined accordingly to the JavaSpace specification [Sun97]; reactions are programmed as Java methods associated to tuples. Another interesting effort in the area of reactive tuple spaces, that could be easily extended to support mobile agents, is the PageSpace project [Cia97], a coordination media for distributed Web applications. The presence of special purpose agents accessing the space and changing its content can provide the capability of influencing the coordination activities of the application agents.
5
Conclusions and Open Directions The mobile agent technology leads to a most promising design paradigm for Internet applications.
However, the presence of mobility requires suitable coordination models to facilitate the application design and to solves the problems related to interactions in a wide and heterogeneous environment. In this paper, we argue that only Linda-like coordination models exhibits the necessary adaptivity and scalability needed by mobile agent applications. Furthermore, the paper shows how a reactive tuple space model can increase the flexibility and the security of mobile agent applications. 11
To our personal opinion, mobile agent coordination represents a key topic in the Internet area and several research issues still need to be faced toward the wide diffusion and acceptance of Internet applications based on mobile agents. In particular: •
how could the mobile agent paradigm be seamlessly integrated into the WWW ?
•
what will it be the role of the HTTP protocol in the context of mobile agent coordination ?
•
how could the mobile agent paradigm be integrated with CORBA ?
•
how and to which extent mobile agent can be allowed to spread over Internet sites their coordination rules ?
All the above issues are interesting starting points for future study in the area.
References [AchRS97] A. Acharya, M. Ranganathan, J. Saltz, “Sumatra: a Language for Resource Aware Mobile Programs, Mobile Object Systems, Lecture Notes in Computer Science, No. 1222, Springer Verlag (D), pp. 111-130, February 1997. [Adl95]
R. M. Adler, ‘Distributed Coordination Models for Client-Server Computing’, IEEE Computer, Vol. 29, No. 4, April 1995, pp. 14-22.
[Bau97]
J. Baumann, F. Hohl, N. Radouniklis, K. Rothermel, M. Strasser, “Communication Concepts for Mobile Agents”, Proceedings of the 1st International Workshop on Mobile Agents, Berlin (D), Lecture Notes in Computer Science, No. 1219, Springer-Verlag (D), pp. 123-135,April 1997.
[CabLZ98] G. Cabri, L. Leonardi, F. Zambonelli, “Mobile Agent Reactive Spaces”, submitted for publication, Feb. 1998. Available at http://sirio.dsi.unimo.it/MOON/papers. [CarG89] N. Carriero, D. Gelernter, “Linda in Context”, Communication of the ACM, Vol. 32, No. 4, pp. 444-458, 1989. [CarG97] L. Cardelli, A. D. Gordon, “Mobile Ambient”, (available at http://www.research.digital.com/SRC/personal/Luca_Cardelli/Ambit/Ambit.html), 1997. [Cia96]
P. Ciancarini, “Coordination Models and Languages as Software Integrators”, ACM Computing Surveys, Vol. 28, No. 2, pp. 300-302, June 1996.
[Cia97]
P. Ciancarini et al., “Redesigning the Web: From Passive Pages to Coordinated Agents in PageSpaces”, 3rd International Symposium on Autonomous Decentralized Systems, ISADS97, pp. 377-384, 1997. http://flp.cs.tu-berlin.de/~pagesps/isads97/isads97.html.
[CiaR97]
P. Ciancarini, D. Rossi, “Jada - Coordination and Communication for Java Agents”, Lecture Notes in Computer Science, Springer-Verlag (D), No. 1222, 1997, pp. 213-226.
[Cug97]
G. Cugola, C. Ghezzi, G. Picco, G. Vigna, “Analyzing Mobile Code Languages”, Mobile Object Systems, Lecture Notes in Computer Science, No. 1222, Springer-Verlag (D), pp. 94-109, February 1997.
[DenNO98]E. Denti, A. Natali, A. Omicini, “On the Expressive Power of a Language for 12
Programmable Coordination Media”, Proceedings of 1998 ACM Symposium on Applied Computing, Atlanta (G), Feb. 1998. [DomLD97]P. Domel, A. Lingnau, O. Drobnik, “Mobile Agent Interaction in Heterogeneous Environment”, Proceedings of the International Workshop on Mobile Agents, Lecture Notes in Computer Science, Springer-Verlag (D), No. 1219, April 1997, pp. 136-148. [GelC92] D. Gelernter, N. Carriero, "Coordination Languages and Their Communications of the ACM, Vol. 35, No. 2, Feb. 1992, pp. 96-107.
Significance",
[Gen97]
General Magic Odissey Page, http://www.genmagic.com/agents/odyssey.html
[Gra96]
R. Gray, “Agent Tcl: A flexible and secure mobile-agent system”, in Mark Diekhans Mark Roseman editor, Proceedings of the fourth Annual Tcl/Tk Workshop (TCL ’96), Monterey, California, July 1996.
[MA97]
“Proceedings of the 1st International Workshop on Mobile Agents”, Berlin (D), Lecture Notes in Computer Science, No. 1219, Springer-Verlag (D), April 1997.
[MOS97] “Mobile Object Systems”, Lecture Notes in Computer Science, No. 1222, Springer Verlag (D), February 1997. [OMG94] Object Management Group, “Common Object Services Specification”, Volume 1, March 1994, http://www.omg.com. [OmiZ98] A. Omicini, F. Zambonelli, “TuCSoN: a Coordination Model for Mobile Agents”, submitted for publication, Feb. 1998. Available by the authors. [PeiS97]
H. Peine, T. Stolpmann, “The Architecture of the Ara Platform for Mobile Agents”, Proceedings of the 1st International Workshop on Mobile Agents”, Berlin (D), Lecture Notes in Computer Science, No. 1219, Springer-Verlag (D), pp. 50-61, April 1997.
[StaG90]
J. W. Stamos, D. K. Gifford, “Implementing Remote Evaluation”, IEEE Transactions on Software Engineering, Vol. 16, No. 7, pp. 710-722, July 1990.
[Sun97]
“The JavaSpace Specifications”, Sun Microsystems, http://chatsubo.javasoft.com.
[Ten97]
D. Tennenhouse et al., “A Survey of Active Network Research”, IEEE Communications, Vol. 35, No. 1, pp. 80-86, Jan. 1997.
[Van92]
T. Von Eicken, D. E. Culler, S.C. Goldstein, K. E. Schauser, “Active Messages: a Mechanism for Integrated Communication and Computation”, Proceedings of the 19th International Symposium on Computer Architecture, Gold Coast (AUS), ACM Press, pp. 256-266, May 1992.
[Wal97]
J. Waldo et al., “A Note on Distributed Computing”, Mobile Object Systems, Lecture Notes in Computer Science, No. 1222, Springer Verlag (D), pp. 49-64, February 1997.
[Weg97]
P. Wegner, “Why Interaction is More Powerful than Algorithms”, Communication of the ACM, Vol. 40, No. 5, pp. 80-91, May 1997.
13
