ingenias-scrum development process for multi-agent … · ingenias-scrum development process for...

INGENIAS-SCRUM Development Process forMulti-Agent Development

Ivan Garcıa-Magarino1, Alma Gomez-Rodrıguez2

, Jorge Gomez-Sanz1, and Juan C. Gonzalez-Moreno2

1 Universidad Complutense de Madrid ivan gmg,[email protected] Universidade de Vigo alma,[email protected]

Summary. One of the key issues in development of Multi-agent System(MAS)is to follow the more suitable development process for a particular problem. Thismeans that development process models must be defined. Definition leads to betterprocess understanding, facilitates process measurement and improvement, and con-stitutes the basis for automating the process itself. The main goal of this paper isthe definition of a process for agent-based development. This definition is based onthe Software Process Engineering Metamodel(SPEM) and applied in the definitionof the software engineering process of INGENIAS MAS methodology following aSCRUM approach.

1 INTRODUCTION

Some authors [3, 4], indicate that the modeling of processes for agent-baseddevelopment is an increasing demand due to many reasons. Some of the Agent-oriented Software Engineering(AOSE) methodologies [15, 5, 2, 14] may befollowed using di!erent process models depending on the system to be con-structed. In these cases, the anticipated definition of the process, by meansof its modeling, is very useful. Besides, the process models can be sharedamong Multi-agent System (MAS) designers, facilitating to inexperienced de-signers the process models defined by experienced ones. Moreover, definingthe process models provide the basis for automating the process itself, in thesame way as it is done in other engineering fields, and opens the possibility ofadapting CASE tools for a particular process within a methodology.

This paper focuses on the definition of a process model for agent-based de-velopment. When addressing this issue several perspectives can be followed:some methodologies define a unique process of development, while others mayfollow di!erent processes depending on the system, the team, etc. This paperincorporates this latest approach, applying a particular process to a well de-fined methodology. In fact, the main aim of this work is to define a processof development for Multiagent Systems following a particular methodology

2 I. Garcıa-Magarino, A. Gomez-Rguez, J. Gomez-Sanz, J.C. Glez-Moreno

(INGENIAS) and approaching the process within the SCRUM philosophy ofmanagement in mind.

The definition of processes is made easier using an editor which allowsdesigners to create the suitable diagrams and definitions in an automatedmanner. In the last two years, an important number of tools have been pro-posed to model and specify Software Development Process [1, 6, 4, 8], mostof them based on the SPEM standard.

The structure of the remaining of the paper follows. Next two sections in-troduce briefly the SCRUM process of management and INGENIAS method-ology of development. Section 4 provides a detailed definition of INGENIAS-SCRUM process, introducing several subsection where details about the life-cycle, the disciplines, etc. are explained. Finally, Section 5 presents the con-clusions and future work.

2 SCRUM

A SCRUM is a mechanism in the sport of rugby for getting an out-of-playball back into play. The term was adopted in 1987 by Ikujiro Nonaka andHirotaka Takeuchi to describe hyper-productive development. Ken Schwaberformalized the process in the first published paper on SCRUM at OOPSLA1995 [18].

As pointed in [17], SCRUM is an empirical Agile project managementframework which is used to iteratively deliver to the customer software incre-ments of high value. It is a simple framework used to organize teams and getwork done more productively with higher quality. SCRUM relies on self orga-nizing, empowered teams to deliver the product increments. It also relies on acustomer, the Product Owner, which provides the development team with alist of desired features using business value as the mechanism for prioritization.

From the previous paragraphs it must be clear that SCRUM is a model formanagement of the process of software development. It is not a methodology,but a framework which can fit with several methodologies. The SCRUM pro-cess is particularly suitable for Knowledge Engineering Developments basedon the use of Multi-Agent Systems, because of the agile development and theuser implication.

3 INGENIAS METHODOLOGY

INGENIAS methodology covers analysis and design of MAS, and it is intendedfor general use, with no restrictions on application domain [16, 11, 12]. It isbased on UML diagrams and process (RUP), trying in this way to facilitateits use and apprenticeship. New models are added and the UML ones areenriched to introduced agent and organizational concepts. At the moment themetamodels proposed cover the whole life cycle and capture di!erent views of

