Event-Based vs. Multi-Agent Systems: Towards a Unified Conceptual Framework

Event-Based vs. Multi-Agent Systems:Towards a Unified Conceptual Framework

Andrea Omicini

Dipartimento di Informatica – Scienza e Ingegneria (DISI)Alma Mater Studiorum—Universita di Bologna, Italy

Keynote Speech @ IEEE CSCWD 2015Calabria, Italy6 May 2015

A. Omicini (DISI, UniBO) Event-Based vs. Multi-Agent Systems CSCWD – 6/5/2015 1 / 78

Outline

1 Premises

2 Event-based Systems

3 Multi-Agent Systems

4 Complex System Engineering: Events, Objects, Agents

5 Mixing Paradigms

6 EBS & MAS: Towards a Unified Framework

7 A Case Study in EBS & MAS Middleware: TuCSoN

8 Conclusion


Premises

Outline

1 Premises




5 Mixing Paradigms



8 Conclusion


Premises

Paradigms for Complex Systems Engineering

Multi-agent systems are expected to provide the most viableabstractions to deal with the modelling and engineering of complexsoftware systems [Jen00, Jen01]

The event-based architectural style has already become prevalent forlarge-scale distributed applications [FMG02], to address some of themost common sources of accidental complexity such as distributedinteraction and large-scale concurrency [Bro87, MJGM13]

Nowadays multi-agent systems (MAS) and event-based systems(EBS) stand as the two most promising paradigms for complexsystems modelling and engineering


Premises

Issues

Can agent-based and event-based models and technologies coexistwithout harming the conceptual integrity of systems?

Is there some common conceptual foundation that could be exploitedas a grounding for integrating agent-based and event-basedabstractions, languages, technologies, and methods, in a coherent andeffective way?


Premises

Outline

We start from the essential of both paradigms, and discuss theirimpact on complex system engineering

We review some of the approaches already gearing towards paradigmintegration

We devise out three steps towards a unified conceptual framework forEBS and MAS, which could work in principle as the foundation of acoherent discipline for the modelling and engineering of complexsoftware systems


Event-based Systems

Outline

1 Premises




5 Mixing Paradigms



8 Conclusion


Event-based Systems

Caveat Lector

The notions of event-based systems, event-based programming ,event-driven programming are more or less ubiquitous in ComputerScience literature

Neither terminology is uniform, nor the many diverse ontologies areoverall fully consistent

However, there is a solid core where some widely-shared ideas andterms can be pointed out so as to provide for a common ontology andterminology for EBS

For instance, in the well-established works by Luckham [Luc02] andMuhl et al. [MFP06]


Event-based Systems

Terminology for Event-Based Systems

Definition

According to [FMG02], an event-based systems (EBS) is

a system in which the integrated components communicate bygenerating and receiving event notifications

An event is an occurrence of a happening relevant for the system, e.g.a state change in some component

A notification is the reification of an event within the system, andprovides for its description


Event-based Systems

Event-Based Architectures

Components in event-based systems act as either producers orconsumers of notifications

Producers publish notifications, and provide an output interface forsubscription

Consumers subscribe to notifications as specified by producers

Being not real messages, notifications have not a designed receiver:they are distributed by the event notification service to consumersthat subscribed to that sort of notification

Expressiveness of subscriptions depends on the data model and filterlanguage used


Event-based Systems

Distributed Event-Based Systems (DEBS)

A fundamental issue in DEBS [MFP06] is represented by distributednotification routing—that is, the way in which notifications arerouted to distributed consumers

Typically handled by event-based middleware, where notifications maytake the form of messages

! Being transmitted in the same way and format of messages does notmake them messages in all aspects


Event-based Systems

Complex Event Processing (CEP)

Many articulated application scenarios – e.g., Business ActivityMonitoring, Sensor Networks, and Market data – raise eventmanagement issues [EB09]

Bringing about the need for the so-called Complex Event Processing(CEP) [Luc02]

Issues such as event aggregation and transformation have to beaddressed by making individual event notifications meaningful at thelevel of interpretation required for making consumer activities effective

Relationships (such as causality, timing, or membership) betweenevents should be detected, and event hierarchies could be required toprovide for different level of abstractions


Event-based Systems

EBS as Coordinated Systems

In EBS

activities of processes are basically driven by event notifications

as they are generated by producers

transformed, aggregated, filtered, distributed by the event bus

finally interpreted and used by consumers

In the overall, EBS are coordinated systems in their essence, where

coordination is event-based [MJGM13]

the event bus works as the system coordinator , encapsulating andpossibly automating most of the coordination activities in an EBS,including CEP-related ones

control over the logic of program execution is somehow inverted[HO06]


Multi-Agent Systems

Outline

1 Premises




5 Mixing Paradigms



8 Conclusion


Multi-Agent Systems

