A survey of theories for mobile agents <s> Mobile computation (agent) environments <s> Obliq is a lexically-scoped, untyped, interpreted language that supports distributed object-oriented computation. Obliq objects have state and are local to a site. Obliq computations can roam over the network, while maintaining network connections. Distributed lexical scoping is the key mechanism for managing distributed computation. <s> BIB001 </s> A survey of theories for mobile agents <s> Mobile computation (agent) environments <s> We argue that objects that interact in a distributed system need to be dealt with in ways that are intrinsically different from objects that interact in a single address space. These differences are required because distributed systems require that the programmer be aware of latency, have a different model of memory access, and take into account issues of concurrency and partial failure. We look at a number of distributed systems that have attempted to paper over the distinction between local and remote objects, and show that such systems fail to support basic requirements of robustness and reliability. These failures have been masked in the past by the small size of the distributed systems that have been built. In the enterprise-wide distributed systems foreseen in the near future, however, such a masking will be impossible. We conclude by discussing what is required of both systems-level and application-level programmers and designers if one is to take distribution seriously. <s> BIB002 </s> A survey of theories for mobile agents <s> Mobile computation (agent) environments <s> Mobile agents are programs that can be dispatched from one computer and delivered to a remote computer for execution. Arriving at the remote computer, they present their credentials and obtain access to local services and data. They also provide a single uniform paradigm for distributed object computing, encompassing synchrony and asynchrony, message-passing and object-passing, and stationary objects and mobile objects. In this paper, we describe our Java-based mobile agents called Aglets and present its programming interface, called Java Aglet API. <s> BIB003
Making the computations mobile means that applications have to explicitly decide where in the net a computation should take place. Locality is made explicit in the hope that the network can be used more efficiently or because we realize that building a system that tries to completely hide the network (and thus locality) is impossible or inappropriate BIB002 . Applications should be able to react in their specific way to various (network) failures instead of delegating this task to some general purpose distributed, but transparent, execution platform. The term mobile agent captures best the view that computations can decide for themselves to move or to stay. There have been various systems proposed to implement mobile agents. The common element is the mobility of code between the nodes. Each node becomes an agent execution environment (i.e., virtual machine or interpreter for portability reasons) that understands a common set of agent instructions or a common programming language. But there are different ways of organizing code mobility and interprocess communication: Java  ] realizes code mobility by enabling Web browsers to download bytecodes, objects communicate via method invocation, synchronization between threads is obtained by the means of locks associated to each object; Aglets BIB003 are Java objects that can execute on one host and suddenly halt execution, dispatch to a remote host, and restart an execution there. When an aglet moves, it takes along its program code as well as state information; Obliq BIB001 objects can be copied to remote sites and references can be adjusted accordingly, they communicate via local or remote method calls; Messengers  ] are computations that can start new threads in remote hosts, they communicate via local shared memory only. To give the flavor of different formalizations of a mobile agent environment, we chose the Obliq and Messenger environments as test cases. Obliq can be characterized as a language approach for extending the object-oriented framework to a distributed environment. Obliq's communication style is determined by the requirement that objects should remain callable although they reside on different hosts. The messenger approach is based on another communication model and imposes all communications to be local and indirect. This divergence, among others, helps to work out the differences between the formalisms, and how they could be used to model the notions of mobility, communication and synchronization. Before looking at the formalisms, we briefly introduce the Obliq and the Messenger systems. A more thorough description of these and other mobile agent environments, as well as a comparison of them can be found in  .