Agent-Oriented Programming for Developing Modern Software Systems

Transcription

1 Agent-Oriented Programming for Developing Modern Software Systems Andrea Santi 1 a.santi@unibo.it Alma Mater Studiorum Università di Bologna Ph.D in Electronics, Computer Science and Telecommunications 1 - XXV Ciclo Second Year Ending Seminar 21/10/2011 A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

2 Outline Introduction 1 Introduction Objectives Method 2 Multi-Agent Oriented Programming The JaCa platform The JaCaMo Framework Weaknesses and Limitations 3 The simpal Project Background Metaphor Programming Model 4 Conclusions A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

3 Outline Introduction 1 Introduction Objectives Method 2 Multi-Agent Oriented Programming The JaCa platform The JaCaMo Framework Weaknesses and Limitations 3 The simpal Project Background Metaphor Programming Model 4 Conclusions A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

4 Introduction Developing Modern Software Systems: Challenges Developing modern software systems is an hard task Almost every modern application has to deal with issues such as Concurrency Distribution Decentralisation of control... The free lunch is over [Sutter and Larus, 2005] Towards a paradigm change in computer science [Zambonelli, 2004] A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

5 Introduction How to Program Such Systems? It is now important to introduce higher-level programming abstractions [Sutter and Larus, 2005] Easing the development of modern software systems Like OO abstractions help(ed) build large component-based programs Proliferation of new programming languages/frameworks aiming at ease this task Rooted on not so mainstream (yet) programming models The Actor [Hewitt et al., 1973] model one is a main example Scala [Wampler and Payne, 2009], Groovy [König and Glover, 2007], Clojure [Hickey, 2011], etc. A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

6 Introduction Agent-Oriented Programming (AOP):the Current Situation The idea of Agent-Oriented Programming is not new The first paper about AOP is dated 1993 [Shoham, 1993].... and since then many APLs and platforms have been proposed [Bordini et al., 2005, Bordini et al., 2009, Bordini et al., 2006] Main acceptations are the (D)AI contexts Agents as a special purpose technique to build intelligent systems No significant impacts on mainstream research in programming languages and software development Emphasis put on theoretical issues No focus on principles of general-purpose computer programming A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

7 Our Perspective Introduction AOP can be exploited for programming modern software systems in general [Ricci and Santi, 2011a] Extending object/function-oriented programming Thanks to an higher-level of abstraction Tackling main challenges of modern software development Concurrency Decentralization of control Autonomy Adaptivity... A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

8 Outline Introduction Objectives 1 Introduction Objectives Method 2 Multi-Agent Oriented Programming The JaCa platform The JaCaMo Framework Weaknesses and Limitations 3 The simpal Project Background Metaphor Programming Model 4 Conclusions A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

9 Introduction Objectives Objectives Background Objective Explore AOP as a high-level general purpose programming paradigm providing a set of abstractions meant to simplify the design of concurrent, distributed, reactive/interactive programs In particular we are interested in Identify the essential concepts and features of the paradigm Focussing on principles of general-purpose computer programming Inject/re-frame modern programming languages features in AOP Typing, reuse, inheritance, etc. AOP s impact on the set of programming support tools IDE, debuggers, profilers, etc. A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

10 Outline Introduction Method 1 Introduction Objectives Method 2 Multi-Agent Oriented Programming The JaCa platform The JaCaMo Framework Weaknesses and Limitations 3 The simpal Project Background Metaphor Programming Model 4 Conclusions A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

11 Introduction Method How Achieve the Stated Objectives? A container project named simpal [Ricci and Santi, 2011b] Concerning the design and development of A new generation agent-oriented programming language (i.e. simpal) Related platforms / infrastructures / tools Starting from the construction of a solid background Studying state of the art of Agent architectures Agent programming languages, programming models Making contributions in the context of Multi-Agent Oriented Programming A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

12 Outline Multi-Agent Oriented Programming 1 Introduction Objectives Method 2 Multi-Agent Oriented Programming The JaCa platform The JaCaMo Framework Weaknesses and Limitations 3 The simpal Project Background Metaphor Programming Model 4 Conclusions A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

13 Outline Multi-Agent Oriented Programming 1 Introduction Objectives Method 2 Multi-Agent Oriented Programming The JaCa platform The JaCaMo Framework Weaknesses and Limitations 3 The simpal Project Background Metaphor Programming Model 4 Conclusions A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

