Danny B. Lange

Seven good reasons for mobile agents

Dispatch your agents; shut off your machine. Mobility is an orthogonal property of agents, that is, not all agents are mobile. An agent can just sit there and communicate with its environment through conventional means, such as remote procedure calling and messaging. We call agents that do not or cannot move stationary agents. A stationary agent executes only on the system on which it begins execution. If it needs information not on that system or needs to interact with an agent on another system, it typically uses a communication mechanism, such as remote procedure calling. In contrast, a mobile agent is not bound to the system on which it begins execution [1]. It is free to travel among the hosts in the network. Created in one execution environment, it can transport its state and code with it to another execution environment in the network, where it resumes execution. The term state typically means the attribute values of the agent that help it determine what to do when it resumes execution at its destination. Code in an object-oriented context means the class code necessary for an agent to execute. A mobile agent has the unique ability to transport itself from one system in a network to another in the same network. This ability allows it to move to a system containing an object with which it wants to interact and then to take advantage of being in the same host or network as the object. Our interest in mobile agents is not motivated by the technology per se but rather by the benefits agents provide for creating distributed systems. There are at least seven main benefits, or good reasons, to start using mobile agents: They reduce the network load. Distributed systems often rely on communication protocols involving multiple interactions to accomplish a given task. The result is a lot of network traffic. Mobile agents allow users to package a conversation and dispatch it to a destination host where interactions take place locally. Mobile agents are also useful when reducing the flow of raw data in the network. When very large volumes of data are stored at remote hosts, that data should be processed in its locality rather than transferred over the network. The motto for agent-based data processing is simple: Move the computation to the data rather than the data to the computation. They overcome network latency. …

A security model for Aglets

Mobile agents offer a new paradigm for distributed computation, but their potential benefits must be weighed against the very real security threats they pose. These threats originate not just in malicious agents but in malicious hosts as well. For example, if there is no mechanism to prevent attacks, a host can implant its own tasks into an agent or modify the agents state. This can lead in turn to theft of the agents resources if it has to pay for the execution of tasks, or to loss of the agents reputation if its state changes from one host to another in ways that alter its behavior in negative ways. Aglets are mobile agents developed at IBMs Tokyo Research Laboratory. The article describes a security model for the Aglets development environment that supports flexible architectural definition of security policies.

MASIF: The OMG Mobile Agent System Interoperability Facility

MASIF is a standard for mobile agent systems which has been adopted as an OMG technology. It is an early attempt to standardize an area of industry that, even though popular in the recent past, still has not caught on. In its short history MASIF has raised interest in industry and academia. There are already a number of projects pursuing MASIF reference implementation. MASIF addresses the interfaces between agent systems, not between agent applications and the agent system. Even though the former seem to be more relevant for application developers, it is the latter that impact interoperability between different agent systems. This paper describes two sets of interfaces that constitute MASIF: MAFAgentSystem and MAFFinder (the acronym MAF is used for historical reasons). MASIF extensively addresses security. The paper provides a brief description of MASIF and its interfaces, data types and data structures.

Mobile agents with Java: The Aglet API

Java, the language that changed the Web overnight, offers some unique capabilities that are fueling the development of mobile agent systems. In this article we will show what exactly it is that makes Java such a powerful tool for mobile agent development. We will also draw attention to some shortcomings in Java language systems that have implications for the conceptual design and use of Java-based mobile agent systems. Last, but not least, we will introduce the aglet – a Java-based agile agent. We will give an overview of the aglet and, its application programming interface, and present a real-world example of its use in electronic commerce.

MASIF: the OMG mobile agent system interoperability facility

MASIF is a standard for mobile agent systems which has been adopted as an OMG technology. It is an early attempt to standardize an area of industry that, even though popular in the recent past, still has not caught on. In its short history MASIF has raised interest in industry and academia. There are already a number of projects pursuing MASIF reference implementation. MASIF addresses the interfaces between agent systems, not between agent applications and the agent system. Even though the former seem to be more relevant for application developers, it is the latter that impact interoperability between different agent systems. This paper describes two sets of interfaces that constitute MASIF: MAFAgentSystem and MAFFinder (the acronym MAF is used for historical reasons). MASIF extensively addresses security. The paper provides a brief description of MASIF and its interfaces, data types and data structures.

Interactive visualization of design patterns can help in framework understanding

Framework programming is regarded as one the main advantages of object-oriented software engineering, and is expected to increase software reuse. In exploiting frameworks, however, programmers often face difficulties caused by the complexity of the hidden architecture and the multiplicity of the design decisions that are embedded in a framework. Interactive visualization of design patterns occurring in a framework shows how the framework is operating, in a flexible yet structured way that contributes to the programmers understanding of the underlying software architecture. In this way, programmers can explore and use frameworks efficiently even when they are distributed without vast amounts of documentation and source code.

Aglets: Programming Mobile Agents in Java

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.

Object-oriented program tracing and visualization

Conventional program analysis and presentation techniques are insufficient when dealing with object oriented concepts, but tool developers have nevertheless found a way to obtain and visualize OO traces. The approach presented combines static information with actual execution information to produce views that summarize the relevant computation. In developing this approach, the authors focused on reducing the search space for extracting dynamic program information and on creating visualizations that may improve a programmers understanding of object behaviour in real world OO systems. They applied the research prototype, Program Explorer, to a real project outside IBM. Although Program Explorer was originally designed for C++, a version for IBMs System Object Model (SOM) has demonstrated that the concepts are applicable to OO languages in general.

An object-oriented design approach for developing hypermedia information systems

Hypermedia system design is a difficult process, mainly because of the lack of high‐level hypermedia design models and support tools. The approach presented herein is intended to solve this problem. Its main elements are the Enhanced Object‐Relationship Model and two support tools for schema design and graphical user‐interface (GUI) design, all based on a common object‐oriented database system. The approach leads to schemas that will serve as design specifications; it can be used for documentation purposes; it paves the way for reuse of hypermedia designs; it allows integration with other object‐oriented systems and non‐object‐oriented systems; and it can lead to systems where the main interaction style is based on hypermedia linking. Finally, the approach offers a foundation for a unique combination of a high‐level hypermedia design methodology and reusable designs, which is expected to have a major impact on the future use of hypermedia in information systems.

Introduction to mobile agents

This article will lead you into the world of mobile agents, an emerging technology that makes it much easier to design, implement and maintain distributed systems. You will find that mobile agents reduce network traffic and provide an effective means of overcoming network latency. Perhaps most important, through their ability to operate asynchronously and independently of the process that created them, they help you to construct highly robust and fault-tolerant systems thereby directly or indirectly benefiting the end user.Read on and let us introduce you to software agents, including mobile as well as stationary agents. We will explain the benefits of mobile agents and demonstrate the impact they have on the design of distributed systems. This article then concludes with a brief overview of some contemporary mobile agent systems.