RoleEP: Role Based Evolutionary Programming for Cooperative Mobile Agent Applications

1
RoleEP Role Based Evolutionary Programmingfor
Cooperative Mobile Agent Applications
ISPSE2000 (November 1-2, 2000)

• 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
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) ---gt 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
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,Ticke
t, 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
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()
public class InfoSearcher public void
executeTask()
Traveling function
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
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
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 ---gt 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 gt 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 UserProxy extends EpsilonObj
public void life() bind
... bind ...
public class InfoSearcher extends EpsilonObj
public void life() bind

Dynamic evolution!
Environment role
Environment role
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()
29
Estimation of RoleEP
30
Merits of RoleEP
1) Construction mechanisms for traveling/collabora
tion 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 en
vironments and roles components components obje
cts 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 ---