extending rational rose to support mas design in uml
Skip this Video
Download Presentation
Extending Rational Rose to support MAS design in UML

Loading in 2 Seconds...

play fullscreen
1 / 21

Extending Rational Rose to support MAS design in UML - PowerPoint PPT Presentation

  • Uploaded on

Extending Rational Rose to support MAS design in UML. presented by: Renato Levy. Intelligent Automation Inc. 2 Research Place, Suite 202 Rockville, MD 20850 http://www.i-a-i.com. Outline. Introduction to IAI and its software tools Three-tier agent architecture Cybele

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

PowerPoint Slideshow about 'Extending Rational Rose to support MAS design in UML' - damali

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
extending rational rose to support mas design in uml

Extending Rational Rose to support MAS design in UML

presented by: Renato Levy

Intelligent Automation Inc.

2 Research Place, Suite 202

Rockville, MD 20850


  • Introduction to IAI and its software tools
  • Three-tier agent architecture
  • Cybele
  • Design of MAS using DIVA
  • Problems and pitfalls
  • Multi-agent Systems Design, Development and Simulation
  • Distributed Computing
  • Scheduling and Logistics
  • Agent-based Distributed Control
software tools
Software tools
  • Cybele : Agent Infrastructure for distributed computing and inter-agent communication
  • DIVA : A case tool with design document editing, online repository, runtime execution support service, verification and Cybele code generation
three tier architecture of iai agents
Three Tier Architecture of IAI Agents

1- Role Layer: Describes the syntax and semantics of the roles this agent can perform in this application.

2- Adapter Objects: Makes the necessary translation between domain independent semantic of the role layer to the passive domain object expertise.

3- Domain Layer: Represents the information content of an agent. Holds the domain expertise of the agent. Layer were existent legacy software can be easily reused.

an example of role interaction
An Example of Role Interaction

Dutch Auction Art Buyer

English Auction Art Buyer

English Auction Car Buyer







Buying Art



cybele an agent infrastructure
Cybele : An Agent Infrastructure
  • Provides location independent communication among agents with efficient flexible, dynamic multicasting
  • Provides services for creating, migrating and terminating agents at run time
  • Supports multi-threaded and shared-threaded
  • Provides an activity model where an agent can work on multiple tasks concurrently
  • Emphasis is on high-performance, scalability, flexibility and ease of use
  • Current prototype of Cybele is implemented using the object-oriented paradigm with a Java API
cybele architecture guidelines
Cybele : Architecture Guidelines
  • Cybele basics: Enforcement of the Activity-oriented programming interfaces or AOPI.
  • Portability of users’ code: User-written agent code runs on any Cybele environment in which the needed services are available
  • Reusability of users’ code: User’s code are re-usable even if services are modified
  • Plug n play service: Encourage vendors to plug whatever service they desire into the Cybele to suite a particular platform
  • Provision for addition of new services: Provide means for agent developers to add and access supplemental services without affecting the reusability and portability
cybele architecture
Cybele : Architecture

Basic Service Layer

Fundamental Service


Cybele Kernel


Three-tier architecture


Distributed, Interactive Computing Infrastructure (DICI)


Service Layer

  • A design tool for agent based distributed system
  • Use an extension of UML as means for system description
  • Integrated with the industry leader Rational Rose 98i/2000e
  • Automatic code generation
  • Maximize interaction and protocol reusability
  • Automatically generate verification model from the same design document
diva and rose
Rational Rose
  • Rose Extensibility Interface (REI)
  • Model Semantics
  • Diagrams
  • Context Menus
  • Properties
  • Add-Ins


  • COM Client/Server
  • Respond to events
  • Custom Spec Dialog
  • Rose Script
  • Code generation
  • Custom dialogs
  • Shell
  • File I/O
  • Web access
  • Environment

Java-COM Bridge

  • Java Bean /COM Server
  • Logic of Add-In
  • Choice of languages
  • Events
  • Rosescript
  • COM server
  • Menus
  • Rosescript
  • External program
  • Add-In Registry
  • Events
  • Stereotype files
  • Property files
  • Menu files
  • Data files
  • Stereotypes
  • Icons
  • String
  • Extensible Properties
  • New tools/tabs
  • New properties
  • Source Files
  • Java Code
  • Promela Code

Java Objects

  • Legend
  • Control
  • Data
DIVA and Rose
multi agent system design entities
Multi-agent System Design: Entities
  • Physical entities of the System (MODEL)
  • Agents
  • Non-agent entities (such as databases, legacy classes)
  • Protocols
    • Roles
multi agent system design diagrams
Multi-agent System Design: Diagrams

Agents X MODEL -> Deployment Diagram

Agents X Hosts (distribution) -> Deployment Diagram

Agents X non-agent -> Class Diagrams

Agents X Protocols -> Class Diagram

Protocols X Roles -> Class Diagram

multi agent system design protocols
Multi-agent System Design: Protocols

Protocols are defined as the description of a relation between two or more agents of the system. Any interaction between two agents are subject to a protocol ruling. The agents that play a part on the protocol perform according with the roles described on this protocol.

A protocol is described by a class diagram which depicts its roles and by a set of interaction diagrams which show the details of the exchange of information between such roles.

In Rational Rose®, protocols were created using stereotypes.

multi agent system design agents x roles
Multi-agent System Design: Agents X Roles

In order to play a role on a protocol an agent has to adhere to an interface publicized by the role.

The interface required by the roles is automatically extracted by the DIVA case tool.

The agent implements the interface by means of delegation to non-agent object that conforms with the interface. (adapter objects)

multi agent system design role classes
Multi-agent System Design: Role Classes

Roles are entities contained by protocols, that define the syntax of a protocol player.

Agents can play different roles on different protocols or even more than one role on the same protocol instance

role design state diagram
Role Design: State Diagram

A Role is defined by an enhanced state machine diagram, in which the information about the guard conditions and actions are detailed enough to extract the conversation syntax.

role reusability
Role Reusability

The correct extraction of the syntax of a conversation from the semantics and context that they carry is fundamental to provide role reusability across domains.

diva interaction protocol verification
DIVA: Interaction Protocol Verification

State Diagrams Of Roles and

Sequence Diagrams of Interactions

RoseScript, Java Bean/COM Server

Role and Adaptor Objects in Java

PROMELA Translator

Concurrent Processes in PROMELA Script


Verified and Re-usable Roles and Protocols

importing protocols roles
Importing Protocols/Roles

DIVA’s repository allows validated protocols and roles to be shared and reused on several domains.

Rose and UML pitfalls
  • Rose is rather inconsistent on the way it can be extended by a third-party add-in. A variety of different techniques are needed to interface with Rose in order to accomplish the most simple tasks. (i.e. Rosescript, COM, ActiveX, Java beans, ….)
  • Despite all the methods to interface with Rose there was no way to enhance its graphical output, forcing us to recreate some of the graphics on a separate child window.
  • UML, as implemented in Rose, leaves too much room for free-form notes. In order to describe a complex system with less ambiguity, richer and more formal representation is needed.