14 Multi-Agent Oriented Programming Objectives Investigating the adoption of state of the art agent-oriented technologies for programming Multi-Agent System (MAS) Focus on Agent-Oriented Programming Languages (APLs) Agent-based frameworks Aiming at Construct a background knowledge on state of the art Agent architectures APLs, programming models Immediately applying agent-based technologies in relevant domains Improving current agent-based technologies A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

15 Multi-Agent Oriented Programming The Belief Desire Intention (BDI) Agent Model Introduced by Rao and Georgeff [Rao and Georgeff, 1995] Reference model for the development of rational/inteligent agents The BDI model promote agent designed rooted upon: Belief knowledge the agent has about the world and other agents Desire all the possible objectives the agent might like to accomplish Intention the set of objectives the agent has decided to work towards A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

16 Multi-Agent Oriented Programming Agents Control Architecture clock events Event queue (sensor) sense stage Agent State Agent Program (plans) plan stage actions Agent Ongoing Tasks Action buffer (actuator) act stage A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

17 Outline Multi-Agent Oriented Programming The JaCa platform 1 Introduction Objectives Method 2 Multi-Agent Oriented Programming The JaCa platform The JaCaMo Framework Weaknesses and Limitations 3 The simpal Project Background Metaphor Programming Model 4 Conclusions A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

18 Multi-Agent Oriented Programming The JaCa platform The JaCa platform Our base reference platform/infrastructure For this macro-research line Born from the synergistic integration of Jason [Bordini et al., 2007] A BDI-based agent-oriented programming language CArtAgO [Ricci et al., 2009] A framework for building agents working environments Applied in several application contexts Mobile [Santi et al., 2011] SOA/WS [Piunti et al., 2009] Ambient-Intelligence [Sorici et al., 2011] A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

19 Multi-Agent Oriented Programming The JaCa platform JaCa-Android in Action: SMS Notification Manager 1/2 Figure: Two different kinds of SMS notifications: (a) notification performed using the standard Android status bar, and (b) notification performed using the ViewerArtifact. A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

20 Multi-Agent Oriented Programming The JaCa platform JaCa-Android in Action: SMS Notification Manager 2/2 00!init !init 03 <- focus("smsartifact"); 04 focus("notificationmanager"); 05 focus("viewerartifact") sms_received(source, Message) 08 : not (state("running") & session(source)) 09 <- shownotification("jaca.android:drawable/notification", 10 Source, Message, "jaca.android.sms.smsviewer", Id); 11 append(source, Message) sms_received(source, Message) : state("running") & session(source) 14 <- append(source, Message). A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

21 Outline Multi-Agent Oriented Programming The JaCaMo Framework 1 Introduction Objectives Method 2 Multi-Agent Oriented Programming The JaCa platform The JaCaMo Framework Weaknesses and Limitations 3 The simpal Project Background Metaphor Programming Model 4 Conclusions A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

22 Multi-Agent Oriented Programming The JaCaMo Framework The JaCaMo Framework A comprehensive multi-agent oriented programming approach [Boissier et al., 2012] Taking into account three different programming dimensions Agent, environment, and organization dimensions Built upon the synergistic integration of Jason [Bordini et al., 2007] CArtAgO [Ricci et al., 2009] M oise [Hübner et al., 2007] Defining semantic links among concepts of the different programming dimensions at the meta-model and programming levels Providing a uniform programming model for MAS programming A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

23 Outline Multi-Agent Oriented Programming Weaknesses and Limitations 1 Introduction Objectives Method 2 Multi-Agent Oriented Programming The JaCa platform The JaCaMo Framework Weaknesses and Limitations 3 The simpal Project Background Metaphor Programming Model 4 Conclusions A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

24 Multi-Agent Oriented Programming Weaknesses and Limitations Weaknesses and Limitations Weak support for modularise active behaviour A main issue: absence of hierarchical structure for plans Still no explicit notion of type Neither for agents nor for artifacts Lack of a seamless integration with object/functional-oriented layer We are currently using a custom library A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

25 Outline The simpal Project 1 Introduction Objectives Method 2 Multi-Agent Oriented Programming The JaCa platform The JaCaMo Framework Weaknesses and Limitations 3 The simpal Project Background Metaphor Programming Model 4 Conclusions A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