INGENIAS-SCRUM Development Process for Multi-Agent Development 3

the system. In the latest years, INGENIAS Metamodels have demonstratedtheir capability and maturity, as supporting specification for the developmentof Multiagent Systems [16, 15].

Recently the INGENIAS Agent Framework (IAF) has been proposed tak-ing into account the experience in application of INGENIAS methodologyduring several years enabling a full model driven development. This meansthat, following the guidelines of the IAF, an experienced developer can fo-cus most of its e!ort in specifying the system, converting a great deal of theimplementation in a matter of transforming automatically the specificationinto code. A MAS, in IAF, is constructed over the JADE platform. It canbe distributed along one or several containers in one or many computers.To enable this feature, the IAF has means of declaring di!erent deploymentconfigurations.

4 SCRUM FOR INGENIAS METHODOLOGY

In [3] the need of process models for agent-based development has been estab-lished. After this work, many others have modeled di!erent kinds of processeswithin a well known methodology. In this paper processes and methodologiesare thought to be in two orthogonal dimensions that can be merged or in-terchanged during the life cycle of a MAS development process. This couldbe done if development resources and deliverables are previously defined andmodeled into a well known process or if, a new process is created to matchthe necessity of the development team for fulfilling the user requirements. Inthis section, the guidelines used in [8] to specify and define a process modelare followed for adapting the SCRUM Development Process within the IN-GENIAS Methodology. Moreover, SCRUM-INGENIAS process has proved hisutility, because it has been used for developing a MAS system, based on delphiprocess for document relevance evaluation [7].

In the latest years an important number of tools for modeling and spec-ifying Software Development Processes have been proposed. Most of themare based on the SPEM standard, for instance Eclipse Process Framework(EPF) [6]. As part of the EPF documentation, two possible development pro-cesses are described: OpenUp and SCRUM. Moreover, in the EPF ComposerOverview, authors propose as an example of the EPF capabilities, the modelof a new process obtained by reusing several activities defined for OpenUpinto a SCRUM process skeleton. On the other hand, in [3, 13] the approach isto find a set of common activities for di!erent Agent Oriented Software Engi-neering Methodologies (AOSEM). The objective, in this case, is to reuse thoseactivities across real Multi-Agent Software Development Life Cycle Processes.

In this paper, process activities can not be shared across di!erent devel-opment processes in AOSEM because the intended meaning may be di!erentand those activities may use di!erent resources (human, software and hard-ware). Nevertheless, di!erent processes for the same methodology which use


the same resources can be used. This section addresses this goal; that is, toshow how an agile project management technique, such as SCRUM, can beused within a methodology like INGENIAS, whose development process na-ture is basically those of the Rational original Unified Process Development(UPD) and which has been recently mapped to the OpenUP process (see [9]).

When trying to map a well established methodology/process into a newprocess, it is necessary to define the steps to be done for obtaining the desiredresult. In [9]several steps that must be followed in the definition of a new de-velopment process models for AOSEM are defined, adopting SPEM as modelspecification. These steps are:

1. Identify the process model with an existent process model if possible, if notdefine from zero the new one taking as basis the next steps.

2. Define the lifecycle view. Identify the phases, iterations and sequence ofapplication. This step is essentially a temporal step in which other re-sources di!erent from time are not considered.

3. Define the disciplines. Disciplines in SPEM determine process packageswhich take part in the process activities, related with a common sub-ject. That is, disciplines represent a specialization of selected subactivi-ties, where these new subactivities can not appear in other packages ordisciplines. In this step, resources are the subject of the activities defined.

4. Define the guidance and suggestion view. The Guidances provide infor-mation about certain model elements. Each Guidance is associated to aGuidance Kind. This step is focused in exemplifying and documenting theactivities previously defined.

After applying the previous steps to IAF and SCRUM, the results can besynthesized in the following points:

