Modern sensor networks often consist of larger numbers of sensor nodes, making it possible for common targets to be measured by multiple sensor nodes rather than a single node. When multiple sensor nodes can measure common targets, simultaneous measurements across sensor nodes can reduce the impact of measurement errors. Alternatively, performing measurements at the same frequency while offsetting the measurement timings among sensor nodes can enhance temporal resolution. In this work, we propose a method for the selfconfigured coordination of the measurement timings, inspired by biological phenomena. This method achieves synchronization, where both the periods and phases of them are synchronized, or desynchronization, where the periods of them are synchronized but the phases of them are evenly offset. We evaluate our proposed method for synchronization and desynchronization of measurement timings among sensor nodes through a simulation with 100 sensor nodes.

Server-less architectures, specifically Function-as-a-Service (FaaS), are sometimes used for data processing in sensor networks. However, due to fluctuations in the start and completion times of FaaS tasks, the order can get reversed even when tasks are required to execute in sequence. As long as the start and end times of FaaS tasks are treated as delay fluctuated, it is not feasible to execute data processing as FaaS tasks. Therefore, this paper aims to clarify and formalize the conditions under which the execution order of periodic tasks by FaaS is maintained, assuming that fluctuations in the start and completion times of FaaS tasks can be predicted within a certain range. Furthermore, it presents a method to minimize the impact on data analysis when the completion of FaaS tasks is delayed beyond that predicted range. It is the first challenge that can provide the direction for future research on addressing the fluctuations.

This paper proposes coordination patterns that support matchmaking, communication and interaction among mobile agents in addition to stationary ones. Mobile agent technology is a powerful implementation technique of distributed systems, but we need to manage migrations of agents, including their current and destination locations. The proposed patterns enable us to define coordination between mobile agents or between mobile and stationary agents without explicitly knowing their migrations between locations. They are mostly based on the Knowledge Query and Manipulation Language, one of the most extended Agent Communication Languages, but also new patterns are proposed. Additionally, a case of study about tourism is presented.

We present a data processing framework for IoTs with clouds. It was inspired by the MapReduce processing but aims at data processing at the edges through low-band networks. It enables data at the edges to be locally processed as much as possible by using the MapReduce processing and to be cooperated with cloud computing if the edges lacks computational capabilities. This paper describes the design and implementation of the framework, basic performance, and an practical application.

This paper proposes a self-organizing framework for adapting software agents on complex computer systems, in particular distributed systems. It is unique to other existing approaches for software adaptation because it introduces the notions of differentiation and dedifferentiation in cellular slime molds into complex computer systems. When an agent delegates a function to another agent. the former's function becomes less-developed and the latter's compatible function becomes well-developed. The framework was constructed as a middleware system and allowed us to define agents as Java objects. We present several evaluations of the framework in a real distributed system.

We present a framework for emulating the physical mobility of computers, e.g., transport robots, by the logical mobility of software designed for running on computers through virtual machine technology. The framework is useful to test software designed for running on transfer robotics, which may be connected/disconnected to/from local area networks due to their movements. It enables software to run within target local networks so that the software can connect to the services or protocols available within the networks, e.g., plug-and-play services based on UDP multicasts.

This paper proposes a framework for configuring software agents on distributed system consisting of heterogenous computers. It is unique to other existing approaches for self-configuration because it introduces the notions of differentiation and dedifferentiation in cellular into real distributed systems. When an agent delegates a function to another agent coordinating with it, if the former has the function, this function becomes less-developed and the latter's function becomes well-developed. Agents can escape to other computers whose capabilities can satisfy their requirements. The framework was constructed as a middleware system and allowed us to define agents as Java objects written in Java Bean. We present several evaluations of the framework in a distributed system instead of any simulation-based systems and describes practical applications.

This paper presents a intelligent management framework for cooperative logistics, which enables multiple shippers to share a few trucks, for improving the efficiency of the trucks' operations. It is necessary to reduce fossil fuel consumption and carbon dioxide emissions resulting from transport on account of environmental protection. Cooperative logistics has been one of the most effective and popular solutions to this problem, but it makes it be complicated to implement in a logistics management system. We propose a language for specifying the routes of trucks and an order relation between the requirements of routes and the possible routes of trucks. The former is formulated as process calculus and the latter selects suitable trucks according to their routes. Our language and selection mechanism were implemented as a web service.