Main abstractions of MAS

MAS can be modelled according to the main first-class abstractions[WOO07]

agents

societies

environment


Multi-Agent Systems

Agents

Agents are computational entities whose defining feature is autonomy[Woo02, ORV08]

→ MAS are collection of autonomous agents working together as asystem

Goals & activities

Individual agents model activities within a MAS through theirobservable actions

along the motivations behind them—namely, the goals that set theagent’s course of actions [Cas12]

Intelligent agents [WJ95a] embody goals as an explicit mentalisticabstraction—along with beliefs, desires, intentions, available actions,and plans


Multi-Agent Systems

Societies I

Societies represent the ensembles where the collective behaviours ofthe MAS are regulated towards the achievement of the overall systemgoals

by governing mutual dependencies [MC94]


Multi-Agent Systems

Societies II

Depencencies & coordination

Handling dependencies in MAS is a coordination problem [MC94]

that is, understanding how actions by (possibly intelligent) agentsinterfere with each other in the MAS when each agent aims at its owngoal, and governing them altogether to make the whole MAS achieveits overall global goal

Accordingly, coordination models are the most suitable tools toharness complexity in MAS [COZ00]

as they are explicitly meant to provide the abstractions andmechanisms to “glue” agents together [GC92, Cia96]by governing agent interaction in a MAS [Weg96]

Agent societies can then be built around the abstraction provided bycoordination models [COZ00], that is

coordination media [Cia96], in the general case of distributed systemscoordination artefacts [ORV+04], in the case of MAS


Multi-Agent Systems

Environment

Environment captures the unpredictability of the MAS context

by modelling the external resources and features that are relevant forthe MAS

along with their change over time [WOO07]

Situated action & MAS situatedess

Situated action is the realisation that coordinated, social, intelligentaction arises from strict interaction with the environment, rather thanfrom rational practical reasoning [Suc87]

The need for situatedness of agents and MAS often translates intothe requirement of being sensitive to environment change [FM96]

This basically means dependency , again: so, agent (and, generally,MAS) behaviour is expected to be affected by environment change


Complex System Engineering: Events, Objects, Agents

Outline

1 Premises




5 Mixing Paradigms



8 Conclusion



Accidental Complexity I

Accidental complexity (originally called accidental difficulty [Bro87])is not related to the application problem, but rather to our lack ofappropriate abstractions and tools to directly handle the essence ofthe problem (essential complexity)

Whereas [Bro87] claims that software engineers nowadays mostly dealwith essential complexity due to the high-level languages andframeworks available, new application scenarios have generated newforms of accidental complexity



Accidental Complexity II

Sources of accidental complexity [MJGM13]

distributed interaction — the distributed architecture of multiple serversrunning on the cloud (server farms) interacting with clientsrunning on different platforms (e.g., smartphones, webbrowsers, desktop widgets, etc.)

abstraction gap — between the problem-domain level (high-level, oftenevent-driven) and the implementation-level (low-levelmessages, queues, schedulers, asynchronous callbacks)

shared data consistency — many sources of data are replicated anddistributed, and accessed concurrently—as well as distributedresources, more generally

concurrency issues — such as data races, atomicity violations, deadlocks,etc.



Object & Event-Based Systems

Object-oriented languages, frameworks, and platforms are stilldominating the SE landscape

The same application field (human-computer graphical interfaces)that made object-oriented languages mainstream is whereevent-driven programming fully developed first

So, object-oriented and event-driven programming represent a goodmatch

However, distributed computing with object-oriented programmingsuffers from an abstraction gap: distributed objects requires eitherthe design of distributed control or total transparency



Agent-Based Engineering for Complex Software Systems

Encapsulation of control makes agents overcome the abstraction gapof OOP [Ode02]

Agent abstractions inherently deal with distribution [Jen00]

Agent autonomy –– along with the associated agent features such associality, pro-activeness, situatedness, and the like – makeagent-oriented software engineering (AOSE) a viable approach forengineering complex software systems [Jen01]

Extra agent features such as mobility and intelligence make AOSEthe most effective approach available for the engineering of intelligentand pervasive distributed systems [ZO04]


Mixing Paradigms

Outline

1 Premises




5 Mixing Paradigms



8 Conclusion


Mixing Paradigms

Agent-Oriented vs. Object-Oriented Computing

Agents are not objects [Gra96], but they can mixed up withobjects—e.g., by wrapping objects as agents [Ode02]

Agent-oriented middleware can build upon object-oriented middlewareto enable the paradigm shift—e.g., Jade [BCG07], TuCSoN [OZ99]

More conceptually-coherent approaches to the integration of agentsand objects include

wrapping objects as agents [Ode02]artefact in the A&A meta-model allowing agents to use objects in aMAS [ORV08]


Mixing Paradigms

Integrating MAS with EBS I