26 Outline The simpal Project Background Metaphor 1 Introduction Objectives Method 2 Multi-Agent Oriented Programming The JaCa platform The JaCaMo Framework Weaknesses and Limitations 3 The simpal Project Background Metaphor Programming Model 4 Conclusions A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

27 The simpal Project Background Metaphor Abstractions and Metaphors for Computer Programming OOP metaphor: real-world objects Objects have properties and states Objects can communicate and respond to communications Actors metaphor: anthropomorphic inspiration A set of light-weight processes (actors)....interacting only via asynchronous message-passing Our Agent-Oriented Programming metaphor Anthropomorphic inspiration too A&A meta-model: mimicking human cooperative work environments from Activity Theory [Nardi, 1996] and Distributed Cognition BDI Agent Model [Rao and Georgeff, 1995] A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

28 The simpal Project Background Metaphor Background Metaphor: an Abstract Representation A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

29 Outline The simpal Project Programming Model 1 Introduction Objectives Method 2 Multi-Agent Oriented Programming The JaCa platform The JaCaMo Framework Weaknesses and Limitations 3 The simpal Project Background Metaphor Programming Model 4 Conclusions A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

30 Agents The simpal Project Programming Model Autonomous, state-full task- and event-driven entity Based on a BDI architecture Creating and co-using artifacts for supporting their activities besides direct communication Autonomous behaviour structured in terms of Role The set of tasks an agent must be able to do inside an organisation Tasks Unit of work that has to be executed Defining what have to be executed Plans Actions to be performed for achieving a task Defining how to execute a task Agent Script Collection of concrete plans for playing a role A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

31 Working Environments The simpal Project Programming Model Structured in terms of multiple (distributed) workspace Provide agents the tools and resource they need by means of artifacts Artifacts are non-autonomous function-oriented entities Controllable and observable by agents Functionalities provided by artifact operations State exposed by means of observable properties AGENTS ORGANISATION ARTIFACTS use observe communicate with WORKSPACE A ARTIFACTS WORKSPACE B A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

