RoleEP: Role Based Evolutionary Programming for Cooperative Mobile Agent Applications Naoyasu UBAYASHI （ Toshiba Corporation) Tetsuo TAMAI （ University of Tokyo ） ISPSE2000 (November 1-2, 2000)

Agenda 1. Introduction 2. Problems of constructing cooperative mobile agent applications 3. RoleEP model and Java RoleEP Framework 4. Related works 5. Conclusion

Introduction

Background Recently, cooperative distributed applications based on mobile agent systems are increasing. Using mobile agents, we can develop cooperative distributed applications that run over the Internet more easily and more flexibly than before. But, there are problems...

Problems It is difficult to understand collaborations among agents and travels of individual agents as a whole because traveling/collaboration functions come to be intertwined in the code. It is difficult to define behaviors of agents explicitly because they are influenced by the external context. Agents may change their functions dynamically. host agent traveling function collaboration function intertwined!

Goal of this research This research proposes the concept of RoleEP (Role Based Evolutionary Programming) in order to alleviate the problems mentioned here. 1) RoleEP separates concerns on mobility/collaboration from agent systems. 2) RoleEP provides a systematic evolutionary programming style. Targets

Problems of constructing cooperative mobile agent applications ～ Traditional approaches ～

Traditional approaches 1. Orthodox approach 2. Design-pattern approach 3. AOP approach

Example A distributed information retrieval system (a typical example of cooperative distributed applications based on mobile agent systems)

Viewpoints for estimation Viewpoints Separation of concerns1) roaming around hosts (mobility) 2) contract-net protocol (collaboration) EvolutionUser proxy agent --- (evolve) ---> Manager agent

Case1: Orthodox approach A program description maps domain structures to program structures. Approach

Description of case1 -- Described in Java public class UserProxy { public void roam(){ : dispatch(getNextHostAddress(), "contractNet_start"); } public void contractNet_start(){ : // broadcasts a task-announcement message // to all agents existing in the host. } public void contractNet_bid(){ : // if all biddings are finished, // selects the best contractor. : best-contractor.award(); } public void contractNet_end(){ : dispatch(getNextHostAddress(), "contractNet_start") }} Code for roaming around hosts is mixed with code for executing the contract-net protocol. Traveling function Traveling function Contract-net function

Estimation of case1 ViewpointsEstimation Separation of concerns × Evolution × It is difficult to understand a program behavior as a whole since traveling/collaboration functions that compose a program are not described separately. Merit Problem none Estimation

Case2: Design-pattern approach Design patterns for Aglets (Aridor, Y. and Lange, D.B.) 1) Traveling Patterns: Itinerary,Forwarding,Ticket, etc. 2) Task Patterns: Master-Slave, Plan, etc. 3) Collaboration Patterns: Meeting, Locker, Messenger, Facilitator, Organized Group, etc. Collaborations among agents are structured using design patterns focused on mobile agents. Approach

