Human-centered software development methodology in mobile computing environment: agent-supported agile approach
© Eom and Lee; licensee Springer. 2013
Received: 17 March 2013
Accepted: 3 April 2013
Published: 24 April 2013
Due to the large demand of the services from the wireless networked computing environment, the capacity and performance of wireless devices, platforms, and applications are improved. Especially, in recent years, the use of mobile applications has increased dramatically along with the concept of ‘smart’ phone. As a result, the center of human e-life has been transferred from a conventional desktop space to a mobile wireless computing environment. These rapid changes also generate additional requirements for more sophisticated and complex functionalities in wireless computing environment such as personalization or adaptation which result in the requirements of ‘human’-centered software development methodology in wireless computing environment. Although there are well-known classical software development methodologies such as waterfall, they do not fit to the characteristics of wireless computing environment. Instead, the agile software development methodology is generally used to deal with dynamically changing requirements in wireless computing environment. However, agile software development methodology is knowledge- and labor-intensive and does not fully cover the requirements that are essential to the wireless computing environment. In this paper, we analyze the requirements of mobile applications in wireless computing environment and propose a human-centered software development methodology which is to integrate agile philosophy and agent technology. Additionally, we employed the concepts of software product line engineering in order to understand and represent the variability of dynamically changing requirements. Consequently, what we propose in this paper is an agent-supported agile-based mobile software development methodology in wireless computing environment for supporting adaptive requirement changes and their automatic implementation. In order to demonstrate the feasibility of the proposed approach, we have performed two experimental case studies by developing android mobile applications.
From the above observations, we focus on three problems. Firstly, there is no existing applicable software development methodology that reflects the characteristics of MCE and its adaptation requirements. Secondly, additional requirements of software adaptation keep accumulated on top of existing requirements by adding the increased complexity of software and its engineering process. Lastly, a well-structured information processing lifecycle is needed to model, analyze and retrieve the complex and sophisticated information from the dynamically changing users, systems and the environment. Thus, our approach integrates agile philosophy and agent technology to resolve the above problems. The proposed framework (in Section 5.4), which adopts the human-centered software development methodology, is based on the hybrid use of the above two concepts.
2. Problem statement
As described in the previous section, there are some problems on the process of mobile software development. Those problems are as follows:
Conventional software development methodology cannot be applied to the mobile software development.
The complexity of mobile software engineering is increasing.
Knowledge- and labor-intensive processes create additional burdens.
Firstly, the MCE is different from the conventional computing environment. The lifespan of mobile software is quite dependent on the usability, and this usability is also dependent on the user requirements. Requirements from mobile software users are variable and capricious. Thus, if we want to make a long-term mobile application on the MCE, it is critical to reflect and satisfy the dynamically changing requirements. Also, the accuracy of processed information for adaptation is important. The MCE has limited resources, including memory, battery, and display. Therefore, developers are required to consider these limited resources. These differences and restrictions make the conventional software development methodology inapplicable for the mobile software development. The additional requirement of adaptation also pulls variable cases and variants, which should concern the developer. In other words, the applications in the MCE need to be more intelligent. They need to recognize the dynamically changing environment and properly react to those changes. To develop such application, the conventional development methodology is not sufficient. Therefore, some labor- and knowledge-intensive processes and complexities exist in the background of realizing adaptation, and this is why the novel development methodology is proposed in this paper.
2.2. Objectives and propositions
In this research, our study aims to analyze the design of the software development methodology specialized in adaptive mobile-software development. The purpose is to find a way to control the complexity and to reduce burdens during the process of adaptation realization. In detail, we have several propositions which are as follows:
Reflecting features of the MCE
Reflecting the adaptation requirement
Controlling complexity on adaptive mobile software engineering
Reducing loads from labor- and knowledge-intensive process of developers
Improving accuracy and functionalities
Basically, the features of MCE have to be reflected onto the methodology, not to miss the factors affecting the usability of the mobile application. Through this, developers can avoid the risk of an early buried and dead application. Then, we should reflect the adaptation of the found factors. These factors become the requirements of the development, and they need to be adapted into the mobile software development process by the adaptive functions. After reflecting additional requirements, the complexity, which is increased by the dynamically changing requirements for the adaptation, needs to be managed. Finally, for more usability of adaptation, sufficient accuracy of information and functionalities of application must be achieved.
3. Related works
3.1. Features of mobile computing environment
MCE includes the environment of the mobile software's execution and the environment of the mobile software's development. The MCE has more limitations compared to the conventional computing environment. Most of them are the constraints on resources, which are as follows:
Memory. The amount of memory that the application can use is limited by constraints of resources.
Battery. The amount of the power consumption is limited by the physical size of the mobile devices and the impossibility of power supply.
Display. The size of display is limited, so that the arrangement of information and view needs to be considered.
Signal. As many functions of the application are based on network environments, the stability of signals is required.
Speed and smoothness. To keep the real-time usability present in the user's life, the speed and smoothness of mobile software have to be assured.
Maintenance. To satisfy changing requirements and updating new information and functions, continuous upgrade and communication with users are needed.
Because of these constraints, mobile applications avoid constructing huge data structures and weighted computations, and pursue compactness and lightness. In addition, users on MCEs need to be active to express opinions on applications they frequently use, and these requirements are various and variable.
3.2. Agile software development methodology on MCE
The agile software development methodology was proposed to resolve the problems of conventional software development methodology, which shows stiffness and intensive labor on the preparation and document process . Thus, the agile methodology focuses on the member's capability, synchronization, and sustained deployment of products. By these principles, the software development process based on agile methodology generally includes the iterative and evolutional development processes  such as Scrum and XP [3, 4]. Due to flexibility and short-term iteration of the agile process, the agile methodology is usually applied to mobile software projects . Thus, the agile methodology has been discussed for mobile software development like the Mobile-D project . However, there is no widely agreed software engineering process for the MCE which considers the dynamic requirement adaptation.
3.3. Agent and software product line
An agent is an encapsulated computer system that is situated. From the establishment of this definition, the study of agent-oriented software engineering (AOSE) or agent-based approaches for software engineering has been researched steadily . AOSE is to adapt the agent concept to software engineering in order to control the complexity field, called as AOSE by Jennings and Wooldridge [8–10].
Software product line engineering (SPLE) is a field of software engineering involving the production of serial applications through distinguishing variable parts from unchangeable parts. The domain and variability concepts of SPLE are used to express the variable and common components in a software system. Presently, these concepts are used to describe the architecture of an adaptive software system as a changeable software at runtime. In SPLE, adaptive software is regarded as the system containing the different software at a different case in one product line. Through using SPLE concepts on engineering an adaptive software system, systems and developers can realize where and how the system changes.
Now, we introduce our solution and approaches to the problems described above. Basically, our solutions are based on the hybrid of three concepts: agile, AOSE, and agent technology. That is, these approaches were developed through combining three ideas, which look isolated at first glance. Therefore, in this section, we explain how those key ideas are combined and used to build our solution.
4.1. Mobile computing environment and agile
As seen through the explosion of the popularity of mobile devices and applications, mobile software supports many services with or without the support of a desktop settled on human life. Hence, requirements for improved function and service approach need to be considered. To satisfy their requirements, developers have to speed up the progress of engineering and strive to produce good performances during relatively tight schedules. Moreover, mobile software and devices have inherent constraints, which produce additional requirements concerning processes.
Agile software development methodology is already used for the development of mobile software for the reason that the agile methodology is capable of covering some critical features of the MCE:
Various requirements. In the MCE, mobile software requirements are changeable for various reasons like the user's needs, capabilities of devices, platforms, etc. Thus, for mobile software development processes and maintenance, frequent tests and revisions are needed to reflect various requirements of users and markets.
Labor- and knowledge-intensive. For dynamically changing requirements and relatively strict terms for development, project members go through many turning points and iterative processes. Moreover, the quality of their results and development processes rely on the capabilities of the project members. Therefore, modern mobile software requires much knowledge and labor.
Human-centered. As functionality and usability are directly related to the life of mobile applications, human-centered functions and interfaces are required to improve usability and functionality.
Generally, a conventional software development methodology cannot deal with these features of the MCE. Unlike the conventional methodology, agile seeks to accept changes in the middle of processes and to continuously communicate with project members, including customers and business members. Agile places the highest importance on delivering valuable software. Thus, the above features of MCE, except for the second characteristic, can be supported by the process and principles of the agile methodology. Consequently, in this study, we choose agile as the basic philosophy of our mobile software development methodology.
4.2. Agile and agent technology
As we mentioned, the software development process based on agile basically has iterative and evolutional processes to reflect requirement changes actively. Because of the rapid process, intensive labor and knowledge are required of developers, indicating that agile cannot solve the second aforementioned characteristic of MCE. In particular, the burdens on developers of the processes increase when they want to satisfy the additional adaptation requirements because adaptation includes a high-level information processing. Also, the rapid process repeats tests and inspections until the requirements are sufficiently met. Suppose we have a technical support on these burdening processes, and then we can reduce the load of knowledge engineering. In order to do that, the technical support has to possess the ability to collect widely spread information and to process collected information, like reasoning and knowledge processing. Agent technology has features that could supply those abilities and agility, as it is autonomous, reactive, and proactive [11, 12]. Agent operates on the basis of knowledge (e.g., belief-desire-intention agent model [13–17]). Thus, agent technology can support the burden process based on information collecting and processing.
4.3. MCE and agent-oriented software engineering
In the field of software engineering, there exists a study about controlling the complexity of complex software systems by abstraction, using the agent concept called AOSE . In this study, systems are considered composite components with several sub-components recursively representing specific goals or objectives. Each component could be expressed as an agent, which is reactive, proactive, autonomous, and social. That is, the complex software system is an organic set of components operating autonomously to meet the objectives. In another study about controlling the complexity of software intensive systems through the agent-oriented approach, researchers said that there are remarkable improvements for some decomposable and organizational problems. Therefore, an agent-oriented approach for the MCE is beneficial. In addition, the features of an agent give flexibility and scalability to the system organization, which is needed to realize adaptation. Consequently, the AOSE approach reduces complexity and other potential abilities to adapt to the system.
5. Body of methodology
The mobile software development methodology proposed by this research is to resolve the problems caused by the complexity and variability of MCE. The proposed methodology uses the flexibility of the agile methodology, the technical capacity of agent systems, and the abstraction of AOSE concepts. For designing such a methodology, we discuss four phases: principles, concepts, processes, and technical supports.
Agile Principles as outlined from an article by Laurie Williams
Agile principles as outlined from an article by Williams
The highest priority is to satisfy the customer through early and continuous delivery of valuable software.
Changing requirements are welcome at the start of each iteration, even late in development; agile processes harness change for the customer's competitive advantage.
Business people and developers must work together daily throughout the project.
Projects should be built around empowered, motivated individuals with a shared vision of success; give them the environment and support their needs, clear their external obstacles, and trust them to get the job done.
The most efficient method for conveying information to and within a development team is through synchronous communication; important decisions are documented so that they are not forgotten.
Valuable, high-quality software is the primary measure of progress at the end of a short time boxed iteration.
Agile processes promote sustainable development. The sponsors, developers, and users should be able to maintain a constant pace indefinitely.
Continuous attention to technical excellence and good design enhances agility and makes the product valuable through its usability and functionality.
Simplicity—the art of maximizing the amount of work not done—is essential.
The best architecture, requirements, and designs emerge from self-organizing teams guided by a vision for a product release.
For each iteration, the team should candidly reflect on the success of the project, its feedback, and how it could be more effective, then tune and adjust its plans and behavior accordingly.
As stated in principle 1, the most important principle of mobile software development is delivering valuable software to users continuously in the short term. Flexible processes and willing minds are needed to accept dynamically changing requirements from various users. Mistakes and misunderstandings have to be reduced through frequent communication and specifications of important changes and feedback. During these steps, developers should pay attention to technical excellence and preserve usability in order to make the product valuable to users. Moreover, important change-centered documentation is pursued instead of heavy documentation. The ultimate purpose of these principles of mobile software development is to produce a human-centered application valuable to real users through flexible processes and active communications.
We referenced several terms to explain certain concepts and artifacts within our process.
Requirement elicitation. A method of eliciting requirements, which are based on the user's situation and context, for mobile software development.
Conti. The material for description of a scenario composed of components like mobile software, agent, and external components. The material includes UI and view, data flows, and simple descriptions about the internal computation.
Profile. Information used for figuring out the environment and users for adaptation. Profiles are composed of processed information and a data structure.
Variable point. An asset differing in the behavior and its situation.
Variants. Descriptions of required behaviors to make a choice for the next branch in variable point at the given situation.
Feed report. A record of important changes and their results for feedback of each iteration.
5.3.2. Design architecture
5.3.3. Decomposition and prioritization
The architecture is decomposed into segments and prioritized in order of development priority in several levels according to the relationships among the components. This step is to increase the reusability of each segment and understandability of the overall architecture and to respond to the dynamically changing environment and requirement more easily.
For each component in a segment that is not developed yet, conventional software development process is repeated. During this phase, we reject weighted documentation in order to make progress rapidly, but we recommend simplified artifacts for specifying important changes, feedback, and progress.
22.214.171.124. Requirement analysis
In this step, the functional and non-functional requirements for each component are described. In particular, requirements for adaptation have to be described based on the distinct situation. Also, the attributes of agent, which is used in the target system, have to be preliminarily described for agent specification (e.g., reactivity, pro-activeness, social ability, and autonomy ).
Type of profiles
General information over applications about a user and the user's life logs, including patterns and the context of the user.
General information over applications about a mobile system, including the state and the context of environment.
The restricted information collected and analyzed by the component for adaptation. These profiles are used for more sophisticated information processing.
General profiles include the shared information that could be accessed by all components. It usually includes the general information about users and the system that could be used to extract the implied information, like patterns or the context. This general information has to be provided by the mobile framework. If additional information is needed for the component's adaptation, then the restricted profiles will be designed for an extension of information.
In this step, the designed components are implemented. This implementation is restricted to the previous design result. If new attributes or requirements occur in this step, the process needs to go back to design step. No functionalities, which are not described in design step, should be implemented. As this methodology is employing an agent module, the agent is also implemented in this step. This agent module is made using the predesigned specifications, models and platforms, and profiles.
126.96.36.199. Testing and feedback
For a present component, engineers verify the agent in a syntactic and semantic way. If it passes the formal test, then engineers will deliver the latest version of the component to users and collect reactions and feedback. At the end of this step, developers analyze artifacts of previous steps, and then make a choice whether they should go through iteration again or go over to the next iteration for the other components. During this phase, the agent-supported development environment could conduct the formal test on the components and collect the results of the testing and feedback instead of the team. Consequently, the specifications of changed requirements, the revisions for the satisfaction, and progress should be documented.
5.3.5. Verification and validation
For the target system operated by all working components, engineers must ensure the satisfaction of the original purpose and objectives they planned in the first step of this process. They also should check whether the combined target system is adapted in the predefined contexts.
5.3.6. Deployment and maintenance
After the above steps are done, the goal product is made. In this step, the deployment of the product and its maintenance are executed. To keep the usability of the product and satisfaction of users, the team has to make a window for continued communication with users and the changes of the market. If needed, they could go back to the iterations and do their process again.
Artifacts of the process
Specification of ideas, category, and objectives of target system through emerging requirement elicitation
Agent oriented architecture of the target system
Decomposition and prioritization
Segments and priorities of components composing the target system
Functional/non-functional requirements specially based on mobile constraints and adaptation
Conti, including variability
Design including the specification of an agent and provision of profiles
Implementation of specified components including agent
Testing and feedback
Specification of requirement satisfaction, testing reports, prototype evaluations and plan for revisions, including agent verification
Verification and validation
Verification and validation of the target system
Deployment and maintenance
Products and user guide
Consequently, previous principles, processes, and technical support compose the framework for developing a mobile software. As shown in Figure 9, our adaptive mobile software development framework adopts the simplified principles based on agile, the process of AOSE, and the agent technology support. The five principles of agile are well matched to the features of MCE and made iterative processes based on that. Each step of the process is based on the AOSE and is supported by an agent technology with labor- and knowledge-intensive processes. Moreover, we propose agent technology support adaptations of mobile software.
6. Case study
In this study, we have made an experiment referred to case study research design components  to show the effectiveness of an agent support and illustrate a way to take into account mobile user customization functions. Thus, we have planned two applications, which are to recommend new services according to the user's behavior history in the mobile environment. One was developed by the classic development methodology, and the other was developed by the proposed mobile software development process.
6.1. Objectives and propositions
This experiment has two main objectives. One is to show that the utilization of an agent support is valuable. The other is to show that the agent can actually reduce the complexity of the development process. Therefore, the following statements are considered in this experiment:
Reflecting the user customization requirement;
Reducing loads over the developers;
Improving accuracy and functionalities.
Concerns for developing customization functions were reflected to the proposed process to make the process easier. Through agent support, we can reduce the loads on the information processing aimed at customization. Lastly, the accuracy and functionality will be improved through the capability of agent reasoning. The evaluation metrics for these propositions are shown in the next chapter.
Metrics for evaluation of methodology
Difficulties in designing information processing for customization exist
Level of difficulty
Through agent reusing, length and complexity of process for design are shortened.
The amount of cost to develop functions instead of agent will be increased.
Cost of time and labor
The cost can be reduced by the reusability of the agent.
By limitation of information closed to users and capability of reasoning, usability of customization is bad.
By agent, collecting information and reasoning from the information are possible. Thus, the usability of customization increases.
Limitations of collecting the user's life information exist. All methods of information processing are implemented by developers each time.
Capability of information processing
Through agent support, we can get huge amounts of information about users and user behavior. Agent reasoning can discover meaningful information remarkably from data.
Generally, as the software development methodology is aimed at reducing the costs from the changing of designs and requirements, the process will fluctuate during the mobile application development.
According to iterative and evolutional processes, changes can be easily accepted. Moreover, reducing the load of preparation before the actual implementation reduces the cost of revision.
Mobile constraints can be missed.
Quality of mobile apps
Through the reflection of mobile application requirements in the process, the possibility of missing concerns related to the quality is reduced.
By the complexity of high level functionality development, possibility of error is high.
Possibility of error
By using agent supported reasoning and specific algorithms, the possibility of error will be reduced.
Independency of components and the stiff structure of the application require the participation of developers for functional extension.
Scalability and flexibility of agent reduce the cost of development for functional extension.
In this experiment, we have made two applications. These applications have the same function which is to recommend new services to be used. One application is developed with agent support in managing intent map, and the other is developed without the support. In this section, we will explain the core concepts and results of customization.
In the proposed methodology, we introduce some concepts for customization and adaptation requirements. Among them, we have adopted three concepts: conti, variable points, and profiles. Firstly, our program has a simple structure composed of three processes and just one view as seen in Figure 8. As you see in this conti, this scenario is composed of units in mobile applications. Generally, units of android applications are recognized as layouts or activities. However, the more general terms need to be used. Among these processes, the standard app list supply makes variability in this application. According to the information supplied by this process, the actual list of recommended services for the user is decided. Though it does not have visible variants, it has actual variability at that point. For the first application, a standard service list is collected from the user's mobile environment. For this, we used the list of present launched services beforehand. As the proposed methodology is used, this process is replaced by an agent module. In this experiment, application intent map agent, which has information about each service's user priority, is the agent module. Through this replacement, we can get more customized and meaningful information to be used as standard for extracting related services.
Consequently, in the first experiment, we simply get the list of currently used applications as standards and then gather additional applications related to the standard applications, but in the second experiment, we use the agent computing with an intent map and make a list of most important applications to the user, instead of just utilizing the currently used applications list.
As a result, some concepts like conti, variable points, and profiles for customization and adaptation are reflected in the process of this experiment. Loads, by implementing the process extracting high priority applications from the user, are reduced using agents instead of people. Lastly, accuracy and usability of application have improved through the utilization of meaningful information from an agent. Consequently, in these experiments, we show three propositions, which are explained in Section 6.1.
Actually, these applications do not always recommend fantastic applications to the user. The reason is that the information is not enough to realize the taste of the user. The information about each service's user priority is not enough to make a practical user customization. However, we expect that it would be possible to get information and increase the accuracy of adaptation if the infrastructure is constructed to support an information lifecycle.
In this research, we attempted to reflect the requirements of the MCE on the methodology and to solve the problems caused by variability, approaching from the hybrid method of combining agile software development methodology and agent technology to make the process effective. Also, we used concepts of SPLE and AOSE to control the complexity of engineering process and to facilitate the realization of adaptation. Lastly, we made experiments to show the potential of agent support in complex mobile developments, e.g., customizing and adaptive mobile software. However, we still have drawbacks in our process, which could yield to further studies as follows:
Standard specification of agent for MCE for adaptation
Autonomous agent verification and validation
Evaluation of adaptive mobile software
Realization of agent-supported development environment
Agent-supported mobile software platform.
Moreover, mobile software engineering and an AOSE approach for customized/adaptive MCE are scarce. However, we are on the stepping stone to adaptive and tailored functions for user and environments. So if we face the needs of an adaptive MCE and the difficulties with complex mobile software engineering, then we could learn more about issues such as the following:
Organization of components in MCE
Collaboration between applications and mobile components in MCE
Adaptation of mobile application and complex MCE
Infrastructure to supply tailored service and information processing.
In this paper, we described the need for an agile-based software development methodology for dynamically changing requirements of mobile software in wireless networked computing environment. This approach can be used to provide automatic computation support for suitably decomposed tasks.
The proposed methodology includes these two features. One is the requirement discovery and the use of variable point concepts in SPLE for the representation of adaptive software requirements. The other is a process satisfying the changing requirements and accommodating the information lifecycle. In the designing of the methodology, we reflected the adaptation requirements as well as the constraints of MCE onto the methodology. Finally, using those concepts, processes, and technical support, we proposed a framework for mobile adaptive software development in wireless computing environment. Moreover, we also described the possible effects of agent support by performing two experiments.
As an experiment, we found a fragmentary scenario to understand the effect of agent support. From this test, we could realize the advantages of the infrastructure which supports the proposed methodology.
In short, what we would like to show in this paper are like these. One is a new mobile software development methodology, which reflects the feature of wireless computing environment. Another is the mobile software development framework based on hybrid solution of agile philosophy and agent technology. The other is the incorporation of ‘requirements discovery’ stage which is a new unit of mobile software development process to support the need of software adaptation. With these objects, the design of a human-centered software development methodology and framework for mobile software development in wireless computing environment is proposed in this paper.
This research was supported by the Next-Generation Information Computing Development Program through the National Research Foundation of Korea (NRF) funded by the Ministry of Education, Science and Technology (No. 2012M3C4A7033343 and No. 2012M3C4A7033346).
- Rahimian V, Ramsin R: Designing an agile methodology for mobile software development: a hybrid method engineering approach. In Second International Conference on Research Challenges in Information Science (RCIS). Edited by: Pastor O, Flory A, Cavarero JL. New York: IEEE; 337-342.Google Scholar
- Abrahamsson P, Salo O, Ronkainen J, Warsta J: Agile Software Development Methods. Espoo, Finland: VTT; 2002:112.Google Scholar
- Rising L, Janoff NS: The Scrum software development process for small teams. IEEE Software 2000, 17: 26-32.View ArticleGoogle Scholar
- Wood WA, Kleb WL: Exploring XP for scientific research. IEEE Software 2003, 20(3):30-36. 10.1109/MS.2003.1196317View ArticleGoogle Scholar
- Wasserman T: Software Engineering Issues for Mobile Application Development. New Mexico, USA: FoSER; 2010:397-400.Google Scholar
- Abrahamsson P, Hanhineva A, Hulkko H, Ihme T, Jaalinoja J, Korkala M, Koskela J, Kyllonen P, Salo O: Mobile-D: an agile approach for mobile application development. Vancouver, BC, Canada: Paper presented at the 19th annual ACM SIGPLAN conference on object-oriented programming systems, languages, and applications; 2004. 24–28 OctoberView ArticleGoogle Scholar
- Mubarak H: Developing flexible software using agent-oriented software engineering. IEEE Software 2008, 25(5):12-15.View ArticleGoogle Scholar
- Jennings NR, Wooldridge M: Agent-oriented software engineering. In Proceedings of the 12th International Conference on Industrial and Engineering Application of Artificial Intelligence and Expert Systems: Multiple Approaches to Intelligent Systems, Cairo, Egypt. Edited by: Imam IF, Kodratoff Y, El-Dessouki A, Ali M. New York: Springer; 1999:4-10.Google Scholar
- Wooldridge M: Agent-based software engineering. IEEE Proceedings on Software Engineering 1997, 144: 26-37. 10.1049/ip-sen:19971026View ArticleGoogle Scholar
- Wooldrige MJ, Jennings NR: Software engineering with agents: pitfalls and pratfalls. Internet Computing, IEEE 1999, 3(3):20-27. 10.1109/4236.769419View ArticleGoogle Scholar
- Srinivasan R: Artificial intelligence methodologies for agile refining: an overview. Knowledge and Information Systems 2007, 12(2):129-145. 10.1007/s10115-006-0057-zView ArticleGoogle Scholar
- Wooldridge M: An Introduction to MultiAgent Systems. New York: Wiley; 2009:484.Google Scholar
- Georgeff MP, Pell B, Pollack ME, Tambe M, Wooldridge M: The belief-desire-intention model of agency. Paris, France: Paper presented at the 5th international workshop on intelligent agents V: agent theories, architectures, and languages, ATAL '98; 1998. 4–7 JulyGoogle Scholar
- Rao AS, Georgeff MP: BDI agents: from theory to practice. In Proceedings of the First International Conference on Multiagent Systems. Edited by: Gasser L, Lesser V. Menlo Park, CA: AAAI; 1995:312-319.Google Scholar
- Huber MJ: JAM: A BDI theoretic mobile agent architecture. Seattle, WA: Paper presented at the proceedings of the third annual conference on autonomous agents; 1999. 1–5 MayView ArticleGoogle Scholar
- Huber MJ: JAM manual (IRS, 2001). . Accessed 1 November 2001 http://www.marcush.net/IRS/Jam/Jam-man-01Nov01.doc
- Rahwan I, Kowalczyk R, Yang Y, PRICAI 2000 Workshop Reader: Virtual enterprise design—BDI agents vs. objects. In Advances in Artificial Intelligence. Edited by: Kowalczyk R. New York: Springer; 2001:147-150.Google Scholar
- Williams L: What agile teams think of agile principles. Commun ACM 2012, 55(4):71-76. 10.1145/2133806.2133823View ArticleGoogle Scholar
- Lee SW, Rine DC: Case study methodology designed research in software engineering methodology. Banff, Alberta, Canada: Paper presented in the proceedings of the sixteenth international conference on Software Engineering and Knowledge Engineering (SEKE'04); 2004. 20–24 JuneGoogle Scholar
This article is published under license to BioMed Central Ltd. This is an Open Access article distributed under the terms of the Creative Commons Attribution License (http://creativecommons.org/licenses/by/2.0), which permits unrestricted use, distribution, and reproduction in any medium, provided the original work is properly cited.