T2. Organization and Environment oriented programming

780 views

Published on

14th European Agent Systems Summer School

Published in: Education, Technology
0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total views
780
On SlideShare
0
From Embeds
0
Number of Embeds
1
Actions
Shares
0
Downloads
20
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide

T2. Organization and Environment oriented programming

  1. 1. Organisation and Environment Oriented Programming Outline of the course Introduction Olivier Boissier1 , Rafael H. Bordini2 , EOP Jomi F. H¨bner3 , Alessandro Ricci4 u About Environment Oriented Programming 1 EMSE, 2 PUC-RS, A&A and CArtAgO France Brazil Olivier.Boissier@emse.fr R.Bordini@pucrs.br OOP 3 DAS-UFSC, Brazil 4 University of Bologna, Italy About Organisation Oriented Programming jomi@das.ufsc.br a.ricci@unibo.it Moise Conclusions European Agent Systems Summer School Practical Exercise: a hands-on lab session! May, 2012 — Valencia, Spain Introduction EOP OOP Conclusion Abstractions in Multi-Agent Systems schema mission role ORGAMISATION org LEVEL Introduction agent AGENT LEVEL artifact ENDOGENOUS ENVIRONMENT wsp LEVEL EXOGENOUS ENVIRONMENT 4 / 165 network node Introduction EOP OOP Conclusion Introduction EOP OOP ConclusionAbstractions in Multi-Agent Systems Agent Oriented Programming Individual Agent Level: autonomy, situatedness Cognitive Concepts: beliefs, desires, goals, intentions, plans Proposed by Shoham [Shoham, 1993] Reasoning Cycle: sense/reason/act, reactive/pro-active Use of mentalistic notions and a societal view of behaviour computation (anthropomorphism) Environment Level: resources and services that agents can Levels of abstraction: Agents – Organisations – Environment access and control; sensing and acting in an environment Programming languages for agents have developed a lot Social and Organisation Level: cooperation, coordination, since then, but still not a mature paradigm regulation patterns Programming languages/platforms for organisation and Roles: rights, responsibilities, ... environment are also being developed Organisational Rules: constraints on roles and their interactions, norms, deadlines, ... Some agent development platforms have a formal basis Organisational Structures: topology of interaction patterns Many influenced by the BDI agent architecture and relations over activity control 5 / 165 6 / 165
  2. 2. Introduction EOP OOP Conclusion Introduction EOP OOP ConclusionBDI Architecture Programming Languages for Cognitive Agents Programming Languages for Multi-Agent Systems E.g., Jason, Jadex, JACK, 2APL, GOAL, Brahms, JIAC, Agent Intentional Stance (Dennett) Factory, MetateM, Golog variants, ... Practical Reasoning (Bratman) IRMA (Bratman, Isreal, Pollack) Architecture to represent an agent mental state: PRS (George↵, Lansky) Beliefs: information available to agent (e.g., about the dMARS (Kinny) environment or other agents) Goals: states of a↵airs that the agent wants to achieve BDI Logics and Agent Architecture (Rao, George↵) Events: changes in agents beliefs or goals Wooldridge, Singh, ... Capabilities: reusable modules of activities that the agent can perform Plans: reasoning about courses of action to achieve goals Rules: reasoning about beliefs 7 / 165 8 / 165 Introduction EOP OOP Conclusion Introduction EOP OOP ConclusionProgramming Languages for Cognitive Agents Programming Languages/Platforms for Organisations Concepts used to specify the state of an organisation: Some steps of a Reasoning Cycle: Agents, Roles, Groups Determining Relevant Plans for Handling Events Norms, Obligations, Prohibitions, Permissions, Violations Select a Plan for Execution Dependency, Power, Delegation, Information flow relations Execute Part of an Intended Plans Deadlines, Sanctions, Rewards Handle Plan Failures Management Infrastructure to control and coordinate agent behaviour at run-time: Agent Interpreter is an infinite loop of such reasoning cycles. Endogenous: The control is a part of the agent program The architecture and reasoning cycle together with the agent Exogenous: The control is performed by an external system program (specially plans) determine the behaviour of the agent. Monitoring Agent Behaviour Enforcing Organisational Rules Regimenting Organisational Rules 9 / 165 10 / 165 Introduction EOP OOP Conclusion Introduction EOP OOP ConclusionProgramming Languages/Platforms for Environments Hands-on Part of this Course We will use JaCaMo Artifacts to represent the state of the environment First fully operational, unified platform covering the 3 main Access to Databases/Services/etc., Coordination, Interaction levels of abstractions for multi-agent oriented programming Environment “objects”, i.e., non-proactive entities JaCaMo = Jason + CArtAgO + Moise Processing Operations on Artifacts http://jacamo.sourceforge.net Realising the e↵ects of environments actions http://jason.sourceforge.net Providing events related to sensing the environment http://cartago.sourceforge.net Synchronising agent actions http://moise.sourceforge.net At the right level of abstraction for a multi-agent system More than the sum of 3 successful platforms Revealing the full potential of Multi-Agent Oriented Programming 11 / 165 12 / 165
  3. 3. Outline Environment Oriented 2 Environment Programming Why Environment Programming in MAS Programming Basic Level Advanced Level — EOP — A&A and CArtAgO Conclusions and Wrap-up Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-upBack to the Notion of Environment in MAS Single Agent Perspective sensors The notion of environment is intrinsically related to the db ack pe fee PERCEPTION rce notion of agent and multi-agent system pts ENVIRONMENT “An agent is a computer system that is situated in some DECISION acti do environment and that is capable of autonomous action in ons tion to ac ACTION this environment in order to meet its design objective” [Wooldridge, 2002] effectors / actuators “An agent is anything that can be viewed as perceiving its environment through sensors and acting upon the environment through e↵ectors. Perception ” [Russell and Norvig, 2003] process inside agent inside of attaining awareness or Including both physical and software environments understanding sensory information, creating percepts perceived form of external stimuli or their absence Actions the means to a↵ect, change or inspect the environment 15 / 165 16 / 165 Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-upMulti-Agent Perspective Why Environment Programming Basic level to create testbeds for real/external environments to ease the interface/interaction with existing software environments Advanced level to uniformly encapsulate and modularise functionalities of the MAS out of the agents typically related to interaction, coordination, organisation, security externalisation this implies changing the perspective on the environment environment as a first-class abstraction of the MAS In evidence endogenous environments (vs. exogenous ones) programmable environments overlapping spheres of visibility and influence ..which means: interaction 17 / 165 18 / 165
  4. 4. Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-upEnvironment Programming: General Issues Basic Level Overview MAS MAS ENVIRONMENT actions Defining the interface SIMULATED REAL WORLD mimicking actions, perceptions WORLD (PHYSICAL OR COMPUTATIONAL) data-model OR Defining the environment computational model & architecture how the environment works INTERFACE EXTERNAL WORLD structure, behaviour, topology (PHYSICAL OR core aspects to face: concurrency, distribution COMPUTATIONAL) OR Defining the environment programming model how to program the environment WRAPPER TO EXISTING Example: percepts JAVA TECHNOLOGY AGENTS PLATFORM 19 / 165 20 / 165 Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-upBasic Level: Features An Example: Jason [Bordini et al., 2007] Flexible Java-based Environment API Environment conceptually conceived as a single monolitic Environment base class to be specialised block executeAction method to specify action semantics addPercept to generate percepts providing actions, generating percepts Environment API Environment User Agent -globalPercepts: List<Literal> Environment Architecture to define the set of actions and program actions -agPercepts: Map<String,List<Literal>> +init(String[] args) computational behaviour +stop() getPercepts which include the generation of percepts +getPercepts(String agName): List<Literal> +executeAction(String agName, Structure action): boolean typically implemented using as single object/class in OO such +addPercept(String agName, Literal p) as Java +removePercept(String agName, Literal p) ... method to execute actions executeAction fields to store the environment state UserEnvironment available in many agent programming languages/frameworks +init(String[] args) change +executeAction(String agName, Structure action): boolean e.g., Jason, 2APL, GOAL, JADEX percepts 21 / 165 22 / 165 Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-upMARS Environment in Jason Jason Agents Playing on Mars // mars robot 1 public class MarsEnv extends Environment { ... private MarsModel model; ... private MarsView view; /* creates the agents perception /* Initial beliefs */ * based on the MarsModel */ +!take(S,L) : true public void init(String[] args) { void updatePercepts() { at(P) :- pos(P,X,Y) & pos(r1,X,Y). <- !ensure_pick(S); model = new MarsModel(); !at(L); view = new MarsView(model); clearPercepts(); /* Initial goal */ drop(S). model.setView(view); updatePercepts(); Location r1Loc = model.getAgPos(0); !check(slots). +!ensure_pick(S) : garbage(r1) } Location r2Loc = model.getAgPos(1); <- pick(garb); /* Plans */ !ensure_pick(S). public boolean executeAction(String ag, Structure action) { Literal pos1 = Literal.parseLiteral +!ensure_pick(_). String func = action.getFunctor(); ("pos(r1," + r1Loc.x + "," + r1Loc.y + ")"); +!check(slots) : not garbage(r1) if (func.equals("next")) { Literal pos2 = Literal.parseLiteral <- next(slot); +!at(L) : at(L). model.nextSlot(); ("pos(r2," + r2Loc.x + "," + r2Loc.y + ")"); !!check(slots). +!at(L) <- ?pos(L,X,Y); } else if (func.equals("move_towards")) { int x = (int)((NumberTerm)action.getTerm(0)).solve(); addPercept(pos1); +!check(slots). move_towards(X,Y); int y = (int)((NumberTerm)action.getTerm(1)).solve(); addPercept(pos2); !at(L). model.moveTowards(x,y); +garbage(r1) : not .desire(carry_to(r2)) } else if (func.equals("pick")) { if (model.hasGarbage(r1Loc)) { <- !carry_to(r2). model.pickGarb(); addPercept(Literal.parseLiteral("garbage(r1)")); } else if (func.equals("drop")) { } +!carry_to(R) model.dropGarb(); <- // remember where to go back } else if (func.equals("burn")) { if (model.hasGarbage(r2Loc)) { ?pos(r1,X,Y); model.burnGarb(); addPercept(Literal.parseLiteral("garbage(r2)")); -+pos(last,X,Y); } else { } return false; } // carry garbage to r2 } !take(garb,R); class MarsModel extends GridWorldModel { ... } updatePercepts(); // goes back and continue to check return true; class MarsView extends GridWorldView { ... } !at(last); } } ... !!check(slots). ... 23 / 165 24 / 165
  5. 5. Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-upAnother Example: 2APL [Dastani, 2008] Example: Block-world Environment in 2APL package blockworld; 2APL public class Env extends apapl.Environment { BDI-based agent-oriented programming language integrating declarative programming constructs (beliefs, goals) and public void enter(String agent, Term x, Term y, Term c){...} imperative style programming constructs (events, plans) Java-based Environment API public Term sensePosition(String agent){...} Environment base class public Term pickup(String agent){...} implementing actions as methods public void north(String agent){...} inside action methods external events can be generated to be perceived by agents as percepts ... } 25 / 165 26 / 165 Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up2APL Agents in the block-world Environment Interface Stardard – EIS Initiative Recent initiative supported by main APL research BeliefUpdates: ... { bomb(X,Y) } RemoveBomb(X,Y){ not bomb(X,Y) } groups [Behrens et al., 2010] { true } AddBomb(X,Y) { bomb(X,Y) } PC-rules: { carry(bomb) } { not carry(bomb) } Drop( ) PickUp( ) { { not carry(bomb)} carry(bomb) } goto( X, Y ) <- true | { GOAL, 2APL, GOAL, JADEX, JASON @blockworld( sensePosition(), POS ); Beliefs: B(POS = [A,B]); Goal of the initiative start(0,1). if B(A > X) then bomb(3,3). clean( blockWorld ) :- { @blockworld( west(), L ); goto( X, Y ) design and develop a generic environment interface standard not bomb(X,Y) , not carry(bomb). } else if B(A < X) then a standard to connect agents to environments Plans: B(start(X,Y)) ; { @blockworld( east(), L ); goto( X, Y ) ... environments such as agent testbeds, commercial @blockworld( enter( X, Y, blue ), L ) } applications, video games.. else if B(B > Y) then Goals: { @blockworld( north(), L ); clean( blockWorld ) goto( X, Y ) Principles } PG-rules: clean( blockWorld ) <- bomb( X, Y ) | else if B(B < Y) then { @blockworld( south(), L ); wrapping already existing environments { goto( X, Y ); } goto( X, Y ) creating new environments by connecting already existing @blockworld( pickup( ), L1 ); PickUp( ); } apps RemoveBomb( X, Y ); goto( 0, 0 ); ... creating new environments from scratch @blockworld( drop( ), L2 ); } Drop( ) Requirements ... generic reuse 27 / 165 28 / 165 Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-upEIS Meta-Model Environment Interface Features Interface functions attaching, detaching, and notifying observers (software design pattern); registering and unregistering agents; adding and removing entities; managing the agents-entities-relation; performing actions and retrieving percepts; managing the environment By means of the Env. Interface agents perform actions and Interface Intermediate language collect percepts to facilitate data-exchange actually actions/percepts are issued to controllable entities in encoding percepts, actions, events environment model represent the agent bodies, with e↵ectors and sensors 29 / 165 30 / 165
  6. 6. Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-upAdvanced Level Overview Three Support Levels [Weyns et al., 2007] Vision: environment as a first-class abstraction in MAS [Weyns et al., 2007, Ricci et al., 2010b] application or endogenous environments, i.e. that environment which is an explicit part of the MAS Basic interface support providing an exploitable design & programming abstraction Abstraction support level to build MAS applications Interaction-mediation support level Outcome distinguishing clearly between the responsibilities of agent and environment separation of concerns improving the engineering practice 31 / 165 32 / 165 Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-upBasic Interface Support Abstraction Support Bridges the conceptual gap between the agent abstraction The environment enables agents to access the deployment and low-level details of the deployment context context shields low-level details of the deployment context i.e. the hardware and software and external resources with which the MAS interacts 33 / 165 34 / 165 Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-upInteraction-Mediation Support Environment Definition Revised Regulate the access to shared resources Mediate interaction between agents Environment definition revised [Weyns et al., 2007] The environment is a first-class abstraction that provides the surrounding conditions for agents to exist and that mediates both the interaction among agents and the access to resources 35 / 165 36 / 165
  7. 7. Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-upResearch on Environments for MAS Environment Programming Environment as first-class programming Environments for Multi-Agent Systems research field / abstraction [Ricci et al., 2010b] E4MAS workshop series [Weyns et al., 2005] software designers and engineers perspective di↵erent themes and issues (see JAAMAS Special endogenous environments (vs. exogenous one) Issue [Weyns and Parunak, 2007] for a good survey) programming MAS = mechanisms, architectures, infrastructures, programming Agents + programming Environment applications [Platon et al., 2007, Weyns and Holvoet, 2007, Weyns and Holvoet, 2004, Viroli et al., 2007] ..but this will be extended to include OOP in next part the main perspective is (agent-oriented) software engineering Environment as first-class runtime abstraction for agents Focus of this tutorial: the role of the environment agent perspective abstraction in MAS programming to be observed, used, adapted, constructed, ... environment programming Defining computational and programming frameworks/models also for the environment part 37 / 165 38 / 165 Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-upComputational Frameworks for Environment Programming Models for the Environment: DesiderataProgramming: Issues Abstraction keeping the agent abstraction level e.g. no agents sharing and Defining the environment interface calling OO objects actions, percepts, data model e↵ective programming models for controllable and observable contract concept, as defined in software engineering contexts computational entities (Design by Contract) Modularity Defining the environment computational model away from the monolithic and centralised view environment structure, behaviour Orthogonality Defining the environment distribution model wrt agent models, architectures, platforms topology support for heterogeneous systems 39 / 165 40 / 165 Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-upProgramming Models for the Environment: Desiderata Existing Computational Frameworks AGRE / AGREEN / MASQ [Stratulat et al., 2009] AGRE – integrating the AGR (Agent-Group-Role) organisation model with a notion of environment Environment used to represent both the physical and social part of interaction Dynamic extensibility AGREEN / MASQ – extending AGRE towards a unified dynamic construction, replacement, extension of environment representation for physical, social and institutional parts environments support for open systems Based on MadKit platform [Gutknecht and Ferber, 2000a] Reusability GOLEM [Bromuri and Stathis, 2008] reuse of environment parts for di↵erent kinds of applications Logic-based framework to represent environments for situated cognitive agents composite structure containing the interaction between cognitive agents and objects A&A and CArtAgO [Ricci et al., 2010b] introducing a computational notion of artifact to design and implement agent environments 41 / 165 42 / 165
  8. 8. Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Agents and Artifacts (A&A) Conceptual Model: Background Human Metaphor CLOCK WHITEBOARD BAKERY artifact artifact workspace agents can join dynamically the workspace A&A and CArtAgO ARCHIVE artifact COM. CHANNEL artifact RESOURCE artifact TASK SCHEDULER artifact 44 / 165 Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-upA&A Basic Concepts [Omicini et al., 2008] A&A Programming Model Features [Ricci et al., 2007b] Agents Abstraction autonomous, goal-oriented pro-active entities create and co-use artifacts for supporting their activities artifacts as first-class resources and tools for agents besides direct communication Modularisation Artifacts artifacts as modules encapsulating functionalities, organized non-autonomous, function-oriented, stateful entities in workspaces controllable and observable Extensibility and openness modelling the tools and resources used by agents artifacts can be created and destroyed at runtime by agents designed by MAS programmers Reusability Workspaces artifacts (types) as reusable entities, for setting up di↵erent grouping agents & artifacts kinds of environments defining the topology of the computational environment 45 / 165 46 / 165 Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-upA&A Meta-Model in More Detail [Ricci et al., 2010b] Artifact Abstract Representation Manual consult SIGNALS has ObsPropName(Args) create OBSERVABLE Workspace Artifact dispose ... PROPERTIES link USAGE link INTERFACE OperationX(Params) Operation use Agent Environment ... generate OPERATIONS update Observable perceive Event OperationY(Params) Observable perceive ... Property observe LINK join INTERFACE quit 47 / 165 48 / 165
  9. 9. Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-upA World of Artifacts A Simple Taxonomy Individual or personal artifacts designed to provide functionalities for a single agent use state available n_records 1001 e.g. an agenda for managing deadlines, a library... count 5 table_names ... wsdl ... inc state true ... ... Social artifacts reset switch GetLastTradePrice createTable ... addRecord query designed to provide functionalities for structuring and a flag a counter a Stock Quote Web Service ... managing the interaction in a MAS a data-base coordination artifacts [Omicini et al., 2004], organisation artifacts, ... n_items 0 next_todo check_plant max_items 100 last_todo ... clearEvents out e.g. a blackboard, a game-board,... postEvent in put setTodo get cancelTodo registerForEvs rd Boundary artifacts a bounded buffer an agenda an event service a tuple space to represent external resources/services e.g. a printer, a Web Service to represent devices enabling I/O with users e.g GUI, console, etc. 49 / 165 50 / 165 Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-upActions and Percepts in Artifact-Based Environments Interaction Model: Use Explicit semantics defined by the (endogenous) environment [Ricci et al., 2010c] success/failure semantics, execution semantics defining the contract (in the SE acceptation) provided by the PropName Value PropName Value environment ... op(parms) ... action actions ! artifacts’ operation op(Params) AGENT the action repertoire is given by the dynamic set of operations provided by the overall set of artifacts available in the workspace can be changed by creating/disposing artifacts action success/failure semantics is defined by operation semantics Performing an action corresponds to triggering the execution of an operation percepts ! artifacts’ observable properties + signals acting on artifact’s usage interface properties represent percepts about the state of the environment signals represent percepts concerning events signalled by the environment 51 / 165 52 / 165 Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-upInteraction Model: Operation execution Interaction Model: Observation SIGNALS PropName Value OBS PROPERTIES CHANGE Value ... op(parms) ... PropName(Value). action PropName(Value). op(Params) ... PropName Value AGENT OPERATION EXECUTION PropName Value Belief base ... action completion (or alike) focus - with success or failure - AGENT OBSERVER a process structured in one or multiple transactional steps asynchronous with respect to agent ...which can proceed possibly reacting to percepts and Agents can dynamically select which artifacts to observe executing actions of other plans/activities predefined focus/stopFocus actions operation completion causes action completion action completion events with success or failure, possibly with action feedbacks 53 / 165 54 / 165
  10. 10. Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-upInteraction Model: Observation Artifact Linkability PropName(Value). PropName(Value). ... PropName Value PropName Value Belief base ... (or alike) use linkedOp AGENT OBSERVER WSP-X WSP-Y By focussing an artifact Basic mechanism to enable inter-artifact interaction observable properties are mapped into agent dynamic linking artifacts through interfaces (link interfaces) knowledge about the state of the world, as percepts operations triggered by an artifact over an other artifact e.g. belief base Useful to design & program distributed environments signals are mapped as percepts related to observable events realised by set of artifacts linked together possibly hosted in di↵erent workspaces 55 / 165 56 / 165 Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-upArtifact Manual CArtAgO Common ARtifact infrastructure for AGent Open Agent-readable description of artifact’s... environment (CArtAgO) [Ricci et al., 2009b] ...functionality what functions/services artifacts of that type provide Computational framework / infrastructure to implement and ...operating instructions run artifact-based environment [Ricci et al., 2007c] how to use artifacts of that type Java-based programming model for defining artifacts set of basic API for agent platforms to work within Towards advanced use of artifacts by intelligent artifact-based environment agents [Piunti et al., 2008] dynamically choosing which artifacts to use to accomplish Distributed and open MAS their tasks and how to use them workspaces distributed on Internet nodes strong link with Semantic Web research issues agents can join and work in multiple workspace at a time Work in progress Role-Based Access Control (RBAC) security model defining ontologies and languages for describing the manuals Open-source technology available at http://cartago.sourceforge.net 57 / 165 58 / 165 Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-upIntegration with Agent Languages and Platforms JaCa Platform Integration of CArtAgO with Jason language/platform a JaCa program is a dynamic set of Jason agents working Integration with existing agent platforms [Ricci et al., 2008] together in one or multiple CArtAgO workspaces by means of bridges creating an action/perception interface and doing data binding Mapping actions Outcome Jason agent external actions are mapped onto artifacts’ developing open and heterogenous MAS operations introducing a further perspective on interoperability besides percepts the ACL’s one artifacts’ observable properties are mapped onto agent beliefs sharing and working in a common work environment artifacts’ signals are mapped as percepts related to common object-oriented data-model observable events data-model Jason data-model is extended to manage also (Java) objects 59 / 165 60 / 165
  11. 11. Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-upExample 1: A Simple Counter Artifact Example 1: User and Observer Agents class Counter extends Artifact { USER(S) OBSERVER(S) void init(){ defineObsProp("count",0); count 5 !create_and_use. !observe. } +!create_and_use : true +!observe : true @OPERATION void inc(){ <- !setupTool(Id); <- ?myTool(C); // discover the tool // use focus(C). ObsProperty p = getObsProperty("count"); inc inc; p.updateValue(p.intValue() + 1); // second use specifying the Id +count(V) signal("tick"); inc [artifact_id(Id)]. <- println(“observed new value: “,V). } } // create the tool +tick [artifact_name(Id,”c0”)] +!setupTool(C): true <- println(“perceived a tick”). <- makeArtifact("c0","Counter",C). +?myTool(CounterId): true <- lookupArtifact(“c0”,CounterId). Some API spots -?myTool(CounterId): true <- .wait(10); Artifact base class ?myTool(CounterId). @OPERATION annotation to mark artifact?s operations set of primitives to work define/update/.. observable properties signal primitive to generate signals Working with the shared counter 61 / 165 62 / 165 Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-upPre-defined Artifacts Example 2: Coordination Artifacts – A Bounded Bu↵er Each workspace contains by default a predefined set of public class BoundedBuffer extends Artifact { private LinkedList<Item> items; private int nmax; artifacts void init(int nmax){ items = new LinkedList<Item>(); providing core and auxiliary functionalities defineObsProperty("n_items",0); this.nmax = nmax; i.e. a pre-defined repertoire of actions available to agents... } n_items 5 @OPERATION void put(Item obj){ Among the others await("bufferNotFull"); items.add(obj); getObsProperty("n_items").updateValue(items.size()); put workspace, type: cartago.WorkspaceArtifact } get functionalities to manage the workspace, including security @OPERATION void get(OpFeedbackParam<Item> res) { await("itemAvailable"); Item item = items.removeFirst(); operations: makeArtifact, lookupArtifact, focus,... res.set(item); getObsProperty("n_items").updateValue(items.size()); node, type: cartago.NodeArtifact } @GUARD boolean itemAvailable(){ return items.size() > 0; } core functionalities related to a node @GUARD boolean bufferNotFull(Item obj){ return items.size() < nmax; } operations: createWorkspace, joinWorkspace, ... } console, type cartago.tools.Console operations: println,... Basic operation features blackboard, type cartago.tools.TupleSpace output parameters to represent action feedbacks operations: out, in, rd, ... long-term operations, with a high-level support for .... synchronization (await primitive, guards) 63 / 165 64 / 165 Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-up Introduction EOP OOP Conclusion Introduction Basic Advanced CArtAgO Wrap-upExample 2: Producers and Consumers Remarks PRODUCERS CONSUMERS item_to_produce(0). !consume. !produce. +!consume: true +!produce: true <- ?bufferReady; <- !setupTools(Buffer); !consumeItems. Process-based operation execution semantics !produceItems. +!consumeItems: true action/operation execution can be long-term +!produceItems : true <- get(Item); <- ?nextItemToProduce(Item); !consumeItem(Item); action/operation execution can overlap put(Item); !!consumeItems. !!produceItems. key feature for implementing coordination functionalities +!consumeItem(Item) : true +?nextItemToProduce(N) : true <- .my_name(Me); Operation with output parameters as action feedbacks <- -item_to_produce(N); println(Me,": ",Item). +item_to_produce(N+1). +?bufferReady : true +!setupTools(Buffer) : true <- lookupArtifact("myBuffer",_). <- makeArtifact("myBuffer","BoundedBuffer", -?bufferReady : true [10],Buffer). <-.wait(50); ?bufferReady. -!setupTools(Buffer) : true <- lookupArtifact("myBuffer",Buffer). 65 / 165 66 / 165

×