event-based vs. multi-agent systems: towards a unified conceptual framework. preliminary notes

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

Preliminary Notes

Andrea Omicini

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

Short Course @ WOA 2014 Mini-schoolWorkshop nazionale “Dagli Oggetti agli Agenti”

Universita di Catania, Italy25 Settembre 2014

A. Omicini (DISI, UniBO) Event-Based vs. Multi-Agent Systems WOA 2014 – 25/9/2014 1 / 62

Outline

1 Programming Paradigms for Complex System Engineering

2 Engineering MAS as Event-Based Systems

3 Conclusion


Programming Paradigms for Complex System Engineering

Outline



3 Conclusion


Programming Paradigms for Complex System Engineering Complexity in Software Systems

Outline

1 Programming Paradigms for Complex System EngineeringComplexity in Software SystemsMixing ParadigmsAgent-Based vs. Event-Based Systems

2 Engineering MAS as Event-Based SystemsEssentials of Event-Based SystemsMAS as Event-Based SystemsMAS Coordination: An Event-driven ViewA Case Study in MAS Coordination as EBS: TuCSoN

3 Conclusion



Accidental Complexity I

Accidental complexity (originally called accidental difficulty[Brooks, 1987]) is not related to the application problem, but ratherto our lack of appropriate abstractions and tools to directly handlethe essence of the problem (essential complexity)

Whereas [Brooks, 1987] claims that software engineers nowadaysmostly deal with essential complexity due to the high-level languagesand frameworks available, new application scenarios have generatednew forms of accidental complexity



Accidental Complexity II

Sources of accidental complexity [Milicevic et al., 2013]

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.



Distributed & Event-Based Systems

Nowadays, applications are increasingly distributed and event-driven[Milicevic et al., 2013]

According to [Fiege et al., 2002], the event-based architectural style

has become prevalent for large-scale distributed applications due to theinherent loose coupling of the participantsfacilitates the clear separation of communication from computationcarries the potential for easy integration of autonomous, heterogeneouscomponents into complex systems that are easy to evolve and scale



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 & Event-Based Systems

Agent-based engineering for complex software systems

Encapsulation of control makes agents overcome the abstraction gapof OOP [Odell, 2002]

Agent abstractions inherently deal with distribution [Jennings, 2000]

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 [Jennings, 2001]

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


Programming Paradigms for Complex System Engineering Mixing Paradigms

Outline



3 Conclusion



Agent-Oriented vs. Object-Oriented Computing

Agents are not objects [Graesser, 1996], but they can mixed up withobjects—e.g., by wrapping objects as agents [Odell, 2002]

Agent middleware can build upon object middleware to enable theparadigm shift—e.g., Jade [Bellifemine et al., 2007], TuCSoN[Omicini and Zambonelli, 1999]

The artefact notion works as a conceptually-coeherent bridge betweenagents and objects [Omicini et al., 2008]



The A&A Metamodel

In the agents & artefacts (A&A) meta-model [Omicini et al., 2008], inshort

agents are autonomous computational entities, encapsulating controlalong with a criterion to govern it

artefacts are computational entities aimed to be used by agents

By extending the reach of the object notion to artefacts, agents can useobjects in a MAS, thus making agent / object interaction sound from botha conceptual and a technical viewpoint


Programming Paradigms for Complex System Engineering Agent-Based vs. Event-Based Systems

Outline



3 Conclusion



Agents-Events Integration?

Either indirectly, since

objects-oriented programming straightforwardly couples withevent-driven systems

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

or directly, since

agents are supposed to be reactive to change[Wooldridge and Jennings, 1995]

agents and MAS are supposed to be situated [Weyns et al., 2007]

agents and events could cope well, in principle, thus allowing for aseamless integration



Examples I

Integrating MAS with event-based system (EBS)

Most of the agent architectures adopts some effective notion of event, in order toprovide for agent reactiveness—e.g., BDI architectures [Rao and Georgeff, 1991]

Most of the agent middlewares provide some event-based abstractions andmechanisms so as to deal with asynchronous message passing and environmentchange–––such as Jade [Bellifemine et al., 2007] and TuCSoN[Omicini and Zambonelli, 1999]

[Aiello et al., 2011] presents an agent-based architecture for coordinating eventstreams from WBSN

ELDA is an event-driven agent meta-model [Fortino et al., 2010]

eXAT [Di Stefano and Santoro, 2005] is an agent programming platform exploitingthe Erlang concurrent language [Armstrong et al., 1996]



Examples II

Integrating actors with event-based system

Event-based actors allow for event-based programming withoutinversion of control [Haller and Odersky, 2006]

Scala actors unify event-based with thread-based programming[Haller and Odersky, 2009]



Issues

