Abstract
Agent-oriented programming (AOP) represents a novel programming paradigm that adopts concepts and technologies of multi-agent system to implement software. It has gained great attentions of researchers and practitioners from both artificial intelligence field and software engineering field. Dozens of AOP languages have been proposed in the past two decades. However the acceptance and adoption of AOP in software engineering community remain limited and the current practices of applying AOP do not convince such paradigm has extensively exploited its technical advantages and potentials. The experiences and practices of programming language researches in software engineering field can give us some inspirations to get out of the dilemma. The paper aims at providing a survey of AOP from software engineering perspectives, including its research history and the state-of-the-art of researches on agent-oriented programming concepts and models, languages, CASE tools and running manners. We investigate how current AOP studies satisfy design principles of programming language like simplicity, regularity, maintainability, expressiveness, reliability and efficiency, discuss several challenges of AOP researches and practices, and point out some directions for future studies.
Introduction
The purpose of software engineering is to develop high-quality software that satisfies requirements in an efficient and low-cost way. In the past years the researchers and practitioners in software engineering community struggled to develop various abstractions, models, methodologies, languages and CASE tools and environments to reach the goal. Generally implementation of software is an indispensable phase in software lifecycle. In this phase, the program that consists of software is to be developed in term of some programming languages, with which programmers can construct program that has rigorous syntax and semantics, and can be understood and executed by computer. In the area of software engineering, various programming paradigms and languages have been developed to satisfy the programming requirements [45,67]. Each programming paradigm and language has its design objectives and provides distinctive approaches to understanding what program is, what language is needed to describe program, how program is to be executed, and how to support the programming activities.
Multi-agent system (MAS) is conceived as consisting of individual agents whose behaviors are autonomous and regulated by the situated organization, and that interact with each other to solve problems [17]. It actually provides an alternative way to understand what the software is and how to develop software. Agent-oriented software engineering (AOSE) aims to support the development of complex systems where the notion of agent and MAS is being used. Such notions are believed to provide high-level concepts, natural abstractions and problem solution approaches that are necessary for modern software engineering [41]. In the past years, AOSE has evolved significantly to address many subjects including analysis and design methodologies, modeling techniques and languages, MAS architectures and patterns, programming languages, and CASE tools and environments, etc. However, it is far from to say that AOSE has convinced the industry of software engineering to adopt its ideas. The researches and practices of AOSE still face up to many problems and challenges, e.g., poor awareness of industrial needs, disconnection from conventional software engineering, immature technology, and a focus on research issues that are not necessarily required by industry [1,47,71].
Maybe one of the main challenges of AOSE is the lack of wide-accepted and practical agent-oriented programming (AOP) languages to support the implementation of software systems in industry-strength. After all, any software engineering paradigms need programming techniques and tools like languages. According to the definition in [59], agent-oriented programming is a new programming paradigm that supports a societal view of computation in terms of the mentalistic, intentional notions that agent theorists have developed to represent the properties of agents. However in this paper we are more concerned about the essences and constituents that AOP provides and the principles that AOP adopts from software engineering viewpoint. Therefore, AOP here is defined as a programming paradigm that aims to support the implementation of software based on MAS notions and technologies.
Since its birth at the beginning of 1990s [59], AOP has gained great attentions in the field of artificial intelligence and recently in the flied of software engineering. Considerable progresses have been made in the past almost two decades, including various AOP languages, frameworks and platforms [8,17]. Some AOP languages (e.g., JAL, AF-APL) and their supporting platforms (e.g. JACK) achieve successes in many domains like decision support, oil production management, autonomous air and underwater vehicles, as well as advanced military simulation systems, robotics and mobile computing [58,69]. However, current applications and practices of AOP do not convince such paradigm has apparent advantages over current mainstream programming paradigms (e.g., OOP) and the potentials to address development issues of increasingly complex software systems (e.g., ultra-large scale systems, social-technical systems, etc.). One evidence is that the practice and the adoption of AOP in industry is comparatively limited. AOP has not found its way to the industry, and only a few of software systems are claimed to be successfully developed in term of AOP languages. Moreover, to exploit its potentials in supporting the development of complex software systems and improve the development efficiency and program quality is still an open issue for the researches of AOP, and should be demonstrated in more successful practices.
Different from other programming paradigms and languages in the field of software engineering [32], AOP emerged from artificial intelligence field. The term AOP was firstly coined by Shoham in 1993 [5,59]. The motivation of early AOP researches is to solve the development issues of intelligent agents and multi-agent systems. They are principally based on the research contributions of artificial intelligence, e.g., rational theory of intelligence agent, agent architecture, agent communication language, etc. However, if we want AOP to be general-purpose and dedicated to the development of complex software systems, solving the fundamental issues of software engineering, and ultimately widely adopted in the software engineering community, we should reconsider the researches and practices of AOP from the software engineering perspectives.
There are several review papers on AOP [5,8,9,17,46]. However, this paper aims at providing an overview of researches on AOP from software engineering perspective. First, we briefly look back the history of AOP researches in Section 2, and then discuss the programming study in software engineering field in Section 3. In Section 4 the state-of-the-art of AOP researches is investigated from three aspects, including programming concepts and models, programming constructs and languages, programming tools and environments. In Section 5 we investigate the extent to which current AOP studies incorporate and consider software engineering fundamental principles for designing programming languages and solving the engineering problems in term of AOP technologies, and discuss some directions for future researches.
Two phases of AOP researches
Two phases of AOP researches
Agent-oriented programming originates from the researches on intelligent agent theory and practice in the areas of AI/DAI. As early as 1980s, such researches has gained great interests in both academic and industry, and emerged as an important solution to construct intelligent systems. The approach provides new abstractions and mechanisms to analyze and implement complex applications with distributed intelligent entities. It seems more suitable for managing complexity and building complex distributed software systems in open environment [41], and supporting the researches and practices of several promising technologies like autonomic computing, cloud computing, semantics web, ambient intelligence, etc.
MASs were originally built in term of specific AI technologies (e.g., knowledge representation and reasoning, expert system) and languages (like Prolog or its extensions) that are dedicated to single knowledge system in static and close environment. However, with the increasing demands on developing MAS and the great progresses of intelligent agent theories and technologies, the implementation of MAS requires specific development supports like programming languages. At the beginning of 1990s, Shoham presented the concept of agent-oriented programming and designed a prototype language Agent-0, which startups the researches and practices of AOP [59]. In the past almost two decades, the researches on AOP have become an important branch of multi-agent system and agent-oriented software engineering. It attracted many researchers from multiple disciplines (e.g., artificial intelligence, software engineering, sociology, cognitive science, etc.) to participate in the multi-disciplinary researches. The whole research history of AOP however can be roughly divided into two phases (see Table 1).
Phase 1: The first dozen years
In this phase, the purpose of AOP researches is to design programming languages that can facilitate the construction and implementation of multi-agent systems. The researches greatly rely on the contributions of artificial intelligence, especially intelligent agent and multi-agent system, and the researchers mostly come from artificial intelligence community. They mainly focus on the implementation of rational and intelligent agents that are capable of reasoning behaviors and performing social interactions. Typically cognitive and mental notions are used as the basic programming concepts and program constructs of AOP languages, e.g., knowledge, belief, desire, intention, commitment [5]. Individual agents are generally implemented as knowledge systems that can reason their belief and/or knowledge and cognitive systems that can reason their beliefs, desires, goals, and intentions.
There are many AOP languages proposed in this phase, such as Agent-0 [59], Concurrent MetateM [31], PLACA [61], AOPLID [34], AgentSpeak(L) [54], 3APL [42], ConGolog [24], Dribble [65], etc. Each of them takes its own approach to translating cognitive or knowledge notions to constructs and abstractions in agent programming language [5]. Most of AOP languages are descriptive style and the extensions to some logic-based programming languages (e.g., Hoare logic, first-order logic, temporal logic, epistemic logic, Prolog). Their semantics are grounded on agent and logic theory, situation calculus, etc. The programs written in these AOP language are normally executed in term of interpreter.
Various prototyping software tools or integrated development environment (IDE) (e.g., AgentFactory [58]) have been developed in support of the coding and running of AOP programs, including interpreter, editor, etc. However, most of AOP languages and their prototyping tools and IDEs are proposed with the purpose to validate AOP technologies (e.g., BDI architecture of rational agent, AOP languages). They are not enough to support the development of industry-strength multi-agent systems that are robust, dependable and efficient. Only a few claim they have successful industry applications like AF-APL [58]. The AOP languages developed in this phase are normally applied for various intelligent systems, distributed systems, etc.
Phase 2: The recent dozen years
The second phase roughly started in 2004. The related publications during this time manifests some significant changes on AOP researches occur. One of backgrounds is the continuous progresses of agent-oriented software engineering and urgent requirements on the breakthrough of AOP languages. Up to 2004, researches on agent-oriented methodologies have reached a top and dozens of agent-oriented methodologies and modeling language have been proposed, such as Gaia, Tropos, MaSE, ADELFE, AOR, INGENIAS, AML, etc. Undoubtedly, the success of agent-oriented analysis and design technologies promotes the demands on AOP languages in order to provide complete development supports for agent-oriented software development. Another background is the application requirements coming from the increasing scale and complexity of software systems as the rapid the development of (mobile) Internet applications, such as socio-technical system, ultra-large scale system, complex adaptive system and system coalitions [53], and the emerging paradigms of Internet computing like grid computing, service-oriented computing, cloud computing, big data computing, etc. The emerging applications and computing paradigms pose new software engineering issues that require software systems with more flexibility, autonomy and adaptability in open environment. AOP become one of the convincing technical candidates to address these issues.
One of the main changes is that AOP is given more general understanding from software engineering viewpoint and expected to provide new paradigm to support the development of complex concurrent and distributed systems. Many researchers and practitioners from software engineering community began to follow with interests and participate in AOP researches that are tightly intersected with multiple disciplines like artificial intelligence, software engineering and sociology. The designs of AOP languages take software engineering principles (e.g., modularity, reusability, information hiding, etc.) into account in order to facilitate their engineering practices. Industry community (e.g., AOS, Agentis Software, RealThing [52]) becomes interested and takes great efforts to develop industrial AOP products, like programming frameworks and platforms. Another impressive change is that the scope of AOP researches is broadened by expanding the view of agent programming beyond the use of cognitive notions, and investigating various new themes related to programming agent decision making [5]. In addition to programming individual agents, AOP researches focus on programming multi-agent system in which agents’ behaviors are regulated by organization norms, rules, etc. Environment and organization notions are introduced into AOP languages as concepts and constructs to implement multi-agent systems, e.g., environment, norm, institution, organization rule and structure, obligation, prohibition, regimentation, enforcement, sanction, etc. The integration of mental, environment and organization notions together into AOP language has become a main challenge of AOP researches in this phase.
Several important AOP languages have been proposed in this phase, such as SLABSp [66], 2APL [50], 2OPL [18,63], NOPL [40], Meta-APL [26], simpAL [56], Oragent [39], JADEL [4], ASTRA [14] etc. Many of AOP languages are imperative style or hybrid style, with an attempt to integrate with mainstream programming languages (e.g., Java) in software engineering or with emerging programming technologies like organization-oriented programming, interaction-oriented programming, environment-oriented programming, etc. [6]. The AOP languages in this phase typically support the programming of individual agents, the interactions among agents and with environments, and the organization regulation of whole system. The formal operation semantics of AOP languages are typically defined in term of various formal system like transition system. More AOP languages attempt to incorporate software engineering principles and address the programming issues resulting from complex distributed systems, such as self-adaptation [30,38,39], self-organization and self-management, service-oriented computing [55,70], mobility [28], etc.
The programs written in these AOP languages are normally executed in term of various programming framework, platform or virtual machine. The CASE tools of AOP languages (e.g., 2APL [50], simpAL [56]) developed in this phase support various programming activities, including editing, compiling, debugging, etc. Many tools are provided to be integrated into IDEs to enrich the engineering capabilities. In addition to traditional applications, the AOP languages developed in this phase seek some new applications, like robots, etc.
Programming study in software engineering
In the process of software development, programming is an important and indispensable development activity aiming at writing programs that accurately implement the expected functional and non-functional features of software system, and can be executed correctly on target computer. Programming languages are therefore needed to act as tool to achieve the communications between programmers and computers [67]. In the field of software engineering, program study is an important branch whose purpose is to develop programming theories and languages to satisfy the requirements of both programmers for easily (e.g., high-level abstraction, easy to find errors or bugs) writing high-quality (e.g., supporting modularity, information hiding and reuse, etc.) source codes and computers for efficiently executing target codes. We can find many significant researches contributions of programming in software engineering, e.g., object encapsulation, procedure calling, exception mechanism, typed theory, etc., which result in various programming paradigms like structured programming, OO programming, etc. The studies of programming and languages in software engineering at least involve the following three aspects.
Programming concepts and models
Any programming language should provide its distinctive understanding about what the program is and how the program is to be constructed and run. Typically, such understanding takes form of programming concepts underlying the design of programming language, e.g., function and its calling in C; object, class, inheritance in
Programming languages
Language is the main output of programming study and the elementary tool for programmers to code the software. The design of programming language is rigorously based on the programming concepts, abstractions and models. In the history of software engineering, hundreds of programming languages have been proposed. However, only a few survive and are used in industry to develop industry-strength software systems. Most of them are obsolete or abandoned by developers. From software engineering viewpoint, we can find some important principles behind the successful design of programming languages. Every programming language has its syntax, semantics and pragmatic. Syntax is concerned about the form of programs in term of programming concepts, which influences how programs are to be written by programmer and parsed by computer. Semantics is concerned about the meaning of a program, which influences how programs are composed by programmers and interpreted by the computer. The syntax and semantics of programming languages should be formally and rigorously defined. Moreover, a programming language should also provide ways to guide developers to use the language in practices, i.e., pragmatics [67]. Up to now, several programming styles have been proposed for designing various programming languages, including descriptive, imperative and hybrid, which will greatly influence the ways to define the syntax and semantic of programming language. For example, OOP language like Java is an imperative language that provides syntax with rigorous operational semantics to represent object class, each object is interpreted as the memory space containing the corresponding properties and methods, and every entity in problem space is suggested to be encapsulated as object class. Some AOP language like JAL [58] is the extension to Java programming language in syntax, and provides the kernel engine and infrastructure to interpret the semantics of JAL program.
Programming CASE tools
In software engineering field, computer-aided software engineering (CASE) tools are provided to support development activities, improve development efficiency and enrich software quality. From programmer viewpoint, programming based on specific language consists of a number of complex and iterative development activities such as editing, compiling and debugging program. From computer viewpoint, the program written in some programming language should be managed and executed on target computer. Therefore, the study and design of programming language also involves provision of CASE tools to support programming activities for programmers and the management and running of program codes for computer. CASE tools for programming are tightly dependent on the programming model and language. For example, development environment integrated several CASE tools like eclipse is provided for Java programmers to implement software and JVM is developed to manage and execute compiled Java codes in an interpret manner. Some AOP language like JAL [58] provides rich CASE tools (e.g., visual design tool) for developers and running platform to execute JAL codes.
An overview of AOP researches from software engineering perspective
In this section we present a survey of AOP researches according to the three aspects of programming study in the field of software engineering (see Fig. 1). We intend to investigate what abstractions and program models are provided by existing AOP languages, their programming styles and the supporting CASE tools, especially how these CASE tools are provided to support the execution of AOP programs.
The framework to survey AOP researches.
Agent-oriented programming is so called because it is based on the concepts of autonomous agent and multi-agent system to understand and construct programs. These concepts constitute high-level abstractions and metaphors to study what the programs are, how to implement them, and what language constructs should be designed to develop such programs. In academic community AOP is considered as a new programming paradigm because the fundamental programming concepts and models behind AOP are essentially different from ones provided by existing programming technologies like OOP, aspect-oriented programming, structured programming, etc. In essence, an agent-oriented program consists of a number of modular that encapsulate the property and behavior features of software agents that are typically formed as organized society in which the behaviors (including interactions) of software agents are regulated by social rules or institutions. Therefore, agent rather than object or thread is the fundamental execution unit of AOP program. The agent-based programming concepts and abstractions are believed to be useful for tackling the complexity of large-scale and complex applications, especially ones that are distributed and situated in open operating environment [1,41].
Until now, the study of AOP provides a repertoire of high-level programming concepts, with which various programming models and different styles of programming languages are designed. In order to support complete implementation of software systems, these programming concepts at least cover three programming aspects, including aspects of individual agent, integration and interaction of agents, and multi-agent organization, respectively representing different scale of observations when implementing software systems based on technologies of multi-agent system, e.g., micro, macro and meso [71].
Programming elementary modular of individual agents
The AOP program of individual agent provides the connections among agent’s internal state, the interactions with other agents or situated environments, and its autonomous behaviors. Such program enables agent to perceive the environment’s changes, record the internal and external information, and perform behaviors in an autonomous way. Therefore, the AOP concepts for individual agent deal with the realization issues related with the abstractions of agent’s internal data and states, actions and behaviors, and environments. They provide fundamental constructs for AOP language to represent the constituents of software modular in AOP from the internal and micro point of view, e.g., the internal architecture of software agent [17], and interpret how the autonomy of behavior is to be achieved.
Different from existing programming paradigms and languages like OOP and Java, the program architecture and programming approach to realize the elementary program modular of AOP are diverse, which results in the AOP concepts for programming individual agents are also various. An autonomous agent can be implemented as a knowledge system, a cognitive system, a reactive system or their combination, each of which depends on different AOP concepts and abstractions. This means the program models of elementary modular in AOP are diverse.
At the early stage of AOP researches, informational attitudes like knowledge, belief, distributed knowledge, etc., and their combinations act as programming concepts to represent the data and state abstractions in AOP program of individual agent. In this approach, agent program is realized as a knowledge system, in which the states of agents are represented by programming concepts like belief and knowledge. The behaviors of agents are programmed as axioms [24] or rules [31], e.g., the temporal logic rule in Concurrent MetateM [31]. The autonomous behaviors of agent program are achieved by the reasoning of beliefs, knowledge and rules in term of belief revisions, knowledge manipulation, situation calculus and logic reasoning. Actually, belief and knowledge are the representations of the state of both agent itself and its observed environment. The environment of agent can be explicitly defined as the set of interacting agents [31]. Several AOP languages provide such kind of programming concepts and models to construct individual agents, e.g., Concurrent MetateM [31], ConGolog [24].
An autonomous agent can also be implemented as a cognitive system whose internal components are composed of informational (e.g., belief, knowledge), motivational (e.g., desire, preferences, goal, intention, etc.), and deliberational (e.g., plan, commitment, capability, etc.) attitudes. These programming concepts provide proper abstractions to represent the data and behaviors of agents based on intentional stance. The autonomous behaviors of software agents depend on practical reasoning of these attitudes that have grounded semantics based on rational agent theories, e.g., BDI theory, KARO theory, etc. The intentional concepts and their combinations for programming individual agents are actually different in various AOP languages to satisfy diverse application requirements and development considerations, which results in the variety of program models for individual agents. For example, Agent-0 [45] uses belief to program agent’s mental state and commitment rule to program agent’s behaviors; AgentSpeak(L) [54] and GOAL [37] use the programming concepts like belief, desire, etc., to represent the data abstractions of agents, and plan, rule, etc., to represent the behavior abstractions of agents. Some variation or extensions to the cognitive concepts are also proposed in some AOP languages to enrich the programming capabilities and achieve specific AOP objectives, e.g., descriptive goal in [42,65] and [50] to describe the state that an agent wants to reach and can be used to program pro-active behavior. There are several AOP languages providing cognitive programming concepts and models to support the implementation of individual agents, e.g., Agent-0 [45], PLACA [61], AgentSpeak(L) [54], CLAIM [28], 3APL [42], GOAL [37,43], Dribble [65] and 2APL [50], etc.
Autonomous behaviors of agent program can also be realized in term of reactive system that is capable of perceiving changes occurring in itself and the situated environment, and responding to the changes in a time-fashion way. In this kind of agent program, there is no practical reasoning in the process of behavior decisions. Several programming concepts are provided for implementing such kind of agent, e.g., caste, event, message, scenario, plan, behavior rule, etc. The programming concepts like event, message, etc., are typically used to represent the changes or interactions; plan and behavior rule, etc., are used to represent the behaviors of agents; and scenario is used to describe a situation in terms of the events happened due to the performance of actions by other agents in the environment [66]. The program model of reactive agents are based on these programming concepts and the stimulus-response mechanism that are implemented in term of event handling and scenario calculus theory [66]. Several AOP languages provide such programming concepts and models to implement individual agents, e.g., SLABSp [66], CAOPLE [72], OragentL [39].
Some AOP languages however adopt the combination of the above programming concepts and corresponding program models to construct individual agents. Such approaches seem more complex because AOP program for individual agent should subtly incorporate these programming concepts as a unified program model, and programmers should know very well about the distinctions and connections of these programming concepts in order to develop software. For example, JAL [58] provides programming concepts like belief, plan, capability, event, team, etc., to implement agents as both reactive system and cognitive system.
Programming integration and interactions of agents
The overall behaviors of multi-agent system depend on not only the behaviors of individual agents but also their integrations and interactions. Few applications only have one agent or have multiple agents that are isolated with no interactions. The AOP program for integration and interactions of agents provides the connection among agents in both structure and behavior. Such program enables agent to integrate into existing systems or organizations, and achieve interactions with other agents. Therefore, the programming concepts for this aspect should solve the realization issues related with the relationships and interactions of agents from the meso point of view.
Several programming concepts like role, caste and corresponding programming models (e.g., role enactment, join/quit caste, etc.) support the dynamic integrations of agents, including migration of an agent into a caste or participation in an organization. Caste in [66,72] is designed as an abstraction of a set of agents with the same pattern of states, actions, behaviors and environments. However, different from that an object is bounded to its class statically and persistently, an agent is desired to be bounded to its castes dynamically, i.e. it may join to or quit from a caste at runtime. When an agent joins a caste, it obtains the behaviors defined in the caste and therefore can interact with the agents declared in environment of the joined caste. The bounded castes by agent can be in different state, e.g., active state or inactive state. Role describes the expected behaviors and properties of agents in an organization. It consists of a set of normative behavior rules, a set of expected objectives and a specification of the information that is expected to be available to agents playing that role [21]. Various role enactment mechanisms and models are proposed in several AOP languages to implement the role dynamic of agents, e.g., enactment and deactment of roles in 3APL [21], the join/quit/suspend/resume roles in OragentL [39]. Enacting a role by an agent means that the agent adopts the role and therefore integrates into the system or organization that defines the role. The integration also means that agent becomes one member of the system or organization, and can interact with other members in the system or organization.
The agents in systems or organizations should interact with each other in order to achieve the design objectives. One way to realize the interaction among agents is to directly communicate with each other in term of speech acts specified by agent communication language like KQML and FIPA ACL. In this approach, various speech acts are designed as programming concepts to support the interactions of agents. For example, Agent-0 [59] provides “inform”, “request”, “unrequest” speech acts to support agents’ communications. Agent-K [22] extends the interactions capability of Agent-0 by introducing more speech acts. Many AOP languages provide programming concepts like event and message to offer alternative ways to implement interactions among agents. In this approach, interactions are realized in term of explicit event manipulation and message sending based on message filtering and broadcasting mechanism or event subscription mechanism. For example, agents in Concurrent MetateM [31] and Goal [37,43] can send and receive messages in a broadcasting way; ConGolog [24] introduces three specific actions to support the sending, sensing and receiving of messages; In JAL [58], agent can interact with each other by explicitly defining external events and “@send” statements; agents in Go! [12] communicate and coordinate using asynchronous messages, synchronisable access and update of shared data.
The interactions of agents can also be realized in term of indirect behavior observations or environment sharing. In order to support such kind of interactions, the programming concepts like environment, observation are presented in AOP languages. In SLABSp [66], programmer can explicitly define the environment of agents to specify what the behaviors of other agents in the environment should be observed. The occurrences of behaviors result in the events to be perceived by the observers and therefore achieve interactions. 3APL [42] supports the indirect interaction through the shared environment that is implemented as a Java class such that its methods correspond with the actions that agents can perform in the environment. Agent’s interaction in simpAL [56] is based instead on the concept of use and observation, reminding the way in which artifacts are used by people in human environments.
A recent trend on AOP study is the explicit programming of environment of agents and multi-agent systems. In cyber-physical systems and social technical systems, environment plays important role to understand and implement interactions of agents. They can take forms of physical ones and social ones. Several AOP languages support environment programming like SARL [57], PLACE [35], Coordination by Social Engagement (CoSE) programming approach [3].
Programming multi-agent organizations
Agents in MAS are individually autonomous in essence. However, the autonomy of the agents may cause loss in global coherence and should be collectively regulated to some extent, especially when they are distributed in deployment, decentralized in management, and evolving in dynamic organizations and open environments. Agents in system are expected to be organization-aware, i.e., with the capability to understand and reason about the structure, work processes, and norms of the organizations in which they operate [64]. The AOP program for multi-agent organization provides the connection between agents’ individual behaviors and organization context and regulations like rules, norm, institutions, etc. Such program enables agent to produce coherent and consistent behaviors by considering both its individual design objectives and global organization constraints, and therefore to obtain expected emergence of the whole organization. The programming concepts for multi-agent organization provide abstractions to support the implementation of social and organizational issues from the macro point of view, such as organizing agents, regulating their behaviors, etc. There are two critical issues that should be tackled when developing such software systems. One is the abstractions and formations of multi-agent organization, another is the regulation and management of agents’ behaviors in the organization. Diverse approaches are used in AOP languages to deal with the issues, like organizational models, normative systems, or electronic institutions [17]. Organizational and social concepts are often proposed to support not only the modeling and analysis, but also the programming and implementation of such kind of software systems [48].
The solution to the first issue is to provide programming concepts and corresponding models to describe the program of multi-agent organization. These concepts enable programmers to organize and decompose their programs in a natural and effective way. They also enable agents in the organization to take appropriate behaviors in the organization context and adjust their positions to adapt to changes occurring in the organization. Several programming concepts in existing AOP languages are proposed to tackle the issue, e.g., organization, group, role, etc. For example, OragentL [39] provides programming concepts like organization, group, role class, etc., to organize program and encapsulate agents that are capable of self-adaptation in organization context.
The way to solve the second issue is to introduce the regulation concepts and mechanisms into AOP languages, e.g., norm, regulation, etc., that can be viewed as behavior standards. Typically, they can take forms of obligation, permission and prohibition. There are two ways to implement regulations in existing AOP languages. One is regimentation approach, the other is sanction/enforcement. In regimentation approach, also called as endogenous way, the agents are implemented so that they decide their behaviors by explicitly considering their internal components and organization norms or rules. In sanction approach, also called as exogenous approach, organization components like norms are implemented as an external software entities that monitors, evaluate and intervene the behaviors of individual agents in the organization. There are several AOP languages and approaches supporting the regulation of agents in multi-agent organization, like 2OPL [18,63], N-2APL [2], NOPL [18,40], and [62].
AOP languages
Since Agent-0 was presented at the beginning of 1990s, there are dozens of AOP languages designed for different programming objectives. The variety of AOP concepts and models results in the designed AOP languages are also diverse. Various language constructs based on different programming concepts and metaphors are integrated into AOP languages that have different programming styles. Most of AOP languages are descriptive style (e.g., GOAL [37]), while other are imperative (JAL [58]) or hybrid style (e.g., simpAL [56]). Some AOP languages are designed from scratch, like SLABSp [66] with its specific syntax and semantics. However, most of AOP languages are actually kinds of logic programming languages (e.g., temporal logic, first-order logic), e.g., Concurrent MetateM [31], ConGolog [24], Agent-0 [45], or the extensions to some mainstream programing language with Java-like syntax (e.g., JAL [58]). Most of AOP languages have rigorous semantics definitions and solid theory foundation, like agent theory (e.g., DALI [15,16]), situation calculus(e.g., ConGolog [24]), ambient calculus (e.g., CLAIM [28]), transition system, fluent calculus (e.g., FLUX [60]), etc. The programs written in these AOP languages can be executed in multiple ways in term of interpreter, framework, platform or virtual machine (see Section 4.3). According to the programming styles [67], the existing AOP languages can be classified as imperative-style, declarative-style and hybrid style [8,17] (see Table 2).
Descriptive AOP languages has Lisp-like or Prolog-like syntax style, and provide descriptive language constructs to represent and reason programming concepts. They typically have strong formal nature normally grounded on formal logic and agent theory (e.g., BDI theory, situation calculus), and are much easier to implement the reasoning of autonomous agents and regulation of agents’ behaviors by adopting the cognitive concepts like belief, knowledge, goal, intention, plan, etc. [17], or the organizational concepts like norm, rule, etc. The program of agents implemented with such kind of AOP language typically have autonomous and pro-active behaviors. AOP languages with programming concepts of cognitive abstractions (e.g., belief, intention, goal) and multi-agent organizations (e.g., norm, prohibition, obligation, etc.) typically belong to this kind of programming style, e.g., 2OPL [18,63], NOPL [40]. Most of descriptive AOP languages are the extension to logic languages like first-order logic or temporal logic. For example, AgentSpeak(L) [54] is a restricted first-order language; GOAL [37] uses Prolog to represent the knowledge, beliefs, and goals of an agent, Concurrent MetateM [31] is an executable temporal logic. Normally the programs written in descriptive AOP languages are executed in term of interpreter.
Imperative AOP languages are based on the commands that update the variables in the programs [67]. Typically the language constructs of variable and commands should be provided in such kind of programming languages so that programmers can explicitly define program’s state and action. Imperative AOP languages also provide explicit language constructs to represent procedural information and structure commands to implement the AOP concepts like plan, task, action, capability, etc. In syntax they are often the extensions to existing imperative programming languages like Java (e.g., JAL [58]) or have the similar syntax formats with traditional imperative languages (e.g., CAOPLE. [72]). Therefore, such kind of AOP languages tend to be accepted by programmers as the tight relationship with the mainstream programming languages like
Lists of agent-oriented programming languages
Lists of agent-oriented programming languages
Hybrid-style AOP languages combine declarative and imperative features. The language constructs in descriptive AOP languages are designed for programming cognitive components (e.g., belief, goal, etc.) or organizational components (norm, obligation, prohibition, etc.), while the imperative language constructs are to program the behaviors and actions of agents and further are designed as a means for interacting with the legacy codes implemented in some imperative language like Java [8]. The semantics of hybrid AOP languages are often defined in several manners like transition systems (e.g., 2APL [50]). There are a number of AOP languages with hybrid style. For example, 3APL [42] inherits full range of regular programming constructs from imperative programming (including recursive procedures and a notion of state-based computation), and the proof as computation model and Prolog-like representations from logic-based programming as a basic means of computation for querying the belief base of an agent. The program written in 3APL allows the integration with Prolog and Java. Go! [12] is a multi-paradigm agent programming language, with a declarative subset of function and relation definitions and an imperative subset comprising action procedure definitions, and rich program structuring mechanism [8]. In 2APL [50], the cognitive components of agent like beliefs and goals are implemented in a declarative way, while action, plans and (interfaces to) external environments are implemented in an imperative programming style. The declarative programming constructs support the implementation of reasoning and the update mechanisms to allow individual agents to reason about and update their mental states. The imperative programming constructs facilitate the implementation of plans, flow of control, and mechanisms such as procedure call, recursion, and interfacing with existing imperative programming languages.
Most of AOP languages claim they are not designed for specific domains, which means they can be used to develop a wide range of applications. However, as the restriction of programming concepts, program models, language constructs, programming and execution styles, any AOP language has its strengths and weaknesses in developing software. Descriptive AOP languages with cognitive programming concepts and cognitive reasoning model seem more suitable for developing software systems in which agents have the reason capabilities and can take autonomous, pro-active behaviors, i.e., knowledge-intensive applications. Such kind of AOP languages like Agent-0 [45], Concurrent MetateM [31], ConGolog [24], Meta-APL [26], etc., seem unsuitable for data-intensive applications that need language constructs to represent data and their operations, or real-time applications that need to respond to events or changes in a time-fashion way. Some AOP languages however introduce particular programming concepts and mechanisms to satisfy specific programming requirements. For example, CLAIM [28] adopts specific syntax and semantics like ambient calculus that seems particularly suitable for mobile computation. OragentL [39] provides self-adaptation constructs and mechanisms in term of organizational concepts and enables programmers to develop self-adaptive software. Some AOP languages are designed for specific requirements like robotics [73].
Table 2 lists AOP languages proposed in both academic and industry and describes their characteristics including programming style, programming concepts, and CASE tools. The list is by no means complete. The ones chosen to list depend on the publications we can find and their representatives. Moreover, some AOP framework like Jade, Jadex, etc., are not listed in the table because they are considered as AOP languages.
Undoubtedly programming language is not enough when we intend to develop high-quality software in an effective and efficient way. In order to aid the programming activities and the execution of AOP programs, the underlying computer-aided software engineering (CASE) tools and even the integrated development environments (IDE) should be provided together with the programming language. According to the functionalities that CASE tools provide and the objectives that CASE tools achieve, the AOP CASE tools can be roughly classified into two categories. One is the development tools that aid the programmers’ development activities at design-time, e.g., editing and compiling programs, debugging and checking the program codes. The other is the running tools that aid the running, analysis, monitoring and management of the target program codes at run-time. The former is provided for AOP programmers while the latter is developed for AOP programs.
Development tools for AOP programmers
During the programming process, several development activities should be performed by programmers, including editing, compiling, testing, checking and debugging the program. The AOP CASE tools support the above programming activities so that programmer can perform these activities in an efficient and effective way.
At the early phase, the AOP researches normally focused on the design of programming languages and their running supports (e.g., interpreter), and neglects the provisions of AOP development tools and supports. However, recent researches pay much more attention on the development tools and even integrated development environments, e.g., JDE (JACK Development Environment) [58], because they are prerequisite to make the languages to be widely accepted and adopted by the software engineering practitioners.
The existing AOP languages provide various development tools supporting programming activities, ranging from program editor, debugger, compiler, to program tester and checker. For example, 2APL [50], Jason [10] and 3APL [42] provide editor and debugger to help programmers to write programs and find bugs in programs; the debugging tools of GOAL [37] include introspectors for inspecting agent states, stepping functionality, (conditional) breakpoints, runtime querying and modification of agent states, tracing and logging functionality at different levels of granularity, and basic performance measurements of Prolog queries. It also provides program analysis tool to help programmers analyze the code (e.g., creating an overview of predicates used in a program). The code generating tool in JDE is provided to automatically generate the program codes in JAL according the high-level design model. JDE is also responsible for maintaining consistency between the design diagrams, the underlying model and therefore with the generated code. Most of these development tools provide graphical user interfaces for programmers and are typically designed as plug-in into IDE like eclipse.
Many of AOP development tools are integrated with each other as a whole development environment to support the knowledge and data sharing. For example, JDE provides integrated development environment for JAL programming, including project management, code editor and debugger; simpAL [56] provides an Eclipse-based IDE organized in plug-ins that include an xtext-based editor and a compiler; AgentFactory Development Environment (AF-DE) is a complete agent prototyping environment for AF-APL [58]; the program of GOAL [37] is distributed with an integrated development environment for coding, testing, and debugging. Some AOP languages like simpAL [56] provide various development libraries as tools, including a system library with artifacts providing basic system functionalities related to I/O, GUI, file system access and a utility library with artifacts providing coordination functionalities (e.g. blackboards, tuple spaces, etc.). These front-end development tools are necessarily integrated with the proper back-ends runtime infrastructure.
Running tools for AOP programs
The programs written in AOP languages should be executed in some way. The running CASE tools implement the semantics of AOP languages, and provide the supports of program executions and management in term of infrastructures and services. The main functionalities of running CASE tools are to manage vast number of running entities like agents, environment, groups, organizations, etc. Therefore, various fundamental services should be provided in the running infrastructure, including lifecycle management, naming service, entities registration and query (e.g., white page and yellow page of agent information), agent monitoring, etc. Some specific management devices like mobility of agents, self-adaptation, etc., also should be provided for specific AOP languages like OragentL [39]. Furthermore, services for supporting the interactions among agent and environment should be provided, including event (e.g., event subscription), message-passing, coordination protocols, environment percept, ACL interfaces, and the corresponding safety and security. For example, JACK [58] provides infrastructure such as message marshalling and a name server for executing agents. 3APL [42] platform consists of a directory facilitator called agent management system (AMS), a message transport system which delivers messages between agents, a shared environment, and a plugin interface that allows agents to execute actions in the shared environment. JACK also provides various facilities such as the sniffer to monitor the exchanges of messages between agents and the changes of all mental attitudes. SyMPA, a multi-platform for CLAIM [28], provides agent system that supports agents’ creation, identification, management, execution and migration. The running environment for simpAL [56] provides a launcher and a distributed runtime infrastructure called simpAL OS to load the program to execute on runtime infrastructure. A state tracer tool is provided through which one can browse through an agent’s states generated by the execution of its corresponding agent program of 2APL [50]. The AgentFactory Runtime Environment (AF-RTE) includes a platform management suite that can hold a number of running agents at any time, and an optional graphical interface to view and manipulate agents and the platform [58].
Execution manners of AOP program
The programs written in existing AOP languages can be executed in several manners based on the provided CASE running tools like interpreter, framework, platform and virtual machine.
Challenges and future directions of AOP studies
In this section we discuss some challenges and future directions of AOP researches by investigating several important programming language design principle proposed in the field of software engineering and the extent to which the AOP studies satisfy these principles. These design principles are proved to be effective and practical to guide the successful design of programming languages.
Undoubtedly, to design a programming language for industry applications is actually a great challenge. Its success largely relies on the extents to which the language is extensively adopted by the programmers and widely used in various applications. Until now a great variety of programming languages have been proposed in the field of software engineering. However only a few survive and still be used in industry, most of them disappear. The technical novelty and programming capability of a programming language does not signify its success. In the study history of programming languages, there are many instances of excellent programming languages (e.g., Smalltalk) that are novel in programming theory (e.g., original programming concepts and models) and successful in academic, but fail in practices and ultimately are abandoned by software engineering practitioners [11].
In software engineering field researchers attempt to find the essential knowledge and fundamental principles behind the successful software engineering researches and practices [49], especially the designs of programming languages [67]. These principles are stable and effective to act as the guidelines to support the design of successful programming language.
Simplicity and regularity of AOP concepts and models
There are at least two important software engineering principles tightly related with the design of AOP concepts and models. The first is simplicity, which means the language should be designed as simple as possible, natural to express the solution, and easily to be understood and mastered by the programmers. The second is regularity, which means the extent to which the concepts are combined together to design a language, avoiding simply piling and unnecessary duplicates [67].
The variety and difference of programming concepts in AOP researches and practices (see Section 4.1) challenges the regularity and simplicity design principles. AOP concepts come from multiple disciplines with different programming objectives. They should be combined together into the AOP languages to deal with programming issues of large-scale and complex applications, and to exploit the potential of agent-orientation. Some AOP concepts like belief, knowledge, desire, goal, intention, etc., are abstractions from artificial intelligence and cognitive science and used to program the individual agents, others like organization, role, norm, obligation, sanction, etc., originate from organization sociology and are used to program multi-agent organization. Moreover, many of programming concepts (e.g., belief, or intention) have no agreed meanings and therefore are implemented in different ways. Some AOP concepts (e.g., desire and goal, intention and plan), though they have different terms, actually have similar semantics and are implemented with similar meanings. For example, the programming concept of goal in some AOP language is implemented with procedural feature to describe the action sequence that an agent wants to perform, while in other AOP languages it is implemented with descriptive feature to represent the state that an agent wants to reach. In some AOP language the intention of agent is actually implemented as the plan that agent commits to perform. For most of AOP programmers the main problem of using AOP languages is the great cognitive gap between the concepts underpinning mainstream languages and those underpinning AOP [14]. This phenomenon violate the simplicity principle and result in the confusion in concepts and vague in programming. The AOP language design should adopt the minimality of programming concepts with clear and unified meanings to satisfy AOP requirements.
The varieties and differences of AOP concepts also result in the necessity to investigate the relationships among these concepts, and the complexity to combine these concepts as a whole to support AOP. Undoubtedly AOP language design should clarify how these programming concepts work together to form the program model and support the composition and running of AOP program. However, the great diversity and high-level abstractions of AOP concepts increase the difficulties to understand and explain their dependencies and correlations. In multi-agent system area, there are numerous researches to examine the inter-relationships among cognitive concepts like belief, desire, intention, etc., and that with the interaction behaviors, e.g., the BDI and KARO theory of rational agents, whole-hearted satisfactory semantics of speech acts. However, there are few researches investigating the relationships between the cognitive concepts (e.g., belief, goal) and the organizational concepts (e.g., role, organization, norm). The designer and programmers of AOP language are difficult to understand how the macro-level organization components (like norm) of the whole systems influence the micro-level cognitive component (like goal) of individual agents in the system. Therefore, to combine various programming concepts in an integral, coherent and consistent way is a great challenge in the researches and practices of AOP languages.
The program models in existing AOP languages are diverse as the variety of programming concepts. Agents in some AOP languages are designed as pure knowledge system consisting belief and knowledge, or cognitive systems with belief, goal and intention, etc., while in other AOP languages they are designed as organizational entities composed of various organizational concepts like role. The interactions among agents and environments can be implemented in several different ways, ranging from speech act, message passing, event mechanism and environment sharing to behavior observation. Inevitably, the variety of program models may confuse programmers to select appropriate AOP languages for their development tasks. Moreover, it also may result in the programs written in different AOP languages are difficult to inter-operate with each other.
According to the principles of simplicity and regularity, and the challenges of existing AOP researches described above, the future studies of AOP should (1) simplify and standardize the programming concepts of AOP so that they are as simple as possible, easily to be understood, and have unified meanings, (2) investigate and clarify the relationships among various programming concepts of AOP, establish solid theoretical foundations for combining these concepts together in a coherent and tight coupling way. (3) unify and standardize the program models of AOP to implement software systems with standard software architecture.
Maintainability, expressiveness and reliability of programming language
There are three important software engineering principles tightly related with the designs of programming constructs and languages. The first is maintainability, which means the extent to which a programing language promotes ease of program maintenance, including well-structured program, program readability and understandability, development efficiency, etc. The second is expressiveness, which means the design of programming language should provide enough ability to achieve the design objectives, including expressing complex computations and data in appealing and intuitive ways. The third is reliability, which means the programming language should be designed in a way that errors in program can be easily detected and eliminated, the unexpected behaviors can be flexibly processed, and therefore aiding the design and development of reliable programs [67].
The existing AOP languages provide varying capabilities to support programming from several aspects, including individual agent, interaction among agents, and organization regulations, etc. However, in addition to the programming capabilities, the quality of programs, especially the maintainability, should also be considered when designing AOP languages. In the long-term researches and practices of software engineering, several important language constructs and mechanisms that are proved to be useful to improve the quality of program have been identified, including encapsulation, modularity, inheritance and reuse, information-hiding, etc. They achieve successes in several programming languages and their applications, e.g.,
Moreover, novel language constructs and mechanisms that are compatible with AOP paradigm and capable of exploiting the potentials of AOP should be proposed to improve the expressiveness and maintainability of AOP language. They should extensively consider the programming requirements of complex software systems (e.g., the increasing scale of system, the openness of the environment, dynamic and unpredictable changes in both environment and system itself, the demands of system flexibility and robustness) and technical characteristics of AOP (e.g., the autonomy and situatedness of individual agent, the flexibility and society of multi-agent system, etc.). For example, the language constructs and mechanisms for expressing and encapsulating self-adaptation, self-organization, self-management, organization norm [33], etc., should be incorporated into the AOP languages. They provide ability to express complex computations that are popular in kinds of complex applications and support the development of self-adaptive, self-organizing and autonomic systems. We believe AOP can provide underlying for these complex applications. There are several AOP languages that attempt to deal with these challenges like OragentL [39], CAOPLE [72], 3APL [20,42], etc. For example, [25] propose a programming constructs for constraints and content/context sets of multi-agent organization, which provides sufficient expressive power to allow us to represent a wide range of organizational structures for multi-agent systems.
Reliability is another important aspects of high-quality program and fundamental principle to guide the design of programming language. There are many programming language constructs and mechanisms that are helpful to improve the reliability of programs, like type system [14], exception processing, etc. They are proved to be effective in software engineering practices and successful in OOP. However, few AOP languages consider the reliability issues when designing AOP language. Therefore, how to introduce the language constructs and mechanisms into AOP language is an open issue in AOP researches and practices. Type system in programming language enables programmers to associate types with variables or other expressions. The type checking of program at compile-time can improve code quality and reduce programmer’s burden. Some AOP languages (e.g., Go! [12], OragentL [39], simpAL [56]) intend to introduce typed system into AOP languages. Go! [12] is a strongly typed programming language that meets strict software engineering best practices. simpAL [56] use the notion of task to define a notion of type for agents in order to improve error checking at compile time and define and exploit a sub-typing relationship among roles. OragentL [39] however provide typed mechanisms for AOP language.
According to the maintainability, expressiveness and reliability principles and the challenges of existing AOP researches described above, the future studies of AOP should consider the maintainability, expressiveness and reliability issues when designing AOP languages. Software engineering best practices should be incorporated into the language designs and some proved software engineering principles like encapsulation, information-hiding, software reuse, etc., should be implemented in the AOP languages in term of various programming concepts (e.g., role class, agent class, caste) and language constructs (e.g., role inheritance). We believe they can improve the maintainability of the programs to some extent. Moreover, various novel language constructs and mechanisms that are specific and compatible with AOP paradigm should be presented in order to satisfy agent-oriented programming requirements and exploit its potentials. The expressiveness of AOP language should be enriched to support the development for complex software systems that are self-adaptive, self-organizing, self-management in open operational environment. This will be an important direction to exploit and prove the technical potentials of AOP. Therefore, various metaphors and mechanism should be borrowed from multiple disciplines and integrated into the AOP language designs, e.g., self-adaptation and re-organization of society. Reliability aspects like checking errors or processing exceptions should be considered when designing AOP languages. The type theory for AOP languages and various mechanisms like exception handing, etc., may become important topics of AOP researches and practices. In addition, the interoperation between the programs implemented by AOP with the programs written in mainstream programming language (e.g., OO software and web service software) should be considered and the designs of AOP languages should allow for integration with (legacy) code, especially ones like service-oriented software, intelligent software, etc.
Efficiency of CASE tools
Efficiency is another important software engineering principle for programming language design. It means the extent to which a language design facilitates the development and production of efficient programs. It depends on several aspects of programming designs, and is more related with the programming CASE tools.
Though many AOP languages have been proposed in academic and industry, only a few provide rich CASE tools to support programming (see Table 1). Most of AOP languages provide CASE tools for the running of AOP program, but lack of necessary CASE tools for developers, e.g., software packages for reusing common functions and debuggers to find and position the potential errors in the program. As the autonomy of individual agent, complex interactions, and unpredictable changes and events, the testing and debugging of AOP programs become a great challenge for AOP researches and practices. According to the discussions in Section 4.3, the running efficiency of AOP program greatly depends on the program execution manners. In fact, when the scale of agents in the system increase, the running efficiency will become a big problem. However, few AOP languages and their running supports discuss the issues of efficiency and their solutions. The run-time systems of some AOP languages like Go! offer additional support for safe programming in the form of a code verifier. Undoubtedly, running verification will bring about running efficiency and performance problems.
There are several directions guiding the future researches of AOP in CASE tools. The first is to provide effective industry-strength software tools to support the verification and validation of AOP programs, especially the debuggers and tester tools. Several researchers emphasize their significance in agent-oriented software engineering. They are prerequisite to put the AOP languages into practices. The industry-strength CASE tools and environment must be robust, easy-to-use, friendly, complete with documented supported. The second is to develop reusable packages or deploy fundamental services for AOP languages. They should encapsulate common functions like graphic interface, natural language process, etc., and can be reused or accessed by AOP programs. Various high-level design patterns can be incorporated into the designs of AOP languages and supporting CASE tools. The third is to optimize the efficiency and performance of AOP programs and their running CASE tools.
Conclusions
In the past years, AOP has become an important research branch of both software engineering and artificial intelligence. The study history of AOP roughly cover two different phases, each of which has its specific purposes, concerns, researchers and practitioners, approaches and technical characteristics. AOP research was originally based on the MAS theories and technologies in the field of artificial intelligence, however recently it intersects multiple disciplines, including (distributed) artificial intelligence, software engineering, cognitive science, organization sociology, natural language processing, etc. Until now, dozens of AOP languages have been proposed and they are diverse in syntax, semantics, programming style and capability, execution manners. There are a wide range of potential applications, including UAVs, surveillance, air traffic management, real-time scheduling, and virtual actors [58]. Several attempts have been made to facilitate the applications and practices of AOP like multi-agent programming contest [68].
However the acceptance and adoption of AOP in software engineering community remain limited. Most of AOP languages are used in Lab and academic field, only a few of them (e.g., JAL) claim they have obtained successful applications in industry. The current practices of applying AOP do not convince such programming paradigm has extensively exploited its technical advantages and potentials to tackle the engineering issues of emerging complex applications, e.g., large-scale social technical systems. Few attempt to tackle the complexities of modern software programming as the features like concurrency, decentralization, distribution, interaction, and adaptation, etc. Most of AOP researches emphasize on the theoretical aspects and prototyping of AOP language in the context of artificial intelligence [56], which results in many AOP languages are based on logic with feature of reasoning capability. From software engineering perspective, the focus of these works so far are mainly on the design of AOP languages rather than the practicability, usability, effectiveness and efficiency of using AOP languages in dealing with the development issues resulting from the software engineering requirements and challenges. This requires us to review the state-of-the-art of AOP and rethink the ways to guide the researches and practices of AOP.
Different from other programming paradigms in software engineering, existing AOP languages are diverse greatly in the programming concepts, program models, language styles and CASE tools. Some AOP languages are based on cognitive concepts and devoted to develop autonomous agents in descriptive way, others integrate cognitive concepts and organizational concepts together to develop multi-agent organizations in descriptive and imperative way. Agents in some AOP languages interact with each other in term of speech acts, while agents in other AOP languages interact with each other in term of explicit event or implicit observation. It is difficult for software developers to select proper AOP language for software development project and the software systems programmed in different AOP languages are difficult to inter-operate and integrate together.
To design a programming language for industry application is actually a great challenge. In addition to the novelty and effectiveness of programming approaches, the design of programming language should follow a number of software engineering principles, including simplicity, regularity, maintainability, expressiveness, reliability, efficiency, etc. These principles are proved to be effective to guarantee the designed programming language can support industry-strength software development. The future researches of AOP should simplify the programming concepts and standardize program model, incorporate more software engineering best practices (e.g., encapsulation, information-hiding, software reuse, etc.) into the AOP language designs, consider the maintainability, expressiveness and reliability issues, enrich the language constructs and mechanism to support the development for complex software systems, and provide industry-strength CASE tools for aiding various programming activities (ranging from editing to testing) of programmers and the flexible and efficient running of AOP program.
Footnotes
Acknowledgement
This work is financially supported by National Nature and Science Foundation of China under Granted Nos. 61379051 and 61532004, Program for New Century Excellent Talents in University under Granted No. NCET-10-0898.