RoleEP: Role Based Evolutionary Programming for Cooperative Mobile Agent Applications

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

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

3. Introduction

4. 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 ...

5. host traveling function intertwined! agent collaboration function 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.

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

7. Problems of constructingcooperative mobile agent applications ～　Traditional approaches　～

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

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

10. Viewpoints for estimation Viewpoints Separation of concerns 1) roaming around hosts (mobility) 2) contract-net protocol (collaboration) Evolution User proxy agent --- (evolve) ---> Manager agent

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

12. 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") }} Contract-net function Traveling function Code for roaming around hosts is mixed with code for executing the contract-net protocol. Traveling function

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

14. Case2: Design-pattern approach Approach Collaborations among agents are structured using design patterns focused on mobile agents. 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.

15. 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. }} Traveling function Itinerary Pattern Contract-net function Separated! (within an agent)

16. ViewpointsEstimation Separation of concerns 　　 △ Evolution × Estimation of case2 Merit Code for roaming around hosts is separated from code for executing the contract-net protocol. Problem 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

17. Case3: AOP approach (Aspect Oriented Programming) Approach 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.

18. Description of case3 -- Described in Aspect/J public class UserProxy{ public void roam(){ … }} Traveling function public class InfoSearcher{ public void executeTask(){ … }} static weaving 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{ ... } } } 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 Contract-net function Contract-net function

19. ViewpointsEstimation Separation of concerns 　　 △ Evolution 　 △ Estimation of case3 Merit Code for roaming around hosts is separated from code for executing the contract-net protocol completely. Problem 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. Estimation

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

21. RoleEP model and Java RoleEP Framework

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

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

24. 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-operation Binding-operations are implemented by creating delegational relations between roles and objects dynamically.

25. 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

26. 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

27. 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.

28. Description in Epsilon/J object object public class UserProxyextends EpsilonObj{ public void life(){ bind ... bind ... } } public class InfoSearcherextends EpsilonObj{ public void life() { bind … } } Dynamic evolution! Environment & role Environment & role public class Roamingextends Environment{ public class Visitorextends Role{ …} } public class ContractNetextends Environment{ public class Managerextends Role{ public void start(){} public void bid(){} public void end(){} } public class Contractorextends Role{ public void award(){} } }

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

30. 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.

31. Related works

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

33. Conclusion

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

35. Appendix

36. AOP vs RoleEP viewpoint AOP RoleEP aspects aspects environments and roles components components objects joint points join points roles (between aspects and components) weaving method weaver binding-operation aspect reuse emphasized emphasized dynamic aspect syntheses not so emphasized emphasized dynamic evolution not so emphasized emphasized dynamic method adding emphasized emphasized dynamic method modification emphasized ---