However, the above examples just emphasise the need for the integrationof the two paradigms, without providing a coherent and uniformconceptual framework for both

Should we be content with the mere integration of technologies?

What about conceptual integrity?

Could we aim at a whole, coherent

uniform conceptual framework for MAS and EBS

?


Engineering MAS as Event-Based Systems

Outline



3 Conclusion


Engineering MAS as Event-Based Systems Essentials of Event-Based Systems

Outline



3 Conclusion



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

What is considered essential, or, fundamental by researchers andteachers often does not coincide

However, some shared ideas and terms can be pointed out to providefor a common ontology and terminology for event-based systems



Terminology for Event-Based Systems

Definition

According to [Fiege et al., 2002], 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 Models

Different event models can be supported by different sorts of notifications,e.g. [Fiege et al., 2002]

name/value pairs [Carzaniga et al., 2001]

objects [Eugster et al., 2001]

semi-structured data [Fiege et al., 2003]



Middleware and Events

At the middleware level, notifications may take the form of messages,or, of any specific form adopted / promoted by the middlewareservices

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

Event notification service

An event notification service, or event system for short, applies differenttechniques and data and filter models to distribute notifications betweenthe components of an event-based system [Fiege et al., 2002]



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



Issues in Event-Based Systems

Mechanisms [Fiege et al., 2002]

notification filteringnotification distribution

Software engineering

inversion of control [Haller and Odersky, 2006]coordination of events [Milicevic et al., 2013]


Engineering MAS as Event-Based Systems MAS as Event-Based Systems

Outline



3 Conclusion



Rethinking MAS Meta-Model

The MAS triad: agents, society, environment

agents are the autonomous computational entities encapsulating thedesigned (sub)goals for the MAS, which are expressed through theirown course of actions

environment captures the unpredictability of the MAS context, bymodelling the external resources and features that are relevant for theMAS, along with their change over time

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



Agents & Environment as Event Sources

From a SE viewpoint, agents and environment are the abstractionsrepresenting the only sources of events in a MAS

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

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



An Event-based View of MAS

MAS can be seen as event-based systems, where

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

environment models external events through dedicatedabstraction—thus capturing the dynamics of the unpredictable eventsexternal but relevant to MAS



Benefits of MAS as EBS

since agents encapsulate control along with the criteria for control –expressed in terms of high level abstractions such as beliefs, goals,intentions, plans – articulated events histories are modelled alongwith their motivations in MAS as EBS

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



Architectural Requirements for MAS as EBS

agent autonomy — boundary artefacts for agents

environment diversity — boundary artefacts for probes

As a resulting benefit, boundary artefacts can deal with diversity of allsorts of events, and translate them all according to a common generalevent model


Engineering MAS as Event-Based Systems MAS Coordination: An Event-driven View

Outline



3 Conclusion



An Event-based View of MAS as Interacting Systems

MAS can be seen as event-based systems, where

agents encapsulate internal events

environment models external events through dedicated abstraction

! social abstractions of some sort take care of dealing with interaction

agent-agent interactionagent-environment interactionenvironment-environment interactionand, any other more complex pattern of interaction

taking care of their mutual dependencies, by coordinating the manyresulting flows of events [Malone and Crowston, 1994]



Harnessing the Complexity of Interaction

An essential source of complexity for computational systems isinteraction [Wegner, 1997]

Coordination models work by constraining the space of interaction[Wegner, 1996]

So, in principle, coordination abstractions and technologies can helpharnessing the intricacies of interaction in the engineering of complexsoftware systems



The Nature of Coordination Models

According to [Ciancarini, 1996],

A coordination model provides a framework in which theinteraction of active and independent entities called agents canbe expressed

Coordination: a meta-model [Ciancarini, 1996]

The components of a coordinated system are

Coordination entities — the entities whose mutual interaction is ruled bythe model, also called the coordinables, or agents

Coordination media — the abstractions enabling and ruling interactionamong coordinables

Coordination laws — the rules governing the observable behaviour ofcoordinables, the behaviour coordination media, as well astheir interactions of any sort



Coordination as Constrained Interaction [Wegner, 1996]

Coordination models harness the complexity of interaction by discipliningthe space of admissible interactions [Omicini, 1999]

the coordination primitives provided by a coordination modelconstrain the possibile agent actions

the coordination media provided by a coordination model constrainthe possible targets of agent actions

Coordination models as constrainers of interaction

A coordination model constrains its coordinables (agents) to interact via alimited yet (possibly) expressive set of primitives acting on a class ofpre-defined media of coordination, whose computational behaviour definesthe laws of coordination



Event-Based Coordination

The potential of event-based coordination has been recognizedboth in academia and industry and there exists a considerableamount of work on event notification systems [Fiege et al., 2002]

a number of event-based middleware providing such services, such asJEDI [Cugola et al., 2001]