32 An Agent Role Example The simpal Project Programming Model r o l e MyRole e x t e n d s B a s i c R o l e { t a s k MyTask { aparam : i n t ; // p r i m i t i v e type mylist : L i s t <S t r i n g >; // an o b j e c t mycountertool : C o u n t e r I n t e r f a c e ; // an a r t i f a c t } t a s k AnotherTask {... } } Figure: An example of role definition in simpal A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

33 Agent Script The simpal Project Programming Model Defines how play one or more roles by means of concrete plans s c r i p t MyScript implements MyRole { s t : S t r i n g ; mytool : MyTool ; p l a n MyPlanA t a s k : MyTask c o n t e x t : ( aparam > 0 && s t. e q u a l s ( t e s t ) ) {... } p l a n MyPlanB t a s k : MyTask c o n t e x t : aparam <= 0 u s i n g : mycountertool, mytool {... } } p l a n MyPlanC t a s k : AnotherTask {... }... Figure: An example of agent script definition in simpal A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

34 The simpal Project Programming Model Mixed Reactive and Proactive Behavior A plan body is composed by a set of action rules Event : Action [label] Easily mixing of reactive/proactive behavihor Combining Event and attributes p l a n MixedPlan t a s k : MyTask { mybel : S t r i n g ; mytool >doaction1 ( ) ; mytool >doaction2 ( ) ; mytool >doaction3 ( ) ;... +c r i t i c a l c o n d i t i o n : mybel == s t a t e 1 => d o R e p a i r A c t i o n 1 ( ) +c r i t i c a l c o n d i t i o n : mybel == s t a t e 2 => d o R e p a i r A c t i o n 2 ( ) +n e w i n f o : t r u e => p r i n t l n ( New i n f o r e t r i e v e d + n e w i n f o ) } Figure: An example of mixed reactive and proactive behavior in simpal A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

35 The simpal Project Programming Model simpal Type System Agent Side Agent type role(s) it implements Set of tasks the agent is able to perform Agent role: the contract identifying a certain set of tasks Analogous to the interface for OOP Basic unit for agent sub-typing/hierarchies relations An agent can play/implement multiple roles Artifact Side Artifact type its artifact model (usage interface), including Operations The set of its observable properties Sub-typing and inheritance rooted on the notion of Artifact type A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

36 The simpal Project Programming Model Inheritance, Polymorphism and Error Checking Inheritance We can define inheritance relations for what concerns Agent roles/scripts Artifact models and concrete implementations Polymorphism We are able to support polymorphism at different levels Role level Agents implementing the same role in different ways Agent script level Tasks performed in different ways on the base of contextual conditions Artifact and artifact model level Error Checking We are able to support error checking at compile time Agents implementation compliant to the roles it implements Artifact definition must adhere to its model specification... A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

37 The simpal Project Programming Model The simpal Ecosystem MyApp1 org ws1 ws2 ws3 Application logical view MyApp1 MyApp2 MyApp1 MyApp1 Application-specific structures simpal OS (JVM based) simpal OS (JVM based) simpal OS (JVM based) Runtime Infrastructure OS OS OS agent processor artifact processor agent artifact A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

38 Outline Conclusions 1 Introduction Objectives Method 2 Multi-Agent Oriented Programming The JaCa platform The JaCaMo Framework Weaknesses and Limitations 3 The simpal Project Background Metaphor Programming Model 4 Conclusions A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

39 Future Work Conclusions Main efforts to be put on finalizing/improving the simpal project From the language perspective Shape the basic set of features of the language Finalize and formalize the type system From the simpal platform perspective IDEs, debuggers, profilers, etc. Finalize the work on the distributed Runtime Infrastructure Test simpal effectiveness for developing modern software systems In relevant application domains Pointing out experienced outcomes, benefits and limitations Continue the exploration with the JaCaMo framework As a reference multi-agent oriented programming approach for developing MAS A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

40 Conclusions AGERE! Programming Systems, Languages, and Applications based on Actors, Agents, and Decentralized Control International workshop we organised to discuss our ideas in practice Held at the ACM conference SPLASH 2011 Aiming at investigating Actors and Agents as post-oo programming paradigm A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

41 Conclusions Bibliography I Boissier, O., Bordini, R., Hübner, J. F., Ricci, A., and Santi, A. (2012). Multi-agent oriented programming with jacamo. Science of Computer Programming. Special Issue on Agent-oriented Design methods and Programming Techniques for Distributed Computing in Dynamic and Complex Environments. Bordini, R., Braubach, L., Dastani, M., Seghrouchni, A., Gomez-Sanz, J., Leite, J., O Hare, G., Pokahr, A., and Ricci, A. (2006). A survey of programming languages and platforms for multi-agent systems. In Informatica 30, pages A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

42 Bibliography II Conclusions Bordini, R., Dastani, M., Dix, J., and El Fallah Seghrouchni, A., editors (2005). Multi-Agent Programming Languages, Platforms and Applications - Volume 1, volume 15 of Multiagent Systems, Artificial Societies, and Simulated Organizations. Springer. Bordini, R., Dastani, M., Dix, J., and El Fallah Seghrouchni, A., editors (2009). Multi-Agent Programming Languages, Platforms and Applications - Volume 2, Multiagent Systems, Artificial Societies, and Simulated Organizations. Springer. Bordini, R., Hübner, J., and Wooldridge, M. (2007). Programming Multi-Agent Systems in AgentSpeak Using Jason. John Wiley & Sons, Ltd. A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

43 Bibliography III Conclusions Hewitt, C., Bishop, P., and Steiger, R. (1973). A universal modular actor formalism for artificial intelligence. In Proceedings of the 3rd international joint conference on Artificial intelligence, pages Morgan Kaufmann Publishers Inc. Hickey, R. (2011). Agents and asynchronous actions (in clojure). Online document, available at: Last Retrieved: Sept. 1, Hübner, J. F., Sichman, J. S., and Boissier, O. (2007). Developing Organised Multi-Agent Systems Using the MOISE+ Model: Programming Issues at the System and Agent Levels. Agent-Oriented Software Engineering, 1(3/4): A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

44 Bibliography IV Conclusions König, D. and Glover, A. (2007). Groovy in action. Manning Pubs Co Series. Manning. Nardi, B. (1996). Activity theory and human-computer interaction. and consciousness: Activity theory and human-computer interaction, pages Piunti, M., Santi, A., and Ricci, A. (2009). Programming SOA/WS systems with BDI agents and artifact-based environments. In Proceedings of MALLOW-AWESOME Joint Workshop on Agents, Web Services and Ontologies, Integrated Methodologies. A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

45 Conclusions Bibliography V Rao, A. S. and Georgeff, M. P. (1995). BDI Agents: From Theory to Practice. In First International Conference on Multi Agent Systems (ICMAS95). Resnick, M. (1994). Turtles, Termites and Traffic Jams. Explorations in Massively Parallel Microworlds. MIT Press. Ricci, A., Piunti, M., Viroli, M., and Omicini, A. (2009). Environment programming in CArtAgO. In Bordini, R. H., Dastani, M., Dix, J., and El Fallah-Seghrouchni, A., editors, Multi-Agent Programming: Languages, Platforms and Applications, Vol. 2, pages Springer. A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

46 Bibliography VI Conclusions Ricci, A. and Santi, A. (2011a). Agent-oriented computing: Agents as a paradigm for computer programming and software development. In Proc. of the 3rd Int. Conf. on Future Computational Technologies and Applications (Future Computing 11), Rome, Italy. IARIA. Ricci, A. and Santi, A. (2011b). Designing a general-purpose programming language based on agent-oriented abstractions: The simpal project. In Proceedings of First International Workshop on Programming Systems, Languages, and Applications based on Actors, Agents, and Decentralized Control, AGERE! A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

47 Bibliography VII Conclusions Santi, A., Guidi, M., and Ricci, A. (2011). JaCa-Android: An agent-based platform for building smart mobile applications. In Dastani, M., El Fallah Seghrouchni, A., Hübner, J., and Leite, J., editors, Languages, Methodologies, and Development Tools for Multi-Agent Systems, volume 6822 of LNAI, pages Springer. Shoham, Y. (1993). Agent-oriented programming. Artificial Intelligence, 60(1): Sorici, A., Santi, A., Picard, G., and Boissier, O. (2011). An adaptive jacamo-based ambient intelligence application. In PAAMS. A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

48 Bibliography VIII Conclusions Sutter, H. and Larus, J. (2005). Software and the concurrency revolution. ACM Queue: Tomorrow s Computing Today, 3(7): Wampler, D. and Payne, A. (2009). Programming Scala. O Reilly Series. O Reilly Media. Zambonelli, F. (2004). Towards a paradigm change in computer science and software engineering: a synthesis. The Knowledge Engineering Review, 18(04): A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

49 Conclusions Considerations Decentralized mindset in programming [Resnick, 1994] thanks to Encapsulation of control (into agents) An interaction dimension rooted on two interaction typologies Asynchronous message passing Environment-mediated interactions An high-level rationale to structure autonomous behaviour Through the notion of roles, tasks and plans Integration of pro-active and reactive behaviour Thanks to the agent control architecture Avoidance of everything is an X perspective Agents to model active parts, artifacts for passive ones A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

50 Conclusions Inheritance: Notable Cases R1 can be defined as an extension of role R Inheriting all tasks defined in R Adding/specializing tasks defined in R Ag1 can be defined as an extension of an agent script Ag Inheriting all plans defined in Ag Adding further plans either to achieve Task defined in the role implemented by Ag New tasks defined in a role implemented by Ag1 (and not by Ag) Similar inheritance relations can be defined also for the environment dimension A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

51 Conclusions Error Checking and Polymorphism: Notable Cases Error Checking An agent script must define at least one plan for each task defined in the role it implements Artifact definition must adhere to its model specification Duplicated constructs checks... Polymorphism The same task can be performed by different agents implementing the same role in different ways Depending on the scripts that they are using Task assigned to an agent can be performed in a different way Depending on current contextual conditions Artifacts can provide different implementations for the same model A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52

52 Conclusions Integration with Object-Oriented/Functional programming Agent and environment are coarse grain abstractions Defining the high-level organization of the system Not useful for defining Data structures Computational parts manipulating them OOP/Functional languages to define data structures and functions simpal integration with OO programming languages is quite straightforward Thanks to a clear separation between the agents/environment layer and the objects/functions one A. Santi (DEIS) XXV Ciclo Second Year Ending Seminar 21/10/ / 52