Indirectly

Objects-oriented programming straightforwardly couples withevent-driven systems

Agents can mixup with objects—by either wrapping objects, or usingthem as artefacts

! Using objects as a sort of intermediate paradigm between events andagents do not represent a straightforward and conceptually-cleansolution


Mixing Paradigms

Integrating MAS with EBS II

Directly

Agents are supposed to be reactive to change [WJ95b]

Agents and MAS are supposed to be situated [WOO07]

! as witnessed by the many diverse occurrences of the notion of eventat the different level of MAS models and technologies


Mixing Paradigms

Technology Patterns I

Most of the agent architectures adopts some effective notion of event,in order to provide for agent reactiveness—e.g., BDI architectures[RG91]

Most of the agent middlewares provide some event-based abstractionsand mechanisms so as to deal with asynchronous message passing andenvironment change–––such as Jade [BCG07] and TuCSoN [OZ99]

[ABF+11] presents an agent-based architecture for coordinating eventstreams from WBSN

ELDA is an event-driven agent meta-model [FGMR10]

eXAT [DSS05] is an agent programming platform exploiting theErlang concurrent language [AVWW96]

In the mobile agent field, MAPS [AFGG11] is an event-based agentplatform for programming wireless sensor networks (WSN) in Java


Mixing Paradigms

Technology Patterns II

In [BLO+14, BDB+14], an event-driven architecture engineered as aMAS is exploited in the context of an EMA (emergency medicalassistance) application scenario

Integrating actors with event-based system

Event-based actors allow for event-based programming withoutinversion of control [HO06]

Scala actors unify event-based with thread-based programming[HO09]


Mixing Paradigms

What is Missing?

The above examples just emphasise the need for the integration ofthe two paradigms, but do not provide a coherent and uniformconceptual framework for both

Just dealing with the mere integration of technologies wouldessentially harm conceptual integrity, making the attempt to build upan overall approach for the engineering of complex software systemsessentially ineffective

Thus, in the remainder of the talk, we discuss how we could aim at awhole unified conceptual framework, capturing both MAS and EBS ina coherent way , though three steps of re-interpretation ofagent-based and event-based abstractions


EBS & MAS: Towards a Unified Framework

Outline

1 Premises




5 Mixing Paradigms



8 Conclusion


EBS & MAS: Towards a Unified Framework Event Sources

Outline

1 Premises




5 Mixing Paradigms

6 EBS & MAS: Towards a Unified FrameworkEvent SourcesBoundary ArtefactsEvent-based Coordination


8 Conclusion



Re-interpreting Agents and Environment

In a MAS, agents and environment are the abstractions representingthe only sources of events

agents represent the designed source of events, autonomously drivingcontrol towards their own goals, and producing internal eventsthrough their actions

environment models the external events that are relevant for theMAS, whose dynamics is in principle unpredictable, throughabstractions of some sorts – environment resources, sensors &actuators, probes – that also capture diversity of the environment



An Event-based View of MAS

Along this line, MAS can be seen as EBS where

agents encapsulate internal events—more generally, they encapsulatethe activities in MAS that generate events according to someapplication criterion

environment models external events through dedicated abstractions –environment resources –, thus capturing the dynamics of theunpredictable events external but relevant to MAS



An Agent-based View of EBS

Dually, EBS can be seen as MAS where producers in an EBS are to beclassified as

either agents—if they are responsible for the designed, internal events

or environment resources—if they are used to model external,unpredictable events



Benefits

Agent abstractions induce a higher-level of expressiveness in EBS

since agents encapsulate control along with the criteria for itsmanagement, articulated events histories can be modelled, along withtheir motivations

Conceptual integrity is largely improved

since environment is modelled as a first-class event-based abstraction,all causes of change and disruption in a MAS are modelled in a uniformway as event pro-sumers


EBS & MAS: Towards a Unified Framework Boundary Artefacts

Outline

1 Premises




5 Mixing Paradigms



8 Conclusion



General Event Model

Handling all the ways in which an agent may produce events meansaccounting for all the many diverse ways in which an agent may effectand perceive the environment.

physical actions of any sorts, perceptions, communication &coordination actions, epistemic actions, and so on and so forth

Resources of any sorts give structure to MAS environment, bringingabout a potentially huge variety of possible interactions

→ Heterogeneity and scale of events mandates for a general eventmodel capable of capturing any sort of event – and all of itsproperties – in an expressive yet uniform way



Boundary Artefacts

The need for a general event model mandates for architecturalabstractions mediating between event producers and the whole system

aimed at uniformly handling a (possibly) hugely heterogeneouscollection of event sources

agents, on the one handenvironmental resources, on the other

Boundary artefacts allow in principle all sorts of occurrences to besuitably translated according to a common general event model intoa uniform system of notifications



An Architectural Pattern