a number of event-based coordination models[Papadopoulos and Arbab, 1998, Viroli et al., 2002], technologies[Freeman et al., 1999], and formalisms[Omicini, 1999, Viroli and Ricci, 2002]

witness the role of event-based middleware in the engineering of complexdistributed systems, as well as the event-based nature of the most relevantcoordination models, such as tuple-based ones [Omicini, 1999]



Coordination in MAS

Given that

artefacts are the reactive abstractions in MAS [Omicini et al., 2008]

coordination artefacts are the social abstractions in charge ofmanaging dependencies [Malone and Crowston, 1994]

the social abstractions in charge of coordinating multiple event flowaccording to their mutual dependencies in MAS are the coordinationartefacts [Omicini et al., 2004]

Coordination models in MAS

The role of coordination models in MAS [Ciancarini et al., 2000] is toprovide event-driven coordination media as the coordination artefactsgoverning event coordination in MAS



Benefits of MAS Coordination as EBS

Since all events are uniformly represented through the same generalevent model – the same language for notifications –, coordinationartefacts can be used to deal with both social and situateddependencies, governing agent-agent, agent-environment,environment-environment interaction through the same set ofcoordination abstractions, languages, and mechanisms[Mariani and Omicini, 2014]

Coordination artefacts provide a specific, event-based computationalmodel for dealing with event observation, manipulation, andcoordination

Coordination artefacts encapsulate the logic for the coordination ofmultiple related flows of events, thus counterfeiting inversion ofcontrol


Engineering MAS as Event-Based Systems A Case Study in MAS Coordination as EBS: TuCSoN

Outline



3 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 [Omicini, 2002] 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 [Casadei and Omicini, 2009] are theboundary artefacts devoted to probes. Each probe isassigned to a transducer, which is specialised to handleevents from that probe, and to act on probes throughsituation operations. Transducers thus decouple in control,reference, space and time probes from tuple 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 [Omicini and Mariani, 2013]. Byadopting ReSpecT tuple centres, TuCSoN relies on (i) theReSpecT language to program coordination laws, and (ii)the ReSpecT situated event 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 changes in acommon 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 essence, TuCSoN seemingly provides both a model and a technology toengineer coordinated MAS as EBS


Conclusion

Outline



3 Conclusion


Conclusion

Summing Up

A unifying 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 and event-basedabstractions, languages, technologies, and methods

Interaction

is a key issue as far as system complexity is concerned

requires the availability of suitably-expressive event-drivencoordination models and middleware for a disciplined engineering ofcomplex MAS as EBS


References

References I

Aiello, F., Bellifemine, F. L., Fortino, G., Galzarano, S., and Gravina, R. (2011).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.

Armstrong, J., Virding, R., Wikstrom, C., and Williams, M. (1996).Concurrent Programming in Erlang.Prentice Hall International, 2nd edition.

Bellifemine, F. L., Caire, G., and Greenwood, D. (2007).Developing Multi-Agent Systems with JADE.Wiley.

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

Carzaniga, A., Rosenblum, D. S., and Wolf, A. L. (2001).Design and evaluation of a wide-area event notification service.ACM Transactions on Computer Systems, 19(3):332–383.


References

References II

Casadei, M. and Omicini, A. (2009).Situated tuple centres in ReSpecT.In Shin, S. Y., Ossowski, S., Menezes, R., and Viroli, M., editors, 24th Annual ACMSymposium on Applied Computing (SAC 2009), volume III, pages 1361–1368, Honolulu,Hawai’i, USA. ACM.

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

Ciancarini, P., Omicini, A., and Zambonelli, F. (2000).Multiagent system engineering: The coordination viewpoint.In Jennings, N. R. and Lesperance, Y., editors, Intelligent Agents VI. Agent Theories,Architectures, and Languages, volume 1757 of LNAI, pages 250–259. Springer.6th International Workshop (ATAL’99), Orlando, FL, USA, 15–17 July 1999. Proceedings.

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


References

References III

Di Stefano, A. and Santoro, C. (2005).Supporting agent development in Erlang through the eXAT platform.In Unland, R., Calisti, M., and Klusch, M., editors, Software Agent-Based Applications,Platforms and Development Kits, Whitestein Series in Software Agent Technologies, pages47–71. Birkhauser Basel.

Eugster, P. T., Guerraoui, R., and Damm, C. H. (2001).On objects and events.ACM SIGPLAN Notices, 36(11):254–269.16th ACM SIGPLAN Conference on Object-oriented Programming, Systems, Languages,and Applications (OOPSLA’01), Tampa Bay, FL, USA. Proceedings.