Pervasive Environments offer new opportunities for users to dynamically access resources and services based on information characterizing their situation (context), generally assuming that this information is correct and trustworthy. In this scenario, the Quality of Context information (QoC) plays an important role for improving context-based adaptation processes and for ensuring the correct behavior of context-aware applications and services. Some research attempts have been done for modeling and measuring the quality of raw context information sensed from the environment. However, so far no attention has been paid to the quality evaluation of derived and inferred context information. This paper describes an approach for modeling and measuring quality of raw, inferred, and derived context information based on the following points of view: privacy, security, precision, completeness, and resolution. We propose a context management framework that support QoC in their various layers, protecting and providing QoC-enriched context information of users to context-aware applications and services.

This paper presents an agent-based framework for building and operating context-aware media for digital signage in public spaces. The framework is managed in a non-centralized manner by using mobile agent technology and enables user assistant media agents to follow the movement of their users between stationary computers, e.g., public terminals, by using active RFID-tags. When users moves between locations in a public space, their agents provide annotations in personal forms according their current context. To demonstrate the utility and effectiveness of the system, we describe two applications of the frameworks.

We introduce a novel approach to handle location- dependent query processing in location-aware environments. We define a hybrid logic-based query language by building a semantic model that benefits from the well- founded model checking techniques. Our language is defined by four modal operators; it can express common location-dependent queries, and has the ability to deal with relative locations. A prototype implementation of the query engine is also presented and will be discussed.

This paper presents a middleware for multi-agents on a distributed system as a general test-bed for bio-inspired approaches. It is unique to other approaches, including distributed object systems, because it can maintain and migrate a dynamic federation of multiple agents on different computers. It enables each agent to explicitly define its own deployment policy as a relocation between itself and another agent. This paper describes a prototype implementation of the middleware and its practical applications to illustrate its utility and effectiveness in real distributed systems instead of using simulation-based evaluations

In this paper, we propose a personal home sewer that makes it possible to coordinate a variety of home appliances. Since each person has a different personal home server, it allows him/her to personalize how to use the appliances according to his preferences. Also, a personal home server can discover and configure appliances at any places, such as railroad stations, cars, and streets as well as houses in a seamless way. We show the design and implementation of a personal home server, and present its current status.

This paper presents a world model for location-aware and user-aware services in ubiquitous computing environments. It can be dynamically organized like a tree based on geographical containment, such as user-room-floor-building, and each node in the tree can be constructed as an executable software component. The model is unique to existing approaches because it can be managed by multiple computers in an ad-hoc manner and it can provide a unified view of the locations of not only physical entities and spaces, including users and objects, but also computing devices and services. A prototype implementation of this approach was constructed on a Java-based mobile agent system. This paper presents the rationale, design, implementation, and applications of the prototype system.

A general-purpose framework for building and managing location-aware applications in ubiquitous computing environments is described. The goal of the framework is to provide people, places, and things with computational functionalities to support and annotate them. Using RFID-based location-tracking systems, the framework can navigate Java-based mobile agents to stationary or mobile computers near the locations of the entities and places to which the agents are attached, even when the locations change. The framework enable a mobile user to directly access his/her personalized services from stationary computing devices in the environment or from his/her portable computing devices.

When a task is assigned to mobile agents, those suitable to perform the task need to be selected according to, not only their application-specific behaviors, but also their mobilities. The focus of current research, however, is on the development of execution platforms and applications for mobile agents and not on methodologies for selection of mobile agents. We present a general approach to selecting mobile agents according to their itineraries among multiple hosts. The approach offers a process algebra-based language for formally specifying the itineraries of mobile agents and an algebraic order relation between two itineraries specified as terms of the language. The relation can strictly decide whether or not the itineraries of mobile agents can satisfy the itinerary required by a given task, in the sense that the agents can migrate to all the hosts required by the task in the permissible order specified by the task. A prototype implementation of this approach was constructed on a Java-based mobile agent system. It enables each mobile agent to specify its itinerary as a term of the language and to migrate over a network according to only the itinerary. Also, when it receives a task request from its external environment, it can select a suitable mobile agent to perform the task by using the order relation. We also describe its implementation and a practical application.