In the MAS field, such a role is played by

Agent Communication Contexts [DSPST06], Agent CoordinationContexts [Omi02] for agentsenvironment class for environment resources in Jason [BHW07]transducers for ReSpecT probes [MO14]

In the field of event-based middleware, such a role is played by eventmediators (or, correlators) in the Cambridge Event Architecture[BMB+00], as implemented by

the Hermes distributed event-based middleware architecture [PB02]the OASIS open architecture for open, secure, widely distributedservices [BM02]



Benefits

When conceived as the abstraction mediating between componentsand the event bus, boundary artefacts account in principle forheterogeneity of event notifications

By ruling agent interaction within a MAS as constrainers, rather thanas commanders [Weg96], boundary artefacts also account for agentautonomy


EBS & MAS: Towards a Unified Framework Event-based Coordination

Outline

1 Premises




5 Mixing Paradigms



8 Conclusion



Dependencies

If agents and environment work as event sources, social abstractionsshould take care of dealing with interaction of any sort

agent-agent interactionagent-environment interactionenvironment-environment interactionas well as any other more complex pattern of interaction

taking care of their mutual dependencies

by coordinating the many resulting flows of events [MC94].



Complexity, Interaction & Coordination

Interaction is an essential source of complexity for computationalsystems in general [Weg97]

A coordination model provides a framework in which the interactionof active and independent entities called agents can be expressed[Cia96]

coordination entities are the entities whose mutual interaction is ruledby the model, also called the coordinables, or agentscoordination media are the abstractions enabling and ruling interactionamong coordinablescoordination laws are the rules governing the observable behaviour ofcoordinables, the behaviour of the coordination media, as well as theirinteractions of any sort



Coordination Models

In principle, coordination abstractions and technologies can helpharnessing the intricacies of interaction in the engineering of complexsoftware systems [Weg96]

by constraining the space of admissible interactions [Omi99]

In particular, the coordination primitives provided by a coordinationmodel constrain the possibile agent actions

whereas the coordination media provided by a coordination modelconstrain the possible targets of agent actions

In the overall

A coordination model constrains agents to interact via a limited set ofprimitives acting on a class of pre-defined media of coordination, whosecomputational behaviour defines the laws of coordination



Event-Based Coordination in the Literature

The potential of event-based coordination is recognised both inacademia and industry, and there exists a considerable amount ofrelated work on event notification systems [FMG02]

A number of

event-based middleware providing such services—e.g., JEDI [CDNF01]event-based coordination models [PA98, VOR02]event-based coordination technologies [FHA99]event-based coordination formalisms [Omi99, VR02]

in the literature witness

the role of event-based middleware in the engineering of complexdistributed systemsthe event-based nature of the most relevant coordination models, suchas tuple-based ones [Omi99]



Coordination Media for Event Coordination I

Along this line, the third step in the integration of MAS and EBS is therecognition that

coordination media [Cia96]) are the abstractions in charge ofcoordinating multiple event flows [ORZ06]

according to their mutual dependencies in both MAS and EBS

From the MAS viewpoint

The role of coordination models in MAS [COZ00] is to provideevent-driven coordination media as the coordination artefacts aimedat governing and ruling event coordination in MAS

← where coordination artefacts are the social abstractions in charge ofmanaging dependencies of any sort within a MAS [MO15]



Coordination Media for Event Coordination II

From the EBS viewpoint

Since EBS are essentially coordinated systems, where

coordination is event-based [MJGM13]the event bus works as the system coordinator

→ coordination media could work as the core for an event-basedarchitecture

→ EBS could be grounded upon a suitably-expressive coordinationmiddleware, designing the event bus around the coordination services[VO06]



Benefits

Since all events are represented uniformly, coordination artefacts canbe used to deal with both social and situated dependencies,governing all interactions [MO14] and enforcing conceptual integrity

By providing a specific computational model for dealing with eventobservation, manipulation, and coordination, coordination artefactsshould make life easier for programmers and engineers

Coordination media provide a suitable way to automatise eventhandling in EBS

By encapsulating the logic for the coordination of multiple flows ofevents, coordination artefacts counterfeit inversion of control on thelarge scale


A Case Study in EBS & MAS Middleware: TuCSoN

Outline

1 Premises




5 Mixing Paradigms



8 Conclusion



TuCSoN Architecture I



TuCSoN Architecture II

agents — Any computational entity willing to exploit TuCSoNcoordination services. Agents should request and obtain anACC from the TuCSoN node. Any action from any agenttowards the MAS – either social or situated – is thenmediated by its associated ACC.

ACC — Agent coordination contexts [Omi02] are TuCSoNboundary artefacts devoted to agents. ACC both enable andconstraint agents interactions: in particular, ACCs map everyagent operation into events asynchronously dispatched totuple centres. ACCs thus decouple agents from MAS incontrol, reference, space, and time.