Fiege, L., Gartner, F. C., Kasten, O., and Zeidler, A. (2003).Supporting mobility in content-based publish/subscribe middleware.In Middleware 2003, Lecture Notes in Computer Science, pages 103–122. Springer BerlinHeidelberg.ACM/IFIP/USENIX International Middleware Conference Rio de Janeiro, Brazil, June16–20, 2003 Proceedings.

Fiege, L., Muhl, G., and Gartner, F. C. (2002).Modular event-based systems.The Knowledge Engineering Review, 17(4):359–388.


References

References IV

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

Freeman, E., Hupfer, S., and Arnold, K. (1999).JavaSpaces Principles, Patterns, and Practice: Principles, Patterns and Practices.The Jini Technology Series. Addison-Wesley Longman.

Graesser, S. F. A. (1996).Is it an agent, or just a program?: A taxonomy for autonomous agents.In Muller, J. P., Wooldridge, M. J., and Jennings, N. R., editors, Intelligent Agents IIIAgent Theories, Architectures, and Languages: ECAI’96 Workshop (ATAL) Budapest,Hungary, August 12–13, 1996 Proceedings, volume 1193 of Lecture Notes In ComputerScience, pages 21–35. Springer.

Haller, P. and Odersky, M. (2006).Event-based programming without inversion of control.In Lightfoot, D. E. and Szyperski, C., editors, Modular Programming Languages. 7th JointModular Languages Conference, JMLC 2006 Oxford, UK, September 13-15, 2006Proceedings, number 1 in Lecture Notes in Computer Science, pages 4–22, Oxford, UK.Springer Berlin Heidelberg.


References

References V

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

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

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

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


References

References VI

Mariani, S. and Omicini, A. (2014).Coordination in situated systems: Engineering mas environment in TuCSoN.In Fortino, G., Di Fatta, G., Li, W., Ochoa, S., Cuzzocrea, A., and Pathan, M., editors,Internet and Distributed Computing Systems, volume 8729 of Lecture Notes in ComputerScience, pages 99–110. Springer International Publishing.7th International Conference on Internet and Distributed Computing Systems (IDCS2014), Calabria, Italy, 22-24 September 2014, Proceedings.

Milicevic, A., Jackson, D., Gligoric, M., and Marinov, D. (2013).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. ACM Press.

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


References

References VII

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

Omicini, A. (2002).Towards a notion of agent coordination context.In Marinescu, D. C. and Lee, C., editors, Process Coordination and Ubiquitous Computing,chapter 12, pages 187–200. CRC Press, Boca Raton, FL, USA.

Omicini, A. and Mariani, S. (2013).Coordination for situated MAS: Towards an event-driven architecture.In Moldt, D. and Rolke, H., editors, International Workshop on Petri Nets and SoftwareEngineering (PNSE’13), volume 989 of CEUR Workshop Proceedings, pages 17–22. SunSITE Central Europe, RWTH Aachen University.


References

References VIII

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

Omicini, A., Ricci, A., Viroli, M., Castelfranchi, C., and Tummolini, L. (2004).Coordination artifacts: Environment-based coordination for intelligent agents.In Jennings, N. R., Sierra, C., Sonenberg, L., and Tambe, M., editors, 3rd internationalJoint Conference on Autonomous Agents and Multiagent Systems (AAMAS 2004),volume 1, pages 286–293, New York, USA. ACM.

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

Papadopoulos, G. A. and Arbab, F. (1998).Coordination models and languages.In Zelkowitz, M. V., editor, The Engineering of Large Systems, volume 46 of Advances inComputers, pages 329–400. Academic Press.


References

References IX

Rao, A. S. and Georgeff, M. P. (1991).Modeling rational agents within a BDI architecture.In Allen, J. F., Fikes, R., and Sandewall, E., editors, 2nd International Conference onPrinciples of Knowledge Representation and Reasoning (KR’91), pages 473–484, SanMateo, CA. Morgan Kaufmann Publishers.

Viroli, M., Omicini, A., and Ricci, A. (2002).On the expressiveness of event-based coordination media.In Arabnia, H. R., editor, International Conference on Parallel and Distributed ProcessingTechniques and Applications (PDPTA’02), volume III, pages 1414–1420, Las Vegas, NV,USA. CSREA Press.

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


References

References X

Wegner, P. (1996).Coordination as constrained interaction.In Ciancarini, P. and Hankin, C., 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. SpringerBerlin Heidelberg.

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

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

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


References

References XI

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


Extras

URLs

Slides

On APICe

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

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

event-based-vs-multi-agent-systems-towards-a-unified-conceptual-framework-

preliminary-notes


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

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




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

Preliminary Notes

Andrea Omicini

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

Short Course @ WOA 2014 Mini-schoolWorkshop nazionale “Dagli Oggetti agli Agenti”

Universita di Catania, Italy25 Settembre 2014