This paper presents a general-purpose infrastructure for building and managing location-aware applications in ubiquitous computing settings. The goal of the infrastructure is to provide people, places, and objects with computational functionalities to support and annotate them. Using location-tracking systems, the infrastructure can navigate Java-based mobile agents to stationary or mobile computers near the entities and places to which the agents are attached, even when the locations change. The infrastructure enables application-specific functionalities to be implemented within mobile agents instead of the infrastructure itself. It maintains the locations of people and objects, including computing devices, and allows mobile users to directly access their personalized services from stationary computing devices in the environment or from their portable computing devices. This paper presents the rationale, design, implementation, and applications for our prototype infrastructure.

We propose a personal home server that makes it possible to coordinate various home appliances. Since each person has a different personal home server, it allows us to personalize how to use the appliances according to his preference. Also, our personal home server can discover and configure various appliances at any places, such as railroad stations, cars, and streets as well as houses in a seamless way. We show the design and implementation of a personal home server, and discuss the current design and future work.

A framework for the dynamic aggregation of ubiquitous computers is presented. The framework aggregates applications from more than one mobile component that can migrate from computer to computer during the execution of applications. Using location-tracking systems, the framework can spatially bind partitioned applications to users and other things and dynamically allocate and migrate a federation of partitioned applications on multiple computers according to the capabilities and locations of the computers and the positions of users. The framework also provides inter-component communications and component relocation semantics so that an application made up components can adapt its structure and functionality to changes in resource availability and the physical environment. A prototype implementation of the framework built on a Java-based mobile agent system and its applications are described.

Adopting mobile agent technology can eliminate the need for the administrator to manage clusters, e.g., installation and upgrading software, and auditing clusters and networks. However, creating mobile agent-based network management systems is still in an ad-hoc manner but not methodologies for building mobile agents for cluster and grid computing. This paper presents a framework for reusable mobile agents for managing clusters in the sense that they are independent of either particular cluster systems or applications. The framework enables a mobile agent to be composed of two layered components, which are mobile agents. The first is a carrier for the second over particular networks independent of any management tasks and the latter defines management tasks performed at each host, independently of any networks. The framework also offers a mechanism for matchmaking the two components. Since the mechanism has been formulated based on a process algebra approach, it can precisely select a suitable itinerary component to do management tasks at the hosts that the tasks want to visit over networks. The framework provides a methodology for easily developing and operating mobile agents to travel among multiple clusters to conduct their management tasks at each of the clusters they visit.

We describe a framework that is used to build and test software for ubiquitous and mobile computing. The approach involves software-level emulators for computing devices. Since each emulator is implemented as a mobile agent, it can dynamically carry its target software to each of the sub-networks that its device is connected to, on behalf of the device, and it permits the software to interact with other servers in its current sub-network. The framework can simulate the mobility and reconnection of mobile or ubiquitous computing devices by using the logical mobility of mobile agent-based emulators. That is, it can test software designed to run on a mobile or ubiquitous device in the same way as if the software were disconnected from the network, moved with the device, and reconnected to and executed on another network. This paper describes the lessons we earned from exploiting the framework in developing typical application software for mobile and ubiquitous computing devices.

We present a framework for testing applications for mobile computing devices. When a device is moved into and attached to a new network, the proper functioning of applications running on the device often depends on the resources and services provided locally in the current network. This framework provides an application-level emulator for mobile computing devices to solve this problem. Since the emulator is constructed as a mobile agent, it can carry applications across networks on behalf of its target device and allow the applications to connect to local servers in its current network in the same way as if they had been moved with and executed on the device itself. This paper also demonstrates the utility of this framework by describing the development of typical network-dependent applications in mobile and ubiquitous computing settings.

