1.1 Survey s scope and motivation
|
|
- Aron Todd
- 8 years ago
- Views:
Transcription
1 Evaluation of Agent Oriented Software Engineering Main Approaches Salaheddin J. Juneidi, George A. Vouros Department of Information and Communication Systems Engineering School of Sciences University of the Aegean Abstract Agent Oriented Software Engineering (AOSE) is occupying major domain in research field, motivated by at least two main fields in computer science, Software Engineering (SE), and Artificial Intelligence (AI) more precisely Distributed Artificial Intelligent (DAI) presented as Agent Base Computing. Even though their wasn t a concrete relation between these two main fields in the past years, SE and agent base computing start to interact seeking an appropriate methodology and modeling technique for modeling and applying software agents into software development process. This article offers gaudiness and evaluation for the main approaches toward AOSE methodologies and modeling techniques for analysis and design phases and helps the researchers and practitioners to have a general and overall view of different approaches with judgment procedure 1.0 Introduction Software engineering is crucial to the industrial and commercial applications, as today's and tomorrow's standard software systems are required to operate in increasingly complex distributed, large, open, dynamic, unpredictable, heterogeneous, and highly interactive application environments. Agent based computing appears to be very promising and natural to build these systems in terms of agent and multiagent technology. Thus agent orientation can serve as a useful paradigm in software engineering which has been referred to as agent-oriented software engineering (AOSE). The core phases of software engineering are analysis and design phases, these two phases are mostly affected with evolution of software engineering paradigm. We attested a massive development in SE when object oriented programming came up, as a result UML Unified Modelling Language was establish to represent not only system analysis and design but also system requirements specifications and functionality. Agent Oriented Software Engineering (AOSE) is being described as new paradigm [1] for the research field of Software Engineering, consequently robust methodologies and tools have to be developed to model software agents into software developing process. What is an Agent or at least as much as we concerns about software agent or an intelligent agent, it is a piece of autonomous software [2] or an autonomous entity that can interact with its environment [3]. Common classification scheme of agent has some properties [4] (autonomy) agents have their own will, (social ability) able to interact with environment or other agents,(pro-activity) they take initiative, (adaptive/reactive) responds to a stimulus, (mobility)can move around in environment from platform to other (characteristic) own personality and emotional state and beliefs(learning) changes its behaviour based on its previous experience(intelligence) has beliefs, goals, assumptions and plans, interact with other agents using symbolic language. 1.1 Survey s scope and motivation Developments in agent-based computing and software engineering have revealed a significant potential and urgent demand for a close interaction among these disciplines. This article provides guideness and judgment for both researchers and practitioners in navigating and investigating through, and becoming acquainted with available methodologies on AOSE. Creating such a guideness and judgment challenging process for four major reasons: AOSE represents a very young field with overwhelming and some times overlapping methodologies and modeling techniques. Final and complete methodology for this matter has not been realized yet. AOSE constitutes an interdisciplinary field from different fields, that means the related work in boarder disciplinary fields (software engineering and agent-based computing ) is quite enough to affect the main stream that runs AOSE research. AOSE research field evolves very rapidly. For that reason after one year for example this article can not be guaranteed to provide pointers to all work AOSE. The article categorizes each work according to its main idea and orientation toward applying agency properties in software system. Before Performing evaluation and judgment procedure, we must establish and agree on appropriate evaluation criteria, which joins evaluation criteria for both software engineering and agent base computing. Well, it is understood that none of the evaluated approaches has been presented in a final stage, though giving such judgment can anticipate the weaknesses and the strength for future enhancements. The article depicts three different major approaches toward that support at least analysis and design phases of software development process. These approaches represented in 1
2 methodologies and modeling techniques, concluded in three major categories: Agent and Multiagent Oriented Methodologies (AOM) Approaches based on Object-Oriented Methodologies. Extending of Object -Oriented modeling techniques (UML) into AUML This article doesn t go through the details of the presented methodologies or modeling technique, each of which been referenced for further interest. In the case of the first two approaches, there are a quite number of proposed methodologies and modeling techniques, a selection process for the most prominent methodology is applied to be identified for discussion and evaluation. The selection procedure carried out on the most known publishing internet locations and digital libraries within the past ten years, taking percentage for publishing frequency for each, with error factor 1.5 %. This article is structured as follows. Section 2 discusses the main approaches of AOSE, starts from section 2.1 Agent and Multiagent Oriented Methodologies (AOM) and according to the publishing frequency, Gaia [5] is chosen for evaluation. Section 2.2 MaSE [6] is selected for evaluation on the behalf of the second approach based on Object-Oriented Methodologies. Section 2.3 discusses the proposed extensions in UML diagrams to represent software agents. Section 3 establishes evaluation criteria for AOSE with aspects software engineering and agency characteristics. Finally, Section 4 conducts an evaluation process according to setup criteria for the selected methodologies and modeling technique. 2.0 Main approaches for AOSE AOSE must have the ability to model agent component into software, as mentioned in survey s scope section, three main approaches propose analysis and design phases, that include assumption toward broad engineering techniques in AOSE, to fit any kind of software entities (agents and non-agents), each approach has its own independent view of AOS, a special purpose and tailor methodologies for specific applications are not counted as AOSE methodology. 2.1 Agent and Multiagent Oriented Methodologies (AOM) This approach doesn t explicitly expressed as a Software Engineering for a software that merge agents entities within, but proposed as a methodology for building an agent oriented software system with its main phases analysis and design, this approach incorporate a revolutionary attitude on classical software engineering, and specially the most resent Object Oriented Software Engineering (OOSE), and argue that OOSE is not adequate to model AOSE, consequently, it has a distinct view of AOS that concentrates on Multi Agent System ( MAS) Modelling. Gives emphasis to agentify software entities, Agentify is an expression used to turn software components agents and non-agents into an agent entity that interact and performer one or more roles into MAS. Because of the great interest in using (Multi Agent System) MAS in a wide variety of applications in recent years, agent oriented methodologies and related modelling techniques have become a priority for the development of large scale agent-base system [7], although recent years have witnessed a great number of theoretical and practical projects in the field of MAS, the development of such system still poses many challenges and remain open field, the main challenge is coordination [8] between people working on this field, some taking a bottom-up view ( bases on goals and roles [9]) other going top-down view ( starting from hierarchical assignments of responsibilities and shared ontology s used in human organizations [10]). Another problem is the lack of standardization in MAS platform and environment. What successful MAS technology needs, among other things, is a rigorous methodology covering the various phases of MAS development process, the following are among other methodologies for MAS modelling as an approach of AOSE: Gaia ( Generic Architecture for Information Availability ) [5]. This is a methodology that distinguishes between analysis and design phases and associates deferent models with these two phases. Gaia focuses on organizational aspects in terms of concepts such as roles, interactions, and acquaintances. Within this article a detailed discussion for Gaia coming next. CoMoMAS [11] focuses on knowledge engineering issues arising in multiagent contexts, proposes also an extension to CommonKADS for MAS. It has a very interesting extension to(cooperation Modeling Language) CML for MAS and a good redefinition of the expertise model. It also defines a new model for cooperation MAS-CommonKADS (Multi-Agent System CommonKADS") [12]. This is another extension of CommonKADS that supports analysis and design of agentoriented systems. MAS-CommonKADS adds objectoriented methods such as the Object Modelling Technique (OMT), Object Oriented Software Engineering (OOSE) and Responsibility Driven Design (RDD) as well as protocol engineering methods such as the Specification and Description Language (SDL) and Message Sequence Charts (MSCs). SODA ( Societies in Open and Distributed Agent spaces ) [13]. This is another method that concentrates on the social (inter-agent) aspects of agent systems and that employs the concept of coordination models Cassiopeia [14]. This is a design method that distinguishes three levels of behavior -elementary, relational, and organizational - and aims at capturing both structural and dynamic aspects of the target system. Aalaadin [15]. This is a general framework that has its focus on the organizational level of multi-agent systems and is built on the three core concepts of agents, groups, and roles. ROADMAP [16][17], which is a modification on Gaia for complex and open and large-scale system by introducing explicit knowledge based models and an interaction model based on UML interaction diagrams. 2
3 Methodology occurency percentage Figure 1: Publishing percentage of each method in AOM approach Percentage Gaia CoMoMAS MAS- CommonKADS SODA Cassiopeia Aalaadin ROADMAP DESIRE KADS with ZEUS Others Methods DESIRE [18] is a formal framework for multi-agent modeling, which mainly consists of agent and expertise models. It could be suitable for specifying the design and implementation after the analysis phase. KADS with ZEUS [19] to develop Multi-Agent for Electronic Commerce applications. Figure 1, displays that Gaia occupies the first position in terms of publications and research interests, Gaia presented by M. Wooldridge, N. Jennings, and D. Kinny [8]. 2.2 Approaches based on Object-Oriented Methodologies Unlike the upper approach, this approach provides an engineering process based on objectify the software system components, that models agent and non-agent components with same level of abstraction, the assumption is that an agent entity is basically an object that capable to perform a task, in other words, each agent component is a special form of object that can do some thing. There are several approaches to develop an agent-oriented software systems that as their starting point. Prototypical examples of such approaches are MaSE (Multiagent Systems Engineering") [20]. This method covers design and initial implementation through two languages called AgML (Agent Modeling Language") and AgDL (Agent Definition Language) and builds upon OMT and UML. KGR [21]. This is a design and specification method for a particular class of agents, namely, BDI agents [22]. KGR extends the object modeling technique (OMT) and considers two viewpoints { external and internal { of agent systems. MASSIVE (MultiAgent Systems Iterative View Engineering") [23]. This method covers analysis, design and code generation, and combines standard software engineering techniques such as multi-view modeling, round-trip engineering, and iterative enhancement. AOAD (Agent-Oriented Analysis and Design") [24]. This analysis and design method proposes the use of extended class responsibility cards (CRCs) and the use of both the Object Modelling Technique (OMT) and the Responsibility Driven Design (RDD) method known from object-oriented development MASB (Multi-Agent Scenario-Based") [25]. MASB is an analysis and design method that covers issues of both objects and agents via behavior diagrams, data models, transition diagrams, and object Figure 2, displays that MaSE methodology have the first position in term of publication and research interests. 2.3 Extending of Object - Oriented modeling techniques This AOSE approach give emphasis on extending modeling techniques developed for Object Oriented software engineering, specifically Unified Modeling Language (UML) to be extended for the next generation of Agent Oriented software engineering (AUML). Presented by J. Odell, B. Bauer, J. Muller, [26,27]. UML has wide acceptance for representation of artificats in object-oriented software. Extending UML modeling techniques has recently increasingly gains interests in the research field, as a result, cooperation has been established between the Foundation of Intelligent Physical Agents (FIPA ) and the Object Management Group (OMG ). For extending UML into AUML. This approach doesn t suggest pre-assumption toward agent and non-agent software s entities. but as UML is presented as the most dominant modeling technique for Object Oriented Software Engineering (OOSE), it argues that AOSE is a natural evolution of its ancestor OOSE. Compassing software agents characteristics, calls for extending UML into Agent UML... 3
4 Methodology occurrency persentage 80 Figure 2: Publishing percentage for methods of OOM approach Persentage MaSE KGR MASSIVE AOAD MASB Others Methods..To employ agent base software, a specification technique must support the whole software engineering process from planning, through analysis and design, and finally system construction, transition, and maintenance. To preserve agency properties, AUML proposed the main modification can occurs on the following,: Dynamic model: [26] developing UML modeling techniques as interaction diagrams (sequence, collaboration and state diagram) and generate AUML interaction protocols Static model:[27] to capture the physicality and state of an agent and its communications with conceptual and implementation models, by creating Agent class diagram and package diagram. 3.0 Evaluations criteria From the fact that AOSE combines SE and Agency theory, it is necessary to establish evaluation criteria concurrent with SE objectives as well as preserves Agents characteristics, which enables us to give a judgment on these methodologies and theirs modeling techniques, actually, a numerous criteria for evaluating the quality of modeling techniques of a generic Software Engineering has been published. In this article the selection of criteria of software engineering methodologies and modeling techniques concentrates on specification should be naturally existed and supported by a given methodology, to represent (model) very generic software system. Based on the criteria [28] [29]: Preciseness: the semantics of a modeling technique must be unambiguous in order to avoid misinterpretation of the models (of the modeling technique) by those who use it. Accessibility: a modeling technique should be comprehensible to both experts and novices. Expressiveness (and applicable to multiple domains): a modeling technique should be able to present: The structure of the system; The knowledge encapsulated within the system; The data flow within the system; The control flow within the system; The interaction of the system with external systems. Modularity& objectiveness: a modeling technique should be expressible in stages. That is, when new specification requirements are added, there is no need to modify pervious parts, and these may be used as part of the new specification. Complexity Management: a modeling technique should be expressed, and then examined, at various levels of detail. Sometimes, high-level requirements are needed, while in other situations, more detail is required. Examination and development of all levels should be facilitated. Executability (and testability): either a prototyping capacity or a simulation capacity should be associated with at least some aspects of the modeling technique. That is, the modeling technique has related tools that allow (possibly inefficient) computation for sample input. These should demonstrate possible behaviors of the system being modeled, and help developers determine whether the intended requirements have been expressed. Refinability : a modeling technique should provide a clear path for refining a model through gradual stages to reach an implementation, or at least for clearly connecting the implementation level to the design specification. Analyzability: A methodology or, preferably, an associated tool is available to check the internal consistency or implications of the models, or to identify aspects that seem to be unclear, such as the interrelations among seemingly unrelated operations. Such tools encourage both consistency and coverage. Openness & portability: a modeling technique should provide a good basis for modeling AO systems without coupling them to a specific architecture, infrastructure or programming language. Formalization: The modeling constructs should be complete and enough to Instruct or even generate implementation. The number of such constructs Should be small, the composition rules should be straightforward. Yet another facet of evaluating -a software that holds Agents within- (AOSE) must be examined with the capability of representing such entities (Agents) in the system. Accordingly, the need is obvious for additional evaluation criteria for modeling software system which has agents within, this criteria must generated from agency characteristics to be checked in a given methodology and its modeling techniques. The following criteria of evaluation is based agent s software characteristics [30, 31, 32, 33] to check how much each methodology can represents these characteristics: Autonomy: unlike objects, agents may be active and are responsible for their own activities: the agent has control over both its reactive and proactive behaviors. The modeling technique should support the capability of describing an agent's self-control feature. 4
5 Complexity: AO systems are basically having sets of components (agents) that interact with each other in order to achieve their goals. These systems may consist of decision making mechanisms, learning mechanisms, reasoning mechanism and other complex algorithms. Modeling complex algorithms and mechanisms requires strong expressive power and many layers of details. A modeling technique should support such expressiveness in order to model the functionality of AO systems. Moreover, the complexity feature requires that modeling technique should be modular, support complexity management and describe the complex nature of an agent. Adaptability: AO systems have to be flexible in order to adjust their activities to the dynamic environmental changes. The adaptability feature may require that a modeling technique be modular and that it can activate each component according to the environmental state. Concurrency: an agent may need to perform several activities/tasks at the same time. The concurrency feature raises the requirement that some AO systems must be designed as parallel processing systems. This requires ability to express parallelism and concurrency in the design and implementation/deployment stages. Distribution: multi-agent systems are sometimes working on different hosts and should be distributed over a network. This requires ability to express distribution in the design and implementation/deployment stages. Communication richness: a basic definition of an agent consists of its autonomous activity. As such, the agent must establish communication with its environment. The environment may include other agents and information sources. The communication is characterized by its type (either inter-agent communication or intra-agent communication), its content and its architecture (e.g. clientserver, peer-to-peer). This requires that a modeling technique should be able to express the communication characterization in order to produce agent communication command or sentences during the implementation stage. 3.0 Evaluation of the main approaches of AOSE. Section 3 and its subsection give an overview of the main approaches with supported example. This section will apply the criteria set for software engineering and criteria to model the agency characteristics in software. 3.1 Agent-Oriented Methodologies AOM (Gaia) Software Engineering evaluation Preciseness & clarity: mostly textual representations, the liveness and safety properties, which are used for depicting the functionality of a role in a formal way (i.e., for each text and notation there is a clear meaning and interpretation), makes Gaia prevents misinterpretation of the modeled functionality. Accessibility: Gaia is easy to understand and use due to its simple models and their clarity. Understanding and usage of Gaia can be achieved by following the description of its models. Expressiveness: Gaia is expressive and can handle a large variety of systems due to its generic structure. However, Gaia is mostly suitable for small and medium scale systems. This is because of its flatness, which limits the ability to model large amount of details. The structure of the system, the encapsulated knowledge, the data and control flows are not presented explicitly within Gaia. Modularity & objectiveness: Gaia is mostly modular due to its design with some building blocks such as roles, protocols, activities and agent types. In Gaia, one can assign new roles to agents and remove ones with no effect on the internal model of the roles. However, changes within the protocol might cause changes within the internal structure of the role. These result in changes in permissions of the role, thus limits the modularity of Gaia. Complexity Management: in Gaia, there is no hierarchical presentation or any other mechanism for complexity management. The system description is flat depicted in the Role Schema with no any hierarchy or distribution. Executability: this issue is not dealt with within Gaia. Refinability: this issue is not dealt with within Gaia. Analyzability: this issue is not dealt with within Gaia. Openness and portability: Gaia provide role oriented architecture, without coupling to a certain infrastructure or programming language. It leaves the implementation issue open for the programmer to deal with. And do not specify a programming paradigm support. Formalization: the impact of textual representation, retunes more than one meaning for a text, or at least, not grantee to have a unique role model for the same role and different prospective. Software agents characteristics Autonomy: in Gaia the autonomy is expressed by the fact that the role encapsulates its functionality (i.e., it is responsible for it). This functionality is internal and is not affected by the environment, thus represents the role's autonomy. In addition, in Gaia one can model alternative computational paths, which gives the role (and agents that consist of this role) the autonomy in making decisions. Complexity: in Gaia one can describe the agent's complexity by integrating several models: the role model, the acquaintance model and the agent model. However, it is difficult to model some procedural processes and complex computation in Gaia, agent learning, reasoning, and decision support algorithms are not supported. Adaptability: adaptability in Gaia can be expressed by the liveness properties. The liveness property operators within Gaia symbolize optional execution, thus expresses the potential adaptability of the agent to environmental changes (although the changes are not described explicitly). Concurrency: this issue is not dealt with within Gaia. Distribution: Gaia allows the expression of distribution via the acquaintance model, where each role can be performed on any 5
6 host or processor. Yet, it does not explicitly address the distribution issue. Communication richness: the communication aspects that are dealt within Gaia are the protocols and the communication paths between agents. However, the content of a message and the communication architecture are not expressed in any of the Gaia models. 4.2 Multiagent Software Engineering (MaSE) Software Engineering evaluation Preciseness: MaSE provide graphical and textual representations, with a hierarchy structure for goals, nondirected and directed nodded graphs for role model, for agent model, with textual declaration for each structure or node. The structures and graphs have precise meanings. Accessibility: The structural form of MaSE offers simplicity as well as understandable view for average users of this methodology, it moves smoothly from one step to another. Expressiveness: MaSE, naturally support goal hierarchy structure modeling of software, data and control flow performed by Agent Class Diagram and Concurrent Task diagram. Knowledge encapsulation partially represented within Rule Container in Class Architecture. Modularity and objectiveness: MaSE highly based on goal structure (modularity), then it assigns agents to perform a group of goals, the goal is represented by at least one module, changing in goals like creating or deleting will call a restructuring for that part of the goal hierarchy. Complexity Management: MaSE manage complicity with the hierarchical structure it offers, complex goals divided into more simple sub-goals, and then assign adjacent sub goals into roles to be carried out by an appropriate agent. Executability: AgentTool is prototyping tool presented to model the software system developing process using MaSE, through all phases of development. Refinability: MaSE provide a clear path from system design to implementation, the outcome of MaSE design phase supports the object-oriented view of programming, even though, it started with its analysis phase with goal structural hierarchy attitude. Analyzability: AgentTool can be used a CASE tool for constancy and coverage of the models. Openness and portability: system designed in MaSE could be implemented in several different ways from the same design. Independent from specific architecture, and programming language. Formalization: MaSE presented as full cycle of software engineering proves, with formal diagrams, that enough defined to be implemented. Software agents characteristics Autonomy: this agent s characteristic in not supported into MaSE, agents in general have reactive behaviour. Complexity: with Agent Class Architecture with the rules container and Communication Class Diagram of MaSE represent pre-planed reasoning and Decision support algorithms, learning algorithms is not sustained. Adaptability: not supported in MaSE, each agent mapped with pre-assigned role/roles, and every role contains a group of goals, any changing on environments appeals to restructuring of the goal hierarchy. Concurrency: MaSE does not sufficiently support concurrency; as for each role consist of one or more tasks to satisfy its goal, time management in Concurrent Task Diagram manages the concurrent tasks in a given tasks of a role not between roles in general. Distribution: represented by Deployment Diagram of MaSE. Communication Richness: communication between agents and environment in MaSE are restricted with initiator, responder, scenario, and binary conversation exchange between two agents through a directed finite state machine represented in Communication Class Diagram. 4.3 Object Oriented modeling extension (AUML) Software Engineering evaluation Preciseness: emphasis on symbolic representations, with less textual definition each symbol has an obvious meaning, the out come is generally diagrams. Accessibility: must study and understanding the meaning of the AUML diagrams and symbols, then it would be easy to depict the meaning from these diagrams. Expressiveness: with AUML diversity of diagrams to represent the static and dynamic structure, provide a wealthy range of representing the software development of all phases with data control and data flow, the knowledge encapsulation is limited, can be represented by Statechart Diagram and Agent Class Diagram. Modularity and objectiveness: by its nature as object oriented descendent, AUML supports objectiveness, the modules represented as methods in those objects. Modules carried out by objects (or Agents), creating new module must assigned with that object or agent, with no changing in software components. Complexity Management: AUML express the software with multiple levels of details from Use-Case functional representation, and collaborative (sequence, activity) diagrams and even for single activity by statechart diagram. Excutability: AUML provide prototyping and sampling for software, transfer prototyping into coding (e.g. Rational Rose software ), which can represent the software behavior before even start coding. Refinability: Diagrams in AUML reflects the final system design and then comes coding or implementations by Object Oriented language (with a prospective of agent support libraries). Analyzability: consistency can be checked with formal semantic of AUML diagrams using many CASE tools that supports UML modeling techniques. Openness and portability: AUML supports agent and object oriented architecture, without coupling to a certain infrastructure or programming language. Likely to be implemented by any Object with Agents programming (OOP, AOP) paradigm. 6
7 Formalization: the symbols and diagrams in AUML support full-life cycle of Software Engineering have one and only one formal meaning that could be straightforward transformed into implementation. Software agents characteristics Autonomy: can be expressed by AUML potential class diagram within capabilities, service description and constrains parts. These parts are not affected by environment, but represent agent s mentality; the proposed knowledge representation used for this matter is not fully set yet [34]. Complexity: AUML relatively support agent system complexity for multi-agent collaboration by developing Agent Interaction Protocol (AIP) connected to Agent Class diagram though Communication Acts Protocol into Agent - head automata, these diagrams support reasoning algorithms, but learning and decision support algorithms are not enough supported. Adaptability: Adapting changes in dynamic environment is limited into AUML, which is lacking to knowledge representation about the environment [46], an Agent Class Diagram may activate one of outgoing Communication acts based on incoming Communication Act Protocol. Concurrency: concurrencies represented by Agent Interaction Protocol with the possibility of layer, nested, or interleave protocol types. Distribution: dealt with by the Deployment Diagram of AUML, which is the same Deployment Diagram in Object UML [see any reference of UML]. Communication Richness: can be represented by incoming and outgoing Communication Acts, and more elaborated in Agent Interaction protocol, but these communication mostly the message contents and architecture are represented by preplaned scenarios. Software Engineering evaluation Software agents characteristics evaluation Criteria Methods AOM (Gaia) OOM (MaSE) Extension of OOSE (AUML) Preciseness * * + Accessibility Expressiveness * * * Modularity & Objectiveness - + * Complexity Management Executability NS + + Refinability NS * + Analysability NS + + Openness & Portability + + * Formalization - * + Autonomy * NS - Complexity Adaptability * NS - Concurrency NS - * Distribution NS * * Communication Richness Table 1: Methodologies and modelling techniques evaluation summary Legend: + : Good * : Satisfactory - : Dissatisfactory NS: Not Supported Conclusion An over view of the evaluation summary results (table 1), shows that Gaia need enhancement in Software Engineering domain criteria, specially with aspects concerning design and implementation, however, provides a little better results with agent characteristics domain criteria compared to others. MaSE has good results in the Software Engineering parts of analysis,design and implementation, but with a shortage in terms Agent characteristics modelling criteria, no wonder because agent in this methodology is dealt with as a special case of object, that provides great limits on agency properties. AUML has great results concerning Software Engineering criteria, some of agent characteristic are satisfactorily represented. Conceivably, the people work with AUML development in FIPA a ware of this deficiency, and they set up technical groups to develop suitable augmentation into AUML to encounter agency properties. References: [1] Shari Lawrence Pfleeger: Software Engineering,The Product of Quality Software, Second Edition, Macmillan Publishing 1991 [2] H. Van Dyke Parunak, Jemes J. Odell, ERIM, : Representation Social Structure in UML, ERIM 2001 [3] Jemes Odell, FIPA publication : Agents, August 1998 [4] R. Jennings, On Agent-Based Software Engineering, Artificial Intelligence, 117 (2), 2000, [ 5] Michael Wooldridge, Nicholas Jennings, David Kinny, Autonomous Agent and Multi- Agent System, 3, ,2000 : The Gaia Methodology for Agent-Oriented Analysis and Design Kluwer Academic Publisher [6]12 Scott A. Deloachm Mark Wood, Intelligent Agent VII,LNAI,pp ,2001: Developing Multiagent Systems with agenttool, Springer-Verlag Berlin Heidelberg
8 [7] 6 Arsene Sabas, Mourad Badri & Sylvain Delisle : A Multidimentional Framework for the Evaluation of Multiagent System Methodologies, Canda 2001 [8]Virginia Dignum, John Jules Mayer, Hans Weigand, Frank Dignum : An Organizational Oriented Model for Agent Societies, Netherlands 2002 [9]avid Kinny, Michael Georgeff, and Anand Rao. A methodology and modelling technique for systems of BDI agents. In W. van der Velde and J. Perram, editors, Agents Breaking Away: Proceedings of the Seventh European Workshop on Modelling Autonomous Agentsin a Multi-Agent World MAAMAW 96, (LNAI Volume 1038). Springer-Verlag: Heidelberg, Germany 1996 [10]acques Ferber: Multi-Agent Systems An Introduction to Distributed Artificial Intelligence pp 31-33, Addison Wesley Longman [11] N. Glaser. Contribution to Knowledge Modelling in a Multi-agent Framework. PhD thesis, University Henry Poincar_e, Nancy, France, [12] C. Iglesias, M. Garijo, J.C. Gonzales, and J.R. Velasco. Analysis and design of multi-agent systems using MAS-CommonKADS. In M.P. Singh, A. Rao, and M.J. Wooldridge, editors, Intelli-gent Agents IV. Proceedings of the Fourth International Workshop on Agent Theories, Architec-tures, and Languages (ATAL-97), Lecture Notes in Artificial Intelligence Vol. 1365, pages 313{326.Springer-Verlag, [13] 30L. Chung, B.A. Nixon, E. Yu, and J. Mylopoulos. Nonfunctional requirements in software engineering. Kluwer Academic Press, Boston et al., [14 ]. Omicini. SODA : Societies and infrastructures in the analysis and design of agent-based systems. In P. Ciancarini and M.J. Wooldridge, editors, Agent-oriented software engineering. Proceedings of the First International Workshop (AOSE-2000), Lecture Notes in Artificial Intelligence, Vol.1957, pages 185{194. Springer-Verlag, [15] A. Drogoul and A. Collinot. Applying an agent-oriented methodology to the design of artificial organizations: a case study in robotic soccer. Autonomous Agents and Multi-Agent Systems,1(1):113{129, [16] 14 Thomas Juan, Leon Sterling, Michael Winikoff : Assembling Agent Oriented Software Engineering Methodologies from Features, Kluer Online, Electronic Commerce Research [17] omas Juan Adrian Pearce Leon Sterling Copyright 2002 ACM /02/0007: ROADMAP: Extending the Gaia Methodology for Complex Open Systems AAMAS 02, July 15-19, 2002, Bologna, Italy. [18] M. T. Brazier, B. M. Dunin-Keplicz, N. R. Jennings, and Treur J. DESIRE: Modelling multi-agent systems in a compositional formal framework. Int Journal of Cooperative Information Systems, 1(6):67 94, January [19] Darryl N. Davis, Yuan Luo, Kecheng Liu, Electronic commerce research : Combining KADS with ZEUS to Develop a Multi-Agent E- Commerce Application, Kluwer Academic Publishers [20] D. Kinny, M. George, and A. Rao. A methodology and modelling technique for systems of BDI agents. In W. van der Velde and J. Perram, editors, Agents Breaking Away: Proceedings of the Seventh European Workshop on Modelling Autonomous Agents in a Multi-Agent World (MAAMAW-96), Lecture Notes in Artificial Intelligence Vol. 1038, pages 56{71. Springer-Verlag, [21] M. Wood and S.A. DeLoach. An overview of the multiagent systems engineering methodology. In P. Ciancarini and M.J. Wooldridge, editors, Agent-oriented software engineering. Proceedings of the First International Workshop (AOSE-2000), Lecture Notes in Artificial Intelligence, Vol. 1957, pages 207{222. Springer-Verlag, [22] M.P. George_ and A.S. Rao. BDI agents: From theory to practice. In Proceedings of the First International Conference on Multi-Agent Systems (ICMAS-95), pages 312{319, [23] J. Lind. Iterative software engineering for multiagent systems: The MASSIVE method. Lecture Notes in Computer Science, Vol Springer-Verlag, Berlin u.a., [24] B. Burmeister. Models and methodology for agent-oriented analysis and design. In K. Fischer, editor, Working Notes of the KI96 Workshop on Agent-oriented Programming and Distributed Systems. DFKI Dokument D-96-06, [25] B. Moulin and M. Brassad. A scenario-based design method and an environment for the development of multiagent systems. In D. Luckose and C. Zhang, editors, Proceedings of the FirstAustralian Workshop on DAI, Lecture Notes in Artificial Intelligence, pages 216{296. Springer-Verlag, [26] Jorg P. Muller, Barhard Bauer, Jemes Odell, Agent UML : A formalism for Specifying Multiagent Interaction, Springer verlag, Berlin, pp , 2001 [27] Barnhard Bauer, Siemens AG, Corporate Technology, Information and Communications : UML class Diagrams Revisited in the Context of Agent- Based Systems, Germany 2002 [28] Katz, Draft of Formal Specification Method Book, [29] M. A. Ardis, J. A. Chaves, L. J. Jagadeesan, P. Mataga, C.Puchol, M. G. Staskauskas and J. Von Olnhausen, AFramework for Evaluating Specification Methods for ReactiveSystems, Experience Report, Proc. of 17th Intl. Conf. onsoftware Engineering, , 47-62, Springer, [30] N. R. Jennings, On Agent-Based Software Engineering, Artificial Intelligence, 117 (2), 2000, [31] Jacques Ferber: Multi-Agent Systems An Introduction to Distributed Artificial Intelligence pp 31-33, Addison Wesley Longman [32] Shehory and A. Sturm, Evaluating Agent-Based System Modeling Techniques, Technical Report TR-ISE/IE , Faculty of Industrial Engineering and Management Technion. [33] R. Jennings and M. Wooldridge, Agent-Oriented Software Engineering, Handbook of Agent Technology (ed. J.Bradshaw) AAAI/MIT Press, 2000 [34] Private Speech Mr. James Odell through 8
Agent-Oriented Software Engineering PORTO Methodology AIAD 2013/2014. António Castro and Eugénio Oliveira
Agent-Oriented Software Engineering PORTO Methodology AIAD 2013/2014 António Castro and Eugénio Oliveira NIAD&R Distributed Artificial Intelligence and Robotics Group 1 Contents What is AOSE? Main Existing
More informationEvaluating the Coverage of Development Lifecycle in Agent Oriented Software Engineering Methodologies
Evaluating the Coverage of Development Lifecycle in Agent Oriented Software Engineering Methodologies N.Sivakumar Department of Computer Science and Engineering Pondicherry Engineering College Puducherry,
More informationEvaluating Agent-Oriented Software Engineering Methodologies
Evaluating Agent-Oriented Software Engineering Methodologies Abdulsalam Alarabeyyat Information Technology Department (IT) Faculty of Prince Abdullah Bin Ghazi of Science and Information Technology Al-Balqa
More informationAn Investigation of Agent Oriented Software Engineering Methodologies to Provide an Extended Methodology
An Investigation of Agent Oriented Software Engineering Methodologies to Provide an Extended Methodology A.Fatemi 1, N.NematBakhsh 2,B. Tork Ladani 3 Department of Computer Science, Isfahan University,
More information4. Multiagent Sys stems Design. Part 2: The PROMETHEUS methodology.
4. Multiagent Systems Design Part 2: Multiagent Syste ems (SMA-UPC) https://kemlg.upc.edu The PROMETHEUS methodology. Javier Vázquez-Salceda SMA-UPC Methodological Extensions to Object-Oriented Approaches
More informationPrometheus: A Methodology for Developing Intelligent Agents
Prometheus: A Methodology for Developing Intelligent Agents Lin Padgham and Michael Winikoff RMIT University, GPO Box 2476V, Melbourne, AUSTRALIA Phone: +61 3 9925 2348 {linpa,winikoff}@cs.rmit.edu.au
More informationMultiagent Systems Engineering: A Methodology And Language for Designing Agent Systems
Presented at Agent-Oriented Information Systems (AOIS) 99 Multiagent Systems Engineering: A Methodology And Language for Designing Agent Systems Scott A. DeLoach Department of Electrical & Computer Engineering
More informationTowards an Agent Oriented approach to Software Engineering
Towards an Agent Oriented approach to Software Engineering Anna Perini and Paolo Bresciani ITC-IRST Via Sommarive 18, 38055 Povo, Trento, Italy perini,bresciani @irst.itc.it John Mylopoulos Department
More informationEngineering of a Clinical Decision Support Framework for the Point of Care Use
Engineering of a Clinical Decision Support Framework for the Point of Care Use Szymon Wilk, PhD 1, Wojtek Michalowski, PhD 1, Dympna O Sullivan, PhD 1, Ken Farion, MD 2, Stan Matwin, PhD 1 1 University
More informationAgent-Based Software and Practical Case of Agent-Based Software Development
Agent-Based Software and Practical Case of Agent-Based Software Development Course 2008/2009 SUBJECTS: AGENT-BASED SOFTWARE and PRACTICAL CASE OF AGENT-BASED SOFTWARE DEVELOPMENT EUROPEAN MASTER on SOFTWARE
More informationA Methodology to Evaluate Agent Oriented Software Engineering Techniques
Submitted to: The International Journal of Multiagent and Grid Systems, Nov. 2005. A Methodology to Evaluate Agent Oriented Software Engineering Techniques Chia-En Lin, Krishna M. Kavi Department of Computer
More informationEnhancement of Development Technologies for Agent- Based Software Engineering
Enhancement of Development Technologies for Agent- Based Software Engineering Andre Karpištšenko Tallinn Technical University, Ehitajate tee 5 19086 Tallinn, Estonia andre@lap.ee Abstract. Current trends
More informationAgent-Oriented Software Engineering
ID2209 Distributed Artificial Intelligence and Intelligent Agents Agent-Oriented Software Engineering Mihhail Matskin: www.ict.kth.se/courses/id2209 Autumn 2015 Lecture Outline 1. When is an agent-based
More informationA Review of Agent-Oriented Development Methodologies and Programming Languages/Frameworks
A Review of Agent-Oriented Development Methodologies and Programming Languages/Frameworks Khalil Salah Advanced Informatics School Universiti Teknologi Malaysia Kuala Lumpur, 54100, Malaysia Ardavan Ashabi
More informationThe multi agent paradigm and organizational abstractions in construction e-business
icccbe 2010 Nottingham University Press Proceedings of the International Conference on Computing in Civil and Building Engineering W Tizani (Editor) The multi agent paradigm and organizational abstractions
More informationVALIDATION OF THE DEVELOPMENT METHODOLOGIES
VALIDATION OF THE DEVELOPMENT METHODOLOGIES Ammar LAHLOUHI Department of computer science, University of Batna, 05 000 Batna ABSTRACT This paper argues that modelling the development methodologies can
More informationBusiness Modeling with UML
Business Modeling with UML Hans-Erik Eriksson and Magnus Penker, Open Training Hans-Erik In order to keep up and be competitive, all companies Ericsson is and enterprises must assess the quality of their
More informationA KNOWLEDGE BASE FOR KNOWLEDGE-BASED MULTIAGENT SYSTEM CONSTRUCTION
National Aerospace and Electronics Conference (NAECON) Dayton, OH, October 10-12, 2000. A KNOWLEDGE BASE FOR KNOWLEDGE-BASED MULTIAGENT SYSTEM CONSTRUCTION MARC J. RAPHAEL 1 and SCOTT A. DELOACH 2 1 Space
More informationThe Agent Modeling Language (AMOLA)
The Agent Modeling Language (AMOLA) Nikolaos Spanoudakis 1,2 and Pavlos Moraitis 2 1 Technical University of Crete, Department of Sciences, University Campus, 73100, Kounoupidiana, Greece nikos@science.tuc.gr
More informationChap 1. Introduction to Software Architecture
Chap 1. Introduction to Software Architecture 1. Introduction 2. IEEE Recommended Practice for Architecture Modeling 3. Architecture Description Language: the UML 4. The Rational Unified Process (RUP)
More informationONTOLOGY BASED FEEDBACK GENERATION IN DESIGN- ORIENTED E-LEARNING SYSTEMS
ONTOLOGY BASED FEEDBACK GENERATION IN DESIGN- ORIENTED E-LEARNING SYSTEMS Harrie Passier and Johan Jeuring Faculty of Computer Science, Open University of the Netherlands Valkenburgerweg 177, 6419 AT Heerlen,
More informationAgent-Based Computing and Programming of Agent Systems
Agent-Based Computing and Programming of Agent Systems Michael Luck 1, Peter McBurney 2, and Jorge Gonzalez-Palacios 1 1 School of Electronics and Computer Science, University of Southampton, United Kingdom
More informationHow To Develop A Multi Agent System (Mma)
S-Tropos: An Iterative SPEM-Centric Software Project Management Process Yves Wautelet, Manuel Kolp, Youssef Achbany IAG Institut d Administration et de Gestion, ISYS Unité de Systèmes d Information, Université
More informationSoftware Development Methodologies
Software Development Methodologies Lecturer: Raman Ramsin Lecture 5 Integrated Object-Oriented Methodologies: OPM and Catalysis 1 Object Process Methodology (OPM) Introduced by Dori in 1995 Primarily intended
More informationBusiness Rules and Decision Processes in Mediated Business Coordination
Business Rules and Decision Processes in Mediated Business Coordination Zheng Zhao and Virginia Dignum and Frank Dignum Department of Information and Computing Sciences Utrecht University The Netherlands
More informationThe Tropos and MaSE Agent-Oriented Software Engineering Methodologies. Msury Mahunnah, Tallinn University of Technology
The Tropos and MaSE Agent-Oriented Software Engineering Methodologies Msury Mahunnah, Tallinn University of Technology Mailing list for the course aine.aom@lists.ttu.ee You can join at http://lists.ttu.ee/mailman/listinfo/aine.aom
More informationSoftware Rapid Approach to Agency Design and Development
1 Introduction Over the past decades, agents have become a powerful software abstraction to support the development of complex and distributed systems (Jennings 2001). They are a natural metaphor to understand
More informationDesigning Real-Time and Embedded Systems with the COMET/UML method
By Hassan Gomaa, Department of Information and Software Engineering, George Mason University. Designing Real-Time and Embedded Systems with the COMET/UML method Most object-oriented analysis and design
More informationAgent Orientation in Software Engineering
Agent Orientation in Software Engineering Gerhard Weiß Institut für Informatik, Technische Universität München D-80290 München, Germany, weissg@in.tum.de Revised Version for Knowledge Engineering Review
More informationMastem: A Mathematics Tutoring Multi-Agent System
Mastem: A Mathematics Tutoring Multi-Agent System Jéssyka Vilela 1, Ricardo Ramos 2, Jaelson Castro 1 1 Universidade Federal de Pernambuco Centro de Informática Av. Jornalista Anibal Fernandes, S/N, Cidade
More informationIncreasing Development Knowledge with EPFC
The Eclipse Process Framework Composer Increasing Development Knowledge with EPFC Are all your developers on the same page? Are they all using the best practices and the same best practices for agile,
More informationAGENTS AND SOFTWARE ENGINEERING
AGENTS AND SOFTWARE ENGINEERING Michael Wooldridge Queen Mary and Westfield College, University of London London E1 4NS, United Kingdom M.J.Wooldridge@qmw.ac.uk Abstract Software engineers continually
More informationQuestions? Assignment. Techniques for Gathering Requirements. Gathering and Analysing Requirements
Questions? Assignment Why is proper project management important? What is goal of domain analysis? What is the difference between functional and non- functional requirements? Why is it important for requirements
More informationMasters of Science in Software & Information Systems
Masters of Science in Software & Information Systems To be developed and delivered in conjunction with Regis University, School for Professional Studies Object Oriented Design Table of Contents January
More informationAgent-Oriented Software Engineering: The State of the Art
Agent-Oriented Software Engineering: The State of the Art Michael Wooldridge and Paolo Ciancarini Department of Computer Science University of Liverpool Liverpool L69 7ZF, UK M.J.Wooldridge@csc.liv.ac.uk
More informationPerspective Methods and Tools for the Design of Distributed Software Systems Based on Services
Acta Polytechnica Hungarica Vol. 4, No. 1, 2007 Perspective Methods and Tools for the Design of Distributed Software Systems Based on Services Marek Paralič Department of Computers and Informatics, Faculty
More informationGenerating Aspect Code from UML Models
Generating Aspect Code from UML Models Iris Groher Siemens AG, CT SE 2 Otto-Hahn-Ring 6 81739 Munich, Germany Iris.Groher@fh-hagenberg.at Stefan Schulze Siemens AG, CT SE 2 Otto-Hahn-Ring 6 81739 Munich,
More informationPerspective Methods and Tools for the Design of Distributed Software Systems Based on Services
5 th Slovakian-Hungarian Joint Symposium on Applied Machine Intelligence and Informatics January 25-26, 2007 Poprad, Slovakia Perspective Methods and Tools for the Design of Distributed Software Systems
More informationPROCESS MODELS FOR AGENT-BASED DEVELOPMENT
PROCESS MODELS FOR AGENT-BASED DEVELOPMENT Luca Cernuzzi 1,2, Massimo Cossentino 3, Franco Zambonelli 1 1) DISMI Università di Modena e Reggio Emilia, Italy 2) Universidad Catolica de Asunciòn, Paraguay
More informationA SYSTEMATIC APPROACH FOR COMPONENT-BASED SOFTWARE DEVELOPMENT
A SYSTEMATIC APPROACH FOR COMPONENT-BASED SOFTWARE DEVELOPMENT Cléver Ricardo Guareis de Farias, Marten van Sinderen and Luís Ferreira Pires Centre for Telematics and Information Technology (CTIT) PO Box
More informationAnnouncements. SE 1: Software Requirements Specification and Analysis. Review: Use Case Descriptions
Announcements SE 1: Software Requirements Specification and Analysis Lecture 4: Basic Notations Nancy Day, Davor Svetinović http://www.student.cs.uwaterloo.ca/ cs445/winter2006 uw.cs.cs445 Send your group
More informationInformation Broker Agents in Intelligent Websites
Information Broker Agents in Intelligent Websites Catholijn M. Jonker, Jan Treur Vrije Universiteit Amsterdam, Department of Artificial Intelligence De Boelelaan 1081a, 1081 HV Amsterdam, The Netherlands
More informationManaging Community Healthcare Information in a Multi-Agent System Environment
Managing Community Healthcare Information in a Multi-Agent System Environment Richard Hill, Simon Polovina and Martin D. Beer Web & Multi-Agents Research Group Faculty of Arts, Computing, Engineering &
More informationHowever, the marketplace for replaceable components is still not at sight due to many
Software Replaceability: An NFR Approach Lei Zhang Lawrence Chung Jing Wang Department of Computer Science The University of Texas at Dallas {lei74, chung, jwang}@ utdallas.edu Abstract Building software
More informationHow To Develop A Multiagent System
Towards a Comprehensive Agent-Oriented Software Engineering Methodology Dissertation vorgelegt dem Fachbereich Wirtschaftswissenschaften, der Universität Duisburg-Essen (Campus Essen) von Tawfig M. Abdelaziz,
More informationStructure of Presentation. The Role of Programming in Informatics Curricula. Concepts of Informatics 2. Concepts of Informatics 1
The Role of Programming in Informatics Curricula A. J. Cowling Department of Computer Science University of Sheffield Structure of Presentation Introduction The problem, and the key concepts. Dimensions
More informationAn Aspect-Oriented Product Line Framework to Support the Development of Software Product Lines of Web Applications
An Aspect-Oriented Product Line Framework to Support the Development of Software Product Lines of Web Applications Germán Harvey Alférez Salinas Department of Computer Information Systems, Mission College,
More informationA Knowledge-based Product Derivation Process and some Ideas how to Integrate Product Development
A Knowledge-based Product Derivation Process and some Ideas how to Integrate Product Development (Position paper) Lothar Hotz and Andreas Günter HITeC c/o Fachbereich Informatik Universität Hamburg Hamburg,
More informationUML-based Conceptual Design Approach for Modeling Complex Processes in Web Application
UML-based Conceptual Design Approach for Modeling Complex Processes in Web Application Siti Azreena Mubin Faculty of Computer Science and Information Technology, Universiti Putra Malaysia, 43400 Serdang,
More informationData Integration using Agent based Mediator-Wrapper Architecture. Tutorial Report For Agent Based Software Engineering (SENG 609.
Data Integration using Agent based Mediator-Wrapper Architecture Tutorial Report For Agent Based Software Engineering (SENG 609.22) Presented by: George Shi Course Instructor: Dr. Behrouz H. Far December
More informationAn Organizational Model for Designing Adaptive Multiagent Systems
An Organizational Model for Designing Adaptive Multiagent Systems Scott A. DeLoach Eric Matson Multiagent and Cooperative Robotics Laboratory Department of Computing and Information Sciences, Kansas State
More informationAgent Services-Based Infrastructure for Online Assessment of Trading Strategies
Agent Services-Based Infrastructure for Online Assessment of Trading Strategies Longbing Cao, Jiaqi Wang, Li Lin, Chengqi Zhang Faculty of Information Technology, University of Technology Sydney, Australia
More informationPersonalized e-learning a Goal Oriented Approach
Proceedings of the 7th WSEAS International Conference on Distance Learning and Web Engineering, Beijing, China, September 15-17, 2007 304 Personalized e-learning a Goal Oriented Approach ZHIQI SHEN 1,
More informationUbiquitous, Pervasive and Mobile Computing: A Reusable-Models-based Non-Functional Catalogue
Ubiquitous, Pervasive and Mobile Computing: A Reusable-Models-based Non-Functional Catalogue Milene Serrano 1 and Maurício Serrano 1 1 Universidade de Brasília (UnB/FGA), Curso de Engenharia de Software,
More informationEnterprise Integration: operational models of business processes and workflow systems *
Enterprise Integration: operational models of business processes and workflow systems. 1 Enterprise Integration: operational models of business processes and workflow systems * G.Bruno 1, C.Reyneri 2 and
More informationNormative Ontologies to Define Regulations Over Roles in Open Multi- Agent Systems
Normative Ontologies to Define Regulations Over Roles in Open Multi- Agent Systems Carolina Felicíssimo, Carlos Lucena, Gustavo Carvalho and Rodrigo Paes Departamento de Informática PUC Rio Rua Marquês
More informationThe Design of an Agent-Based Production Scheduling Software Framework for Improving Planning-Scheduling Collaboration
The Design of an Agent-Based Production Scheduling Software Framework for Improving Planning-Scheduling Collaboration Pedro Gomez-Gasquet, Francisco Cruz Lario Esteban, Ruben Dario Franco Pereyra, and
More informationfeature requirements engineering
feature requirements engineering Exploring Alternatives during Requirements Analysis John Mylopoulos, University of Toronto Goal-oriented requirements analysis techniques provide ways to refine organizational
More informationInternational Journal of Software Engineering and Knowledge Engineering Vol. 11, No. 3 (2001) 231-258 World Scientific Publishing Company
International Journal of Software Engineering and Knowledge Engineering Vol. 11, No. 3 (2001) 231-258 World Scientific Publishing Company MULTIAGENT SYSTEMS ENGINEERING SCOTT A. DELOACH, MARK F. WOOD AND
More informationTask Management under Change and Uncertainty
Task Management under Change and Uncertainty Constraint Solving Experience with the CALO Project Pauline M. Berry, Karen Myers, Tomás E. Uribe, and Neil Yorke-Smith Artificial Intelligence Center, SRI
More informationA Multiagent Model for Intelligent Distributed Control Systems
A Multiagent Model for Intelligent Distributed Control Systems José Aguilar, Mariela Cerrada, Gloria Mousalli, Franklin Rivas, and Francisco Hidrobo CEMISID, Dpto. de Computación, Facultad de Ingeniería,
More informationUML-based Test Generation and Execution
UML-based Test Generation and Execution Jean Hartmann, Marlon Vieira, Herb Foster, Axel Ruder Siemens Corporate Research, Inc. 755 College Road East Princeton NJ 08540, USA jeanhartmann@siemens.com ABSTRACT
More informationCONFIOUS * : Managing the Electronic Submission and Reviewing Process of Scientific Conferences
CONFIOUS * : Managing the Electronic Submission and Reviewing Process of Scientific Conferences Manos Papagelis 1, 2, Dimitris Plexousakis 1, 2 and Panagiotis N. Nikolaou 2 1 Institute of Computer Science,
More informationA Contribution to Expert Decision-based Virtual Product Development
A Contribution to Expert Decision-based Virtual Product Development László Horváth, Imre J. Rudas Institute of Intelligent Engineering Systems, John von Neumann Faculty of Informatics, Óbuda University,
More informationA Methodology for the Development of New Telecommunications Services
A Methodology for the Development of New Telecommunications Services DIONISIS X. ADAMOPOULOS Centre for Communication Systems Research School of Elec. Eng., IT and Mathematics University of Surrey Guildford
More informationThe Role of Computers in Synchronous Collaborative Design
The Role of Computers in Synchronous Collaborative Design Wassim M. Jabi, The University of Michigan Theodore W. Hall, Chinese University of Hong Kong Abstract In this paper we discuss the role of computers
More informationWeb Application Development Processes: Requirements, Demands and Challenges
Web Application Development Processes: Requirements, Demands and Challenges THAMER AL-ROUSAN 1, BASEM HADIDI 2, SHADI ALJAWARNEH 3 1, 3 Faculty of Science and Information Technology, Isra University, Amman,
More informationImplementation of hybrid software architecture for Artificial Intelligence System
IJCSNS International Journal of Computer Science and Network Security, VOL.7 No.1, January 2007 35 Implementation of hybrid software architecture for Artificial Intelligence System B.Vinayagasundaram and
More informationJOURNAL OF OBJECT TECHNOLOGY
JOURNAL OF OBJECT TECHNOLOGY Online at http://www.jot.fm. Published by ETH Zurich, Chair of Software Engineering JOT, 2008 Vol. 7, No. 8, Novmeber - December 2008 Extension of Object-Oriented Software
More informationExploiting User and Process Context for Knowledge Management Systems
Workshop on User Modeling for Context-Aware Applications at the 8th Int. Conf. on User Modeling, July 13-16, 2001, Sonthofen, Germany Exploiting User and Process Context for Knowledge Management Systems
More informationChapter 4 Software Lifecycle and Performance Analysis
Chapter 4 Software Lifecycle and Performance Analysis This chapter is aimed at illustrating performance modeling and analysis issues within the software lifecycle. After having introduced software and
More informationDistributed Database for Environmental Data Integration
Distributed Database for Environmental Data Integration A. Amato', V. Di Lecce2, and V. Piuri 3 II Engineering Faculty of Politecnico di Bari - Italy 2 DIASS, Politecnico di Bari, Italy 3Dept Information
More informationA Pattern-based Framework of Change Operators for Ontology Evolution
A Pattern-based Framework of Change Operators for Ontology Evolution Muhammad Javed 1, Yalemisew M. Abgaz 2, Claus Pahl 3 Centre for Next Generation Localization (CNGL), School of Computing, Dublin City
More informationBusiness-Driven Software Engineering Lecture 3 Foundations of Processes
Business-Driven Software Engineering Lecture 3 Foundations of Processes Jochen Küster jku@zurich.ibm.com Agenda Introduction and Background Process Modeling Foundations Activities and Process Models Summary
More informationLayered Approach to Development of OO War Game Models Using DEVS Framework
Layered Approach to Development of OO War Game Models Using DEVS Framework Chang Ho Sung*, Su-Youn Hong**, and Tag Gon Kim*** Department of EECS KAIST 373-1 Kusong-dong, Yusong-gu Taejeon, Korea 305-701
More informationAgent-oriented Modeling for Collaborative Learning Environments: A Peer-to-Peer Helpdesk Case Study
Agent-oriented Modeling for Collaborative Learning Environments: A Peer-to-Peer Helpdesk Case Study Renata S. S. Guizzardi 1, Gerd Wagner 2 and Lora Aroyo 1 1 Computer Science Department University of
More informationMeta-Model specification V2 D602.012
PROPRIETARY RIGHTS STATEMENT THIS DOCUMENT CONTAINS INFORMATION, WHICH IS PROPRIETARY TO THE CRYSTAL CONSORTIUM. NEITHER THIS DOCUMENT NOR THE INFORMATION CONTAINED HEREIN SHALL BE USED, DUPLICATED OR
More informationTool Support for Software Variability Management and Product Derivation in Software Product Lines
Tool Support for Software Variability Management and Product Derivation in Software s Hassan Gomaa 1, Michael E. Shin 2 1 Dept. of Information and Software Engineering, George Mason University, Fairfax,
More informationA Multi-Agent Approach to a Distributed Schedule Management System
UDC 001.81: 681.3 A Multi-Agent Approach to a Distributed Schedule Management System VYuji Wada VMasatoshi Shiouchi VYuji Takada (Manuscript received June 11,1997) More and more people are engaging in
More informationCharacteristics of Computational Intelligence (Quantitative Approach)
Characteristics of Computational Intelligence (Quantitative Approach) Shiva Vafadar, Ahmad Abdollahzadeh Barfourosh Intelligent Systems Lab Computer Engineering and Information Faculty Amirkabir University
More informationModeling the User Interface of Web Applications with UML
Modeling the User Interface of Web Applications with UML Rolf Hennicker,Nora Koch,2 Institute of Computer Science Ludwig-Maximilians-University Munich Oettingenstr. 67 80538 München, Germany {kochn,hennicke}@informatik.uni-muenchen.de
More informationAn Approach to Software Architecture Description Using UML
An Approach to Software Architecture Description Using UML Henrik Bærbak Christensen, Aino Corry, and Klaus Marius Hansen Department of Computer Science, University of Aarhus Aabogade 34, 8200 Århus N,
More informationAutonomy for SOHO Ground Operations
From: FLAIRS-01 Proceedings. Copyright 2001, AAAI (www.aaai.org). All rights reserved. Autonomy for SOHO Ground Operations Walt Truszkowski, NASA Goddard Space Flight Center (GSFC) Walt.Truszkowski@gsfc.nasa.gov
More informationCloud Computing and Software Agents: Towards Cloud Intelligent Services
Cloud Computing and Software Agents: Towards Cloud Intelligent Services Domenico Talia ICAR-CNR & University of Calabria Rende, Italy talia@deis.unical.it Abstract Cloud computing systems provide large-scale
More informationMulti-Agent Architecture for Implementation of ITIL Processes: Case of Incident Management Process
Multi-Agent Architecture for Implementation of ITIL Processes: Case of Incident Management Process Youssef SEKHARA, Hicham MEDROMI, Adil SAYOUTI Equipe Architectures des Systèmes (EAS), Laboratoire d Informatique,
More informationA Multi-agent System for Knowledge Management based on the Implicit Culture Framework
A Multi-agent System for Knowledge Management based on the Implicit Culture Framework Enrico Blanzieri Paolo Giorgini Fausto Giunchiglia Claudio Zanoni Department of Information and Communication Technology
More informationSocially Grounded Analysis of Knowledge Management Systems and Processes. Email: rguizzardi@inf.ufes.br. Email: perini@itc.it
Socially Grounded Analysis of Knowledge Management Systems and Processes Renata S. S. Guizzardi 1, Anna Perini 2, Virginia Dignum 3 1 Computer Science Department, Federal University of Espírito Santo,
More informationRequirements engineering
Learning Unit 2 Requirements engineering Contents Introduction............................................... 21 2.1 Important concepts........................................ 21 2.1.1 Stakeholders and
More informationFoundations of Model-Driven Software Engineering
Model-Driven Software Engineering Foundations of Model-Driven Software Engineering Dr. Jochen Küster (jku@zurich.ibm.com) Contents Introduction to Models and Modeling Concepts of Model-Driven Software
More informationStatic Analysis and Validation of Composite Behaviors in Composable Behavior Technology
Static Analysis and Validation of Composite Behaviors in Composable Behavior Technology Jackie Zheqing Zhang Bill Hopkinson, Ph.D. 12479 Research Parkway Orlando, FL 32826-3248 407-207-0976 jackie.z.zhang@saic.com,
More informationAPPLICATION OF MULTI-AGENT SYSTEMS FOR NETWORK AND INFORMATION PROTECTION
18-19 September 2014, BULGARIA 137 Proceedings of the International Conference on Information Technologies (InfoTech-2014) 18-19 September 2014, Bulgaria APPLICATION OF MULTI-AGENT SYSTEMS FOR NETWORK
More informationMulti-Agent System: A Guiding Metaphor for the Organization of Software Development Projects
Multi-Agent System: A Guiding Metaphor for the Organization of Software Development Projects Lawrence Cabac University of Hamburg, Dept. of Informatics, Vogt-Kölln-Str. 30, D-22527 Hamburg http://www.informatik.uni-hamburg.de/tgi
More informationFIPA Brokering Interaction Protocol Specification
1 2 3 4 5 FOUNDATION FOR INTELLIGENT PHYSICAL AGENTS FIPA Brokering Interaction Protocol Specification 6 7 Document title FIPA Brokering Interaction Protocol Specification Document number SC00033H Document
More informationTowards an Integration of Business Process Modeling and Object-Oriented Software Development
Towards an Integration of Business Process Modeling and Object-Oriented Software Development Peter Loos, Peter Fettke Chemnitz Univeristy of Technology, Chemnitz, Germany {loos peter.fettke}@isym.tu-chemnitz.de
More informationVARIABILITY MODELING FOR CUSTOMIZABLE SAAS APPLICATIONS
VARIABILITY MODELING FOR CUSTOMIZABLE SAAS APPLICATIONS Ashraf A. Shahin 1, 2 1 College of Computer and Information Sciences, Al Imam Mohammad Ibn Saud Islamic University (IMSIU) Riyadh, Kingdom of Saudi
More informationComponent-based Development Process and Component Lifecycle Ivica Crnkovic 1, Stig Larsson 2, Michel Chaudron 3
Component-based Development Process and Component Lifecycle Ivica Crnkovic 1, Stig Larsson 2, Michel Chaudron 3 1 Mälardalen University, Västerås, Sweden, ivica.crnkovic@mdh.se 2 ABB Corporate Research,
More informationWorkflow Automation and Management Services in Web 2.0: An Object-Based Approach to Distributed Workflow Enactment
Workflow Automation and Management Services in Web 2.0: An Object-Based Approach to Distributed Workflow Enactment Peter Y. Wu wu@rmu.edu Department of Computer & Information Systems Robert Morris University
More informationModeling Guidelines Manual
Modeling Guidelines Manual [Insert company name here] July 2014 Author: John Doe john.doe@johnydoe.com Page 1 of 22 Table of Contents 1. Introduction... 3 2. Business Process Management (BPM)... 4 2.1.
More informationChapter 8 Approaches to System Development
Systems Analysis and Design in a Changing World, sixth edition 8-1 Chapter 8 Approaches to System Development Table of Contents Chapter Overview Learning Objectives Notes on Opening Case and EOC Cases
More informationManaging and Tracing the Traversal of Process Clouds with Templates, Agendas and Artifacts
Managing and Tracing the Traversal of Process Clouds with Templates, Agendas and Artifacts Marian Benner, Matthias Book, Tobias Brückmann, Volker Gruhn, Thomas Richter, Sema Seyhan paluno The Ruhr Institute
More information