Description of case2 -- Described in Aglets public class UserProxy extends Aglets{ public void roam(){ // sets sequential planning itinerary itinerary = new SeqPlanItinerary(this); itinerary.addPlan(HostAddress1, "contractNet_start"); : itinerary.addPlan(HostAddressN, "contractNet_start"); // starts the trip itinerary.startTrip(); } public void contractNet_start(){ // broadcasts a task-announcement message // to all agents existing in the host. : // waits until contract-net process is finished } public void contractNet_bid(){ // if all biddings are finished, // selects the best contractor. : best-contractor.award(); } public void contractNet_end(){ // saves results of the task execution. : // notifies this agent. }} Itinerary Pattern Separated! ( within an agent ) Contract-net function Traveling function

Estimation of case2 Problem Merit Code for roaming around hosts is separated from code for executing the contract-net protocol. Separations of traveling/collaboration descriptions are limited only within an agent. As shown in the program, if a roaming agent wants to behave as a manager at the host machine the agent moves into, functions requested for a manager should be described as methods of the agent ! Estimation ViewpointsEstimation Separation of concerns △ Evolution ×

Case3: AOP approach (Aspect Oriented Programming) AOP is a programming paradigm such that a system is divided into a number of aspects and a program is described per aspect. A function that is dispersed among a group of objects is defined as an aspect. A compiler, called weaver, weaves aspects and objects together into a system. Kendall, E.A. proposed role model designs and implementations with AspectJ that is an aspect-oriented extension to Java. Approach

Description of case3 -- Described in Aspect/J public class UserProxy{ public void roam(){ … }} aspect Manager extends Role{ // introduces empty behavior // to the class UserProxy introduce public void UserProxy.start(){} introduce public void UserProxy.bid(){} introduce public void UserProxy.end(){} // advise weaves for aspect instances // that will be attached to an instance // of the class UserProxy advise public void UserProxy.start(){ before{... } } advise public void UserProxy.bid(){ before{... } } advise public void UserProxy.end(){ before{... } } } public class InfoSearcher{ public void executeTask(){ … }} aspect Contractor extends Role{ // introduces empty behavior // to the class InfoSearcher introduce public void InfoSearcher.taskAnnounce(){} introduce public void InfoSearcher.award(){} // advise weaves for aspect instances // that will be attached to an instance // of the class InfoSearcher advise public void InfoSearcher.taskAnnounce(){ before{... } } advise public void InfoSearcher.award(){ before{ // calls a method of the class InfoSearcher executeTask();} } } weaver program static weaving Traveling function Contract-net function Contract-net function

Estimation of case3 Each aspect must be defined per a role. A description that cross-cuts roles may be dispersed in several aspects. Dynamic evolution is not emphasized. Problem Merit Code for roaming around hosts is separated from code for executing the contract-net protocol completely. Estimation ViewpointsEstimation Separation of concerns △ Evolution △

Estimation of traditional approaches (summary) ApproachesViewpoints (Separation of concerns)(Evolution) Orthodox approach × × Design-pattern approach △ × AOP approach △ △

RoleEP model and Java RoleEP Framework

RoleEP Model RoleEP is composed of four model constructs -- agents, roles, objects and environments Traveling/Collaboration function Traveling/Collaboration function Original Function separated Evolution (object ---> agent) Evolution (object ---> agent)

Model constructs (1) Traveling/collaboration functions including tours around hosts and message communications among agents are described by role attributes and role methods. Environment A field where a group of mobile agents collaborate with each other. Role A function that an agent assumes in a field.

Model constructs (2) Object, Agent An object(instance) becomes an agent by binding itself to a role(instance) that is defined in an environment, and acquires functions needed for collaborating with other agents that exist in the same environment. Binding-operations are implemented by creating delegational relations between roles and objects dynamically. Binding-operation

Model constructs (Summary) environment ::= [environment attributes, environment methods, roles] role ::= [role attributes, role methods, binding-interfaces] object ::= [attributes, methods] agent ::= [roles, object] agent.binding-interface => object.method

Construction of Cooperative Mobile Agent Applications in RoleEP Cooperative distributed applications based on mobile agent systems, which may change their functions dynamically in order to adapt themselves to their external context, can be constructed by synthesizing multiple environments dynamically. Evolutionary construction

Epsilon/J -- Java RoleEP Framework Epsilon/J is a framework that supports RoleEP concepts including environment and roles. This framework, which is presented as class libraries, is implemented on Aglets that is a mobile agent system based on Java.

Description in Epsilon/J public class Roaming extends Environment{ public class Visitor extends Role{ …} } public class ContractNet extends Environment{ public class Manager extends Role{ public void start(){} public void bid(){} public void end(){} } public class Contractor extends Role{ public void award(){} } public class UserProxy extends EpsilonObj{ public void life(){ bind... bind... } public class InfoSearcher extends EpsilonObj{ public void life() { bind … } object Environment & role Dynamic evolution!

Estimation of RoleEP ApproachesViewpoints (Separation of concerns)(Evolution) RoleEP ○ ○ Orthodox approach × × Design-pattern approach △ × AOP approach △ △

Merits of RoleEP 1) Construction mechanisms for traveling/collaboration components Environment classes can be regarded as traveling/collaboration components. 2) Evolution mechanisms for agents: An object can dynamically evolve to an agent that can behave multiple roles. Using RoleEP, programs that adapt to external context can be described easily. 3) Agentification mechanisms: In RoleEP, a role corresponds to a transducer that accepts messages from other agents and translates them into messages that an object can understand. RoleEP can be regarded as one of dynamic agentification mechanisms.

Related works

Mobile Ambients (Cardelli, L. and Gordon, A.D.) Aspect Oriented Programming (Kiczales, G., et al.) Subject Oriented Programming (Harrison, W. and Ossher, H.) Role model (VanHilst, M. and Notkin, D.) Separation of Concerns Mobile agents This model gives a layered agent structure. In this model, agents run on fields constructed by synthesizing contexts (environments) dynamically.

Conclusion

Summary RoleEP separates concerns on mobility from agent systems. RoleEP provides a systematic evolutionary programming style. We proposed RoleEP, a new approach that constructs cooperative mobile agent applications.

Appendix

AOP vs RoleEP viewpoint AOPRoleEP aspectsaspectsenvironments and roles componentscomponentsobjects joint points join pointsroles (between aspects and components) weaving methodweaverbinding-operation aspect reuseemphasizedemphasized dynamic aspect synthesesnot so emphasizedemphasized dynamic evolutionnot so emphasizedemphasized dynamic method addingemphasizedemphasized dynamic method modificationemphasized---