TuCSoN Architecture III

probes — Environmental resources in TuCSoN are called probes.They are dealt with as sources of perceptions (aka sensors)or makers of actions (aka actuators) in a uniform way.Probes do not directly interact with the MAS, but throughmediation of their associated transducer.

transducers — TuCSoN transducers [CO09] are the boundary artefactsdevoted to probes. Each probe is assigned to a transducer,which is specialised to handle events from that probe, and toact on probes through situation operations. Transducers thusdecouple in control, reference, space and time probes fromtuple centres.



TuCSoN Architecture IV

events — TuCSoN adopts and generalises the ReSpecT eventmodel. Events are the run-time data structure representingboth activities and change in a uniform way. ACC andtransducers translate external events (activities and change)into internal events (operations and situations) that tuplecentres can handle to implement the policies required forMAS coordination

tuple centres — TuCSoN architectural component implementingcoordination artefacts, thus in charge of managingdependencies. As such, they are meant to govern both socialand situated interactions [OM13]. By adopting ReSpecTtuple centres, TuCSoN relies on (i) the ReSpecT language toprogram coordination laws, and (ii) the ReSpecT situatedevent model to implement events



TuCSoN Event Model I

〈Event〉 ::= 〈StartCause〉 , 〈Cause〉 , 〈Evaluation〉〈StartCause〉 , 〈Cause〉 ::= 〈Activity〉 | 〈Change〉 , 〈Source〉 , 〈Target〉 , 〈Time〉 , 〈Space:Place〉

〈Source〉 , 〈Target〉 ::= 〈AgentId〉 | 〈CoordArtefactId〉 | 〈EnvResId〉 | ⊥〈Evaluation〉 ::= ⊥ | {〈Result〉}

Table: ReSpecT situated event model



TuCSoN Event Model II

〈Activity〉 ::= 〈Operation〉 | 〈Situation〉〈Operation〉 ::= out( 〈Tuple〉 ) | (in | rd | no | inp | rdp | nop) ( 〈Template〉 [, 〈Term〉] )〈Situation〉 ::= getEnv( 〈Key〉 , 〈Value〉 ) | setEnv( 〈Key〉 , 〈Value〉 )〈Change〉 ::= env( 〈Key〉 , 〈Value〉 ) | time( 〈Time〉 ) |

from( 〈Space〉 , 〈Place〉 ) | to( 〈Space〉 , 〈Place〉 )

Table: ReSpecT triggering events



Event-Based TuCSoN: Summing Up

In a TuCSoN-coordinated MAS

ACCs and transducers represent agents and environment,respectively, in the MAS, by translating activities and environmentchange in a common event model

Tuple centres deals with both social and situated dependencies bymaking it possible to program the coordination of all sort of event ina uniform way

In the overall, TuCSoN seemingly provides both a model and a technologyto engineer coordinated MAS as EBS—or, dually, EBS as full-fledged MAS


Conclusion

Outline

1 Premises




5 Mixing Paradigms



8 Conclusion


Conclusion

Summing Up I

A unified conceptual framework for MAS and EBS. . .

. . . is possible

. . . could work as the foundation of a principled discipline for theengineering of complex software systems

. . . by promoting a coherent integration of agent-based andevent-based abstractions, languages, technologies, and methods


Conclusion

Summing Up II

Steps

Three conceptual steps towards the unified framework

1 Agents and environment are interpreted as the only sources of events

2 Boundary artefacts as the architectural abstractions mediatingbetween event sources and the system, enacting a general event model

3 Coordination media as the social abstractions for coordinatingmultiple event flows


Acknowledgment

Thanks. . .

. . . to everybody here for listening

. . . to Giancarlo Fortino for inviting me to the CSCWD 2015conference

. . . to Stefano Mariani for the many discussions about agents andevents we had in the last years


References

References I

Francesco Aiello, Fabio Luigi Bellifemine, Giancarlo Fortino, Stefano Galzarano, andRaffaele Gravina.An agent-based signal processing in-node environment for real-time human activitymonitoring based on wireless body sensor networks.Engineering Applications of Artificial Intelligence, 24(7):1147–1161, 2011.

F. Aiello, G. Fortino, R. Gravina, and A. Guerrieri.A Java-based agent platform for programming wireless sensor networks.Computer Journal, 54(3):439–454, 2011.

Joe Armstrong, Robert Virding, Claes Wikstrom, and Mike Williams.Concurrent Programming in Erlang.Prentice Hall International, 2nd edition, 1996.

Fabio Luigi Bellifemine, Giovanni Caire, and Dominic Greenwood.Developing Multi-Agent Systems with JADE.Wiley, February 2007.


References

References II