1. Process Model: There are several Multi-Agents Systems that could bequickly constructed with INGENIAS by reusing previous developments.Recently, the INGENIAS Agent Framework (IAF) for JADE has beenproposed and documented as a successful approach in this context.

2. Lifecycle: In SCRUM, each release is produced within a number of briefiterations called Sprints (see Fig. 1). All the work is done in two basicphases: the Preparation Phase (before the first sprint) and the SprintPhases(successive sprints leading to the release).

3. Disciplines: The team defines required tasks for developing the Sprint:Daily Scrum, Initiate Product Backlog, Manage problems, Plan Release,Sprint Planning, Sprint Retrospective, Sprint Review and Update productbacklog.

4. Guidance and suggestion view: The guidance for implementing theprocess with INGENIAS could be found in the IAF documentation [10].

All the aforementioned technique steps are further explained in the follow-ing subsections.


Fig. 1. SCRUM lifecycle

4.1 Lifecycle

Although, SCRUM does not describe engineering activities required for prod-uct development, INGENIAS-SCRUM process must do it in order to adjust toIAF recommendations. IAF allows combining the classic approach of codingapplications with modern techniques of automatic code generation. In thislatest case, the generated MAS works over the JADE platform and additionaltools available for this framework can be applied as well. This requires a cor-rect IAF specification, that is, determine the following aspects in a soundway:

• Interactions. Interactions describe how agents do coordinate. Coordina-tion is defined in terms of information transfer units.

• Tasks. Tasks are the basic units of agent’s behavior. They modify theagent mental state and perform actions over applications.

• Agents. Agents are the main building blocks of the system. An agent isdefined completely when its perception (main tasks) and its coordinationmeans are described.

• Deployment. Deployment expresses how agents are instantiated and ini-tialized in the final system.

• Tests. Tests describe the testing units the MAS should pass.• Goal. The agents pursue certain goals. Goals guide agent’s behavior.• Mental state. The tasks performed by agents depend on their mental

state and their pursued goals.

IAF requires the use of the INGENIAS Development Kit (IDK). IDKcontains a graphical editor for working with the specification model. Accord-


ingly to IDK, the SCRUM definition for the Preparation Phase (see Fig. 2)comprises the tasks: Initiate Product Backlog, Plan Release and PreparationTasks.

Fig. 2. Preparation Phase workflow

The INGENIAS Product Backlog contains the product requirements estab-lished with the IDK. This process can be done by adapting a known modelfrom a previous project (i.e. IDK-IAF distribution comes with a completecinema project which can be used for other distributed e-commerce develop-ments) or defining a completely new product backlog with the editor.

After this initial model is completed, in the Preparation Tasks, the SCRUMMaster and the Product Owner establish the Plan Release in which the neededSprints are defined.

From the SCRUM perspective and taking into account that IAF baseson the automatic generation of code approach, the project team must becompletely involved in getting the release within the planned sprints. So, theINGENIAS specification must be established with the IDK as the core ofthe development. From this core, the di!erent scripts and sources will beautomatically produced. Nevertheless, at the first stage, the generated codefor the tasks may be incomplete and the programmer should add, if necessary,code in the tasks. This code must be incorporated in the specification by meansof the IDK or the CodeUploader 3 application. In this way, the next codegeneration does not overwrite the added code. Furthermore, for some MAS,external components may be necessary, and the IDK provides a mechanism tointegrate these components into the MAS. In addition, a developer may findnecessary to modify code already generated. In order to do that, in each sprint(see Fig. 3 and Fig. 4) the following tasks must be performed: Plan Sprint,3 http://grasia.fdi.ucm.es/


Update Product Backlog, Daily Works, Manage Problems, Conduct SCRUMDaily Meeting, Review Sprint, and Conduct Retrospective.

Fig. 3. Sprint Phase workflow

4.2 Disciplines