Mobile agents can migrate among nodes to perform a set of management tasks at each of the visited nodes. Existing mobile agent-based network management systems often assume that their mobile agents are designed to work in particular networks to raise the efficiency of agent migration among multiple nodes. Unfortunately, such mobile agents cannot be reused in different networks. This paper proposes a framework where a mobile agent for network management is composed of two kinds of software components, an itinerary part and a behavioral logic part. Both components are implemented as mobile agents. The former is a carrier designed for particular networks, and it can efficiently navigate other mobile agents among nodes in its target network. The latter defines management tasks performed at each node independently of any local network. This framework allows a mobile agent for network management to be reused in various networks without being modified. A prototype implementation of this framework and its application were built on a Java-based mobile agent system.

Abstract This paper presents a framework for the building of context‐aware applications in ubiquitous and mobile computing settings. The framework provides people, places, and things with computational functionalities to support and annotate them. It is unique among existing systems because the functionalities are implemented by mobile agents. Using location‐tracking systems, this framework can navigate mobile agents to stationary or mobile computers near the locations of the entities and places to which the agents are attached, even when the locations change. The framework provides a way for mobile agents to follow their users as they move about and to adhere to places as virtual Post‐its. A prototype implementation of the framework has been built on a Java‐based mobile agent system and tested with several practical applications, including follow‐me applications and a user navigational assistance system. Copyright © 2003 John Wiley & Sons, Ltd.

Mobile agents can migrate among nodes to perform a set of management tasks at each of the visited nodes. Existing mobile agent-based network management systems often assume that their mobile agents are designed to work in particular networks to raise the efficiency of agent migration among multiple nodes. Unfortunately, such mobile agents cannot be reused in different networks. This paper proposes a framework where a mobile agent for network management is composed of two kinds of software components, a itinerary part and a behavioral logic part. Both components are implemented as mobile agents. The former is a carrier designed for particular networks, and it can efficiently navigate other mobile agents among nodes in its target network. The latter defines management tasks performed at each node independently of any local network. This framework allows a mobile agent for network management to be reused in various networks without being modified. A prototype implementation of this framework and its application were built on a Java-based mobile agent system.

This paper presents a mobile agent-based framework for building mobile compound document, which can each be dynamically composed of mobile agents and can migrate itself over a network as a whole, with all its embedded agents. The key of this framework is that it builds a hierarchical mobile agent system that enables multiple mobile agents to be combined into a single mobile agent. The framework also provides several value-added mechanisms for visually manipulating components embedded in a compound document and for sharing a window on the screen among the components. This paper describes this framework and some experiences in the implementation of a prototype system, currently using Java the both implementation language and component development language, and then illustrates several interesting applications to demonstrate the framework's utility and flexibility.

A framework for building adaptive network protocols for agent migration over a network is presented. A key idea of the framework is to introduce mobile agents as first-class objects. That is, the framework allows network protocols for agent migration to be naturally implemented within mobile agents and then dynamically deployed at network nodes by migrating the agents that carry the protocols. A prototype implementation was built on a hierarchical mobile agent system, and several practical protocols for agent migration were designed and implemented. These protocols can have significant contributions to active network technology as well as mobile agent technology.

This paper presents a new framework for constructing mobile agents. The framework introduces the notion of agent hierarchy and inter-agent migration and thus allows a group of mobile agents to be dynamically assembled into a single mobile agent. It provides a powerful method to construct a distributed application, in particular a large-scale mobile application. To demonstrate how to exploit our framework, we construct an extensible and portable mobile agent system based on the framework. The system is implemented as a collection of mobile agents and thus can dynamically change and evolve its functions by migrating agents that offer the functions. Also, mobile agent-based applications running on the system can naturally inherit the extensibility and adaptability of the system.

We investigate a formal model for reasoning about real-time object-oriented computations.The model is an extension of CCS with the notion of time, called RtCCS(Real-time Calculus of Communication Systems).It can naturally model real-time concurrent objects as communicating processes and represent the timed properties of objects.We define two timed equivalences based on CCS's bisimulation and derive algebraic laws for reasoning about real-time processes.The equivalences provide a formal framework for analyzing the behavior and timing of real-time computations.Also, we define a sound and complete equational proof system for finite processes.Some examples in RtCCS are shown in order to demonstrate its usefulness.