Ralf Bruns, Jurgen Dunkel, Holger Billhardt, Marin Lujak, and Sascha Ossowski.Using Complex Event Processing to support data fusion for ambulance coordination.In Juan M. Corchado, James Llinas, Jesus Garcia, Jose Manuel Molina, Javier Bajo,Stefano Coraluppi, David Hall, Moises Sudit, Alan Steinberg, T. Kirubarajan, Eloi Bosse,Kellyn Rein, Subrata Das, and Uwe Hanebeck, editors, 17th International Conference onInformation Fusion (FUSION 2014), pages 1–7, Salamanca, Spain, 2014. IEEE ComputerSociety.

Rafael H. Bordini, Jomi F. Hubner, and Michael J. Wooldridge.Programming Multi-Agent Systems in AgentSpeak using Jason.John Wiley & Sons, Ltd, October 2007.

Holger Billhardt, Marin Lujak, Sascha Ossowski, Ralf Bruns, and Jurgen Dunkel.Intelligent event processing for emergency medical assistance.In 29th Annual ACM Symposium on Applied Computing (SAC 2014), pages 200–206, NewYork, New York, USA, March 2014. ACM Press.

Jean Bacon and Ken Moody.Toward open, secure, widely distributed services.Communications of the ACM, 45(6):59–64, June 2002.


References

References III

Jean Bacon, Ken Moody, John Bates, Richard Heyton, Chaoying Ma, Andrew McNeil,Oliver Seidel, and Mark Spiteri.Generic support for distributed applications.Computer, 33(3):68–76, March 2000.

Frederick P. Brooks.No Silver Bullet Essence and Accidents of Software Engineering.Computer, 20(4):10–19, April 1987.

Cristiano Castelfranchi.Goals, the true center of cognition.In Fabio Paglieri, Luca Tummolini, Rino Falcone, and Maria Miceli, editors, The Goals ofCognition. Essays in Honor of Cristiano Castelfranchi, volume 20 of Tributes, chapter 41,pages 837–882. College Publications, London, December 2012.

Gianpaolo Cugola, Elisabetta Di Nitto, and Alfonso Fuggetta.The JEDI event-based infrastructure and its application to the development of the OPSSWFMS.IEEE Transactions on Software Engineering, 27(9):827–850, September 2001.


References

References IV

Paolo Ciancarini.Coordination models and languages as software integrators.ACM Computing Surveys, 28(2):300–302, June 1996.

Matteo Casadei and Andrea Omicini.Situated tuple centres in ReSpecT.In Sung Y. Shin, Sascha Ossowski, Ronaldo Menezes, and Mirko Viroli, editors, 24thAnnual ACM Symposium on Applied Computing (SAC 2009), volume III, pages1361–1368, Honolulu, Hawai’i, USA, 8–12 March 2009. ACM.

Paolo Ciancarini, Andrea Omicini, and Franco Zambonelli.Multiagent system engineering: The coordination viewpoint.In Nicholas R. Jennings and Yves Lesperance, editors, Intelligent Agents VI. AgentTheories, Architectures, and Languages, volume 1757 of LNAI, pages 250–259. Springer,2000.6th International Workshop (ATAL’99), Orlando, FL, USA, 15–17 July 1999. Proceedings.

Antonella Di Stefano, Giuseppe Pappalardo, Corrado Santoro, and Emiliano Tramontana.The transparent implementation of agent communication contexts.Concurrency and Computation: Practice and Experience, 18(4):387–407, 2006.


References

References V

Antonella Di Stefano and Corrado Santoro.Supporting agent development in Erlang through the eXAT platform.In Rainer Unland, Monique Calisti, and Matthias Klusch, editors, Software Agent-BasedApplications, Platforms and Development Kits, Whitestein Series in Software AgentTechnologies, pages 47–71. Birkhauser Basel, 2005.

Michael Eckert and Francois Bry.Complex event processing (CEP).Informatik-Spektrum, 32(2):163–167, March 2009.

Giancarlo Fortino, Alfredo Garro, Samuele Mascillaro, and Wilma Russo.Using event-driven lightweight DSC-based agents for MAS modelling.International Journal of Agent-Oriented Software Engineering, 4(2):113–140, 2010.

Eric Freeman, Susanne Hupfer, and Ken Arnold.JavaSpaces Principles, Patterns, and Practice: Principles, Patterns and Practices.The Jini Technology Series. Addison-Wesley Longman, June 1999.

Jacques Ferber and Jean-Pierre Muller.Influences and reaction: A model of situated multiagent systems.In Mario Tokoro, editor, 2nd International Conference on Multi-Agent Systems(ICMAS-96), pages 72–79, Tokio, Japan, December 1996. AAAI Press.


References

References VI

Ludger Fiege, Gero Muhl, and Felix C. Gartner.Modular event-based systems.The Knowledge Engineering Review, 17(4):359–388, December 2002.