Disciplines in SPEM determine process packages which take part in the pro-cess activities, related with a common subject. That is, disciplines representa specialization of selected subactivities, where these new subactivities cannot appear in other packages or disciplines. As previously pointed, in theINGENIAS-SCRUM approach the disciplines are the tasks required in eachsprint, so the intended meaning of each task, according to IAF, must be ex-plained. But first, the roles and products involved in the development mustbe introduced [9]. The roles, in this case, are:Product Owner, this role must beplay by an active customer as in eXtreme Programming(XP); SCRUM Mas-ter, the coach and main of the development team; SCRUM Team, this is acollective role that must be played by any of the team members; Stakeholder,anyone that does not directly participate on the project but can influence theproduct being developed, that is, an interested party.

The products or artifacts involved in a SCRUM development process are:Product backlog, Sprint backlog and Product increment. The product backlogcontains the product requirements and has the purpose of listing all the func-tionalities to implement from a customer perspective. The sprint backlog isthe list of things to do from the development team point of view. It could beunderstood as a fine-grained planning on detailed tasks. At last, the productincrement is a partial product obtained at the end of each sprint, which canbe deployed in the production environment or simply made available to users.From the INGENIAS-SCRUM perspective those artifacts are referred to theINGENIAS model and JADE code produced in each release. An INGENIASmodel documented with the IDK can accomplish a low o high level of detail.Also, in the description of each model the SCRUM Master can fix the work tobe done in the next release, where release can be identified with the packageentity of the INGENIAS model.


Fig. 4. Sprint Iteration

The tasks that must be performed during the development lifecycle are:

• Initiate Product Backlog.- Explained in the previous subsection.• Preparation tasks.- Explained in the previous subsection.• Plan Release.- Explained in the previous subsection.• Sprint Planning.- It involves the following steps: Define the sprint’s goal,

Select the items, Identify tasks from items, Estimate tasks, Assigning tasks,Getting team commitment.

• Update product backlog.- The update should take sprint scope changes intoaccount for planning the next sprints. It must be performed in three steps:Collecting changes, Reprioritizing items and Reestimating items.

• Daily SCRUM.- The team performs backlog tasks to reach sprint goal in afree way, each SCRUM team selects the tasks to be performed or modified.

• Sprint Retrospective.- It allows the feedback and adaptation of the process.• Sprint Review.- It shows what has been done and works.• Manage problems.- This means to take into consideration the events that

happen at every moment in a project and try to solve them. It is relevantwith respect to last steps of the guideline presented in the next section

• Release work.- This latest Sprint prepares product release.

All these tasks could be matched with di!erent guidelines appearing inIAF documentation [10].


4.3 Guidances

Developing a system with code generation facilities requires some guidance.In IAF documentation [10] several guidelines for development are proposed.In multi-agent systems, we recommend specially the use of two kinds of guid-ance: Technique and Guideline. The technique provides an algorithm to createa work product. The guideline is a set of rules and recommendations about awork product organization. As examples, the most relevant INGENIAS Guid-ances are described below. Reader can have a more detailed view in [8].

5 CONCLUSIONS AND FUTURE WORK

The definition of the software process engineering model of a MAS methodol-ogy makes it easier to learn and use the methodology. This paper provides atechnique to define process models for agent-based development, using SPEMtechniques. In particular, the technique is used for the redefinition of theSCRUM development process for the INGENIAS methodology. Furthermore,this work can guide a MAS team of developers through the steps of definitionof a development process for MAS construction using an agent framework (theIAF) and the SCRUM process management. The description of the steps tofollow provided in the paper, can simplify the definition of processes for nonexpert engineers.

In addition, the description of how SCRUM can be used for managinga project within the INGENIAS methodology provides an example, of howa methodology can incorporate several processes. That is, INGENIAS mayfollow a RUP process of development or can use other specific processes, suchas SCRUM.

In the future, other methodologies and processes can be mixed in a par-ticular process definition using the available tools for modeling. The modelsconstructed in this way can assist the MAS designer in selecting the appropri-ate methodology and process model for a specific MAS, team of developmentor other circumstances. Moreover, the SCRUM process for the INGENIASmethodology can be compared with other MAS processes by means of certainmetrics.

6 Acknowledgments

This work has been supported by the following projects: Methods and toolsfor agent-based modeling supported by Spanish Council for Science and Tech-nology with grants TIN2005-08501-C03-01 and TIN2005-08501-C03-03 co-financed with FEDER funds and Grant for Research Group 910494 by theRegion of Madrid (Comunidad de Madrid) and the Universidad ComplutenseMadrid.