David Gelernter and Nicholas Carriero.Coordination languages and their significance.Communications of the ACM, 35(2):97–107, 1992.

Stan Franklin Art Graesser.Is it an agent, or just a program?: A taxonomy for autonomous agents.In Jorg P. Muller, Michael J. Wooldridge, and Nicholas R. Jennings, editors, IntelligentAgents III Agent Theories, Architectures, and Languages: ECAI’96 Workshop (ATAL)Budapest, Hungary, August 12–13, 1996 Proceedings, volume 1193 of Lecture Notes InComputer Science, pages 21–35. Springer, 1996.

Philipp Haller and Martin Odersky.Event-based programming without inversion of control.In David E. Lightfoot and Clemens Szyperski, editors, Modular Programming Languages.7th Joint Modular Languages Conference, JMLC 2006 Oxford, UK, September 13-15,2006 Proceedings, number 1 in Lecture Notes in Computer Science, pages 4–22, Oxford,UK, September 2006. Springer Berlin Heidelberg.


References

References VII

Philipp Haller and Martin Odersky.Scala actors: Unifying thread-based and event-based programming.Theoretical Computer Science, 410(2-3):202–220, February 2009.

Nicholas R. Jennings.On agent-based software engineering.Artificial Intelligence, 117(2):277–296, March 2000.

Nicholas R. Jennings.An agent-based approach for building complex software systems.Communications of the ACM, 44(4):35–41, April 2001.

David C. Luckham.The Power of Events: An Introduction to Complex Event Processing in DistributedEnterprise Systems.Addison-Wesley Longman Publishing Co., Inc, Boston, MA, USA, 2002.

Thomas W. Malone and Kevin Crowston.The interdisciplinary study of coordination.ACM Computing Surveys, 26(1):87–119, 1994.


References

References VIII

Gero Muhl, Ludger Fiege, and Peter Pietzuch.Distributed Event-Based Systems.Springer Berlin Heidelberg, 2006.

Aleksandar Milicevic, Daniel Jackson, Milos Gligoric, and Darko Marinov.Model-based, event-driven programming paradigm for interactive Web applications.In 2013 ACM International Symposium on New Ideas, New Paradigms, and Reflections onProgramming & Software (Onward!’13), pages 17–36, New York, NY, USA, October 2013.ACM Press.

Stefano Mariani and Andrea Omicini.Coordination in situated systems: Engineering mas environment in TuCSoN.In Giancarlo Fortino, Giuseppe Di Fatta, Wenfeng Li, Sergio Ochoa, Alfredo Cuzzocrea,and Mukaddim Pathan, editors, Internet and Distributed Computing Systems, volume 8729of Lecture Notes in Computer Science, pages 99–110. Springer International Publishing,September 2014.7th International Conference on Internet and Distributed Computing Systems (IDCS2014), Calabria, Italy, 22-24 September 2014, Proceedings.

Stefano Mariani and Andrea Omicini.Coordinating activities and change: An event-driven architecture for situated MAS.Engineering Applications of Artificial Intelligence, January 2015.


References

References IX

James J. Odell.Objects and agents compared.Journal of Object Technology, 1(1):41–53, May–June 2002.

Andrea Omicini and Stefano Mariani.Coordination for situated MAS: Towards an event-driven architecture.In Daniel Moldt and Heiko Rolke, editors, International Workshop on Petri Nets andSoftware Engineering (PNSE’13), volume 989 of CEUR Workshop Proceedings, pages17–22. Sun SITE Central Europe, RWTH Aachen University, 6 August 2013.

Andrea Omicini.On the semantics of tuple-based coordination models.In 1999 ACM Symposium on Applied Computing (SAC’99), pages 175–182, New York,NY, USA, 28 February – 2 March 1999. ACM.Special Track on Coordination Models, Languages and Applications.

Andrea Omicini.Towards a notion of agent coordination context.In Dan C. Marinescu and Craig Lee, editors, Process Coordination and UbiquitousComputing, chapter 12, pages 187–200. CRC Press, Boca Raton, FL, USA, October 2002.


References

References X

Andrea Omicini, Alessandro Ricci, Mirko Viroli, Cristiano Castelfranchi, and LucaTummolini.Coordination artifacts: Environment-based coordination for intelligent agents.In Nicholas R. Jennings, Carles Sierra, Liz Sonenberg, and Milind Tambe, editors, 3rdinternational Joint Conference on Autonomous Agents and Multiagent Systems (AAMAS2004), volume 1, pages 286–293, New York, USA, 19–23 July 2004. ACM.

Andrea Omicini, Alessandro Ricci, and Mirko Viroli.Artifacts in the A&A meta-model for multi-agent systems.Autonomous Agents and Multi-Agent Systems, 17(3):432–456, December 2008.Special Issue on Foundations, Advanced Topics and Industrial Perspectives of Multi-AgentSystems.

Andrea Omicini, Alessandro Ricci, and Nicola Zaghini.Distributed workflow upon linkable coordination artifacts.In Paolo Ciancarini and Herbert Wiklicky, editors, Coordination Models and Languages,volume 4038 of LNCS, pages 228–246. Springer, June 2006.

Andrea Omicini and Franco Zambonelli.Coordination for Internet application development.Autonomous Agents and Multi-Agent Systems, 2(3):251–269, September 1999.


References

References XI

George A. Papadopoulos and Farhad Arbab.Coordination models and languages.In Marvin V. Zelkowitz, editor, The Engineering of Large Systems, volume 46 of Advancesin Computers, pages 329–400. Academic Press, 1998.

Peter R. Pietzuch and Jean M. Bacon.Hermes: a distributed event-based middleware architecture.In 22nd International Conference on Distributed Computing Systems Workshops (ICDCS2002), pages 611–618, Vienna, Austria, 2–5 July 2002. IEEE Computer Society.

Anand S. Rao and Michael P. Georgeff.Modeling rational agents within a BDI architecture.In James F. Allen, Richard Fikes, and Erik Sandewall, editors, 2nd International Conferenceon Principles of Knowledge Representation and Reasoning (KR’91), pages 473–484, SanMateo, CA, 1991. Morgan Kaufmann Publishers.

Lucy A. Suchman.Situated actions.In Plans and Situated Actions: The Problem of Human-Machine Communication,chapter 4, pages 49–67. Cambridge University Press, New York, NYU, USA, 1987.


References

References XII

Mirko Viroli and Andrea Omicini.Coordination as a service.Fundamenta Informaticae, 73(4):507–534, 2006.Special Issue: Best papers of FOCLASA 2002.

Mirko Viroli, Andrea Omicini, and Alessandro Ricci.On the expressiveness of event-based coordination media.In Hamid R. Arabnia, editor, International Conference on Parallel and DistributedProcessing Techniques and Applications (PDPTA’02), volume III, pages 1414–1420, LasVegas, NV, USA, July 2002. CSREA Press.

Mirko Viroli and Alessandro Ricci.Tuple-based coordination models in event-based scenarios.In 22nd International Conference on Distributed Computing Systems, pages 595–601. IEEECS, 2002.Proceedings of the Workshops.


References

References XIII

Peter Wegner.Coordination as constrained interaction.In Paolo Ciancarini and Chris Hankin, editors, Coordination Languages and Models. FirstInternational Conference, COORDINATION ’96 Cesena, Italy, April 15–17, 1996.Proceedings, Lecture Notes in Computer Science, pages 28–33, Cesena, Italy, April 1996.Springer Berlin Heidelberg.

Peter Wegner.Why interaction is more powerful than algorithms.Communications of the ACM, 40(5):80–91, May 1997.

Michael J. Wooldridge and Nicholas R. Jennings.Intelligent agents: Theory and practice.Knowledge Engineering Review, 10(2):115–152, June 1995.

Michael J. Wooldridge and Nicholas R. Jennings.Intelligent agents: Theory and practice.Knowledge Engineering Review, 10(2):115–152, 1995.

Michael J. Wooldridge.An Introduction to MultiAgent Systems.John Wiley & Sons Ltd., Chichester, UK, March 2002.


References

References XIV

Danny Weyns, Andrea Omicini, and James J. Odell.Environment as a first-class abstraction in multi-agent systems.Autonomous Agents and Multi-Agent Systems, 14(1):5–30, February 2007.

Franco Zambonelli and Andrea Omicini.Challenges and research directions in agent-oriented software engineering.Autonomous Agents and Multi-Agent Systems, 9(3):253–283, November 2004.Special Issue: Challenges for Agent-Based Computing.


Extras

URLs

Slides

On APICe

http://apice.unibo.it/xwiki/bin/view/Talks/EbsmasCscwd2015

On SlideSharehttp://www.slideshare.net/andreaomicini/

eventbased-vs-multiagent-systems-towards-a-unified-conceptual-framework


http://apice.unibo.it/xwiki/bin/view/Talks/EbsmasCscwd2015

http://www.slideshare.net/andreaomicini/eventbased-vs-multiagent-systems-towards-a-unified-conceptual-framework



Event-Based vs. Multi-Agent Systems:Towards a Unified Conceptual Framework

Andrea Omicini

Dipartimento di Informatica – Scienza e Ingegneria (DISI)Alma Mater Studiorum—Universita di Bologna, Italy

Keynote Speech @ IEEE CSCWD 2015Calabria, Italy6 May 2015


Event-Based vs. Multi-Agent Systems: Towards a Unified Conceptual Framework

Science

Transcript of Event-Based vs. Multi-Agent Systems: Towards a Unified Conceptual Framework