Some figures which facilitate de understanding of this paper have beenobtained form EPF [6].

References

1. APES2: A Process Engineering Software. http://apes2.berlios.de/en/links.html.2. C. Bernon, M. Cossentino, and J. Pavon. Agent-oriented software engineering.

Knowl. Eng. Rev., 20(2):99–116, 2005.3. L. Cernuzzi, M. Cossentino, and F. Zambonelli. Process models for agent-based

development. Engineering Applications of Artificial Intelligence, 18(2):205–222,2005.

4. M. Cossentino, L. Sabatucci, V. Seidita, and G. S. An Agent Oriented Toolfor New Design Processes. Proceedings of the Fourth European Workshop onMulti-Agent Systems, 2006.

5. P. Cuesta, A. Gomez, J. Gonzalez, and F. J. Rodrıguez. The MESMA method-ology for agent-oriented software engineering. In Proceedings of First Interna-tional Workshop on Practical Applications of Agents and Multiagent Systems(IWPAAMS’2002), pages 87–98, 2002.

6. Eclipse: Eclipse Process Framework (EPF). http://www.eclipse.org/epf/.7. I. Garcıa-Magarino, J. R. P. Agera, and J. J. Gomez-Sanz. Reaching consensus

in a multi-agent system. In International workshop on practical applications onagents and multi-agent systems, 2007. Salamanca, Spain.

8. I. Garcıa-Magarino, A. Gomez-Rodrıguez, and J. C. Gonzalez. Modeling IN-GENIAS development process using EMF (In Spanish). In 6th InternationalWorkshop on Practical Applications on Agents and Multi-agent Systems, IW-PAAMS’07, pages 369–378, 2007. November 12/13, 2007, Salamanca Spain.

9. I. Garcıa-Magarino, A. Gomez-Rodrıguez, and J. C. Gonzalez. Definition ofProcess Models for Agent-based Development. In 9th International Workshopon AOSE, 2008. May 12/13, Lisbon, Portugal.

10. J. Gomez-Sanz. Ingenias Agent Framework. Development Guide V. 1.0. Tech-nical report, Universidad Complutense de Madrid.

11. J. J. Gomez-Sanz. Modelado de Sistemas Multi-Agente. PhD thesis, Depar-tamento de Sistemas Informaticos y Programacion, Universidad ComplutenseMadrid, 2002.

12. J. J. Gomez-Sanz and R. Fuentes. Agent oriented software engineering withingenias. In Fourth Iberoamerican Workshop on Multi-Agent Systems (Ibera-gents’2002), a workshop of IBERAMIA’2002, the VIII Iberoamerican Confer-ence on Artificial Intelligence, pages –, 2002.

13. B. Henderson-Sellers and P. Giorgini. Agent-Oriented Methodologies. Idea GroupInc., 2005.

14. A. Mas. Agentes Software y Sistemas Multi-Agentes. Pearson Prentice Hall,2004.

15. J. Pavon and J. Gomez-Sanz. Agent Oriented Software Engineering with IN-GENIAS. Multi-Agent Systems and Applications III, 2691:394–403, 2003.

16. J. Pavon, J. Gomez-Sanz, and R. Fuentes. Model Driven Development ofMulti-Agent Systems. ECMDA-FA, Proceedings of Model Driven Architecture-Foundations and Applications, Second European Conference, ECMDA-FA 2006,Bilbao, Spain, 4066:284–298, 2006.


17. K. Schwaber and M. Beedle. Agile Software Development with Scrum. PrenticeHall PTR, Upper Saddle River, NJ, USA, 2001.

18. J. Sutherland. Business object design and implementation workshop. In OOP-SLA ’95: Addendum to the proceedings of the 10th annual conference on Object-oriented programming systems, languages, and applications (Addendum), pages170–175, New York, NY, USA, 1995. ACM.

ingenias-scrum development process for multi-agent … · ingenias-scrum development process for...

Documents