An Inspection Technique Proposal for the Veriﬁcation of Requirements

Speciﬁcation Documents for Multi-Agent Systems

Giovane D’Avila Mendonc¸a

, Gilleanes Thorwald Araujo Guedes

and Iderli Pereira de Souza

Filho

Software Engineering Post-Graduation Program, Pampa Federal University, Av. Tiaraju, 810, Alegrete, Brazil

Keywords:

Requirements Engineering, Requirements Veriﬁcation, Requirements Inspection, Multi-Agent Systems,

Perspective-Based Reading.

Abstract:

Requirements engineering is an important area of software engineering dedicated to eliciting, analysing, speci-

fying, and validating software requirements to ensure the correct understanding of what needs to be developed.

The requirements speciﬁcation objective is to provide a detailed description of what the software must do, it

involves the production of a document that can be systematically reviewed, evaluated, and approved. Prob-

lems in the requirements are appointed among the main causes of failures in software projects. Therefore,

performing requirements veriﬁcation and validation is extremely important to ensure the software quality.

Multi-Agent systems are a type of software with particular requirements, beyond the commonly found among

other systems, since they are composed by several autonomous and proactive agents that divide the problem

to be solved among them. Thus, requirements engineering needs to be adapted for this kind of system and the

produced documents need to be veriﬁed too. Several techniques were proposed for requirements inspection,

among them there is the Perspective-Based Reading. However, as in the other approaches, this technique does

not allow the inspection of particular requirements for multi-agent systems. Taking this in consideration, our

work has as its objective to adapt this technique so as to allow the veriﬁcation of requirements speciﬁcation

documents speciﬁc for this kind of system.

1 INTRODUCTION

Multi-Agent systems are characterized by being com-

posed of several agents that interact among them-

selves (Wooldridge, 2009). An agent is an au-

tonomous, proactive, reactive, and with social skills

process (Vicari and Gluz, 2007), moreover, an agent

is able to performing actions without the user inter-

vention (Wooldridge and Jennings, 1995) (Pornphol

and Chittayasothorn, 2006) (Sivakumar et al., 2013).

Multi-Agent systems became an alternative for

the complex systems development (Labba et al.,

2015). However, the development of this kind of

system brought several challenges to the software

engineering area, what entailed the emergence of

AOSE (Agent-Oriented Software Engineering) an

area that mixes characteristics of several disciplines

both from Software Engineering and Artiﬁcial Intel-

https://orcid.org/0000-0001-9445-6831

https://orcid.org/0000-0001-5457-2600

https://orcid.org/0000-0001-9694-0977

ligence (Cuesta et al., 2007). AOSE has, among its

objectives, to adapt software engineering practices

speciﬁcally for the agent-based systems development

(Guedes and Vicari, 2010), that includes to produce

methodologies, processes, techniques, modeling lan-

guages, and tools for the multi-agent systems devel-

opment (Genza and Mighele, 2013) (Mendonc¸a et al.,

2021). How could it be, AOSE also includes the adap-

tation of Requirements Engineering for multi-agent

systems.

Requirements Engineering is a Software Require-

ments area that is concerned with requirements elic-

iting, analysing, specifying, and validating to ensure

the correct understanding of what needs to be devel-

oped (Fuentes-Fern

andez et al., 2009). Requirements

Engineering performs a crucial function for the devel-

opment of any software, since, if the software needs

were not understand correctly, the product will not

satisfy those to whom its is destined (Mendonc¸a et al.,

2021).

The main failures veriﬁed in software projects are

related to problems in the requirements speciﬁcation,

Mendonça, G., Guedes, G. and Filho, I.

An Inspection Technique Proposal for the Veriﬁcation of Requirements Speciﬁcation Documents for Multi-Agent Systems.

DOI: 10.5220/0010842700003116

In Proceedings of the 14th International Conference on Agents and Artiﬁcial Intelligence (ICAART 2022) - Volume 1, pages 257-264

ISBN: 978-989-758-547-0; ISSN: 2184-433X

257

due, mainly, to difﬁculties in the understanding of

the users needs (Koscianski and dos Santos Soares,

2007). Therefore, to perform the requirements veri-

ﬁcation and validation is essential to ensure the soft-

ware quality, because errors identiﬁed in the require-

ments in posterior phases of the software develop-

ment has a very much bigger cost to be corrected (Bi-

lal et al., 2016). Thus, several inspection techniques

were created to the requirements veriﬁcation and val-

idation. Inspections had proved to be an effective way

to ﬁnd failures in different software artifacts (Fogel-

str

om and Gorschek, 2007).

Taking this in consideration, we are proposing

an adaptation of the Perspective-Based Reading tech-

nique (PBR) (Basili et al., 1996) (Shull et al., 2000)

in such a way that it can be applied in the inspection

of software requirements speciﬁcation documents

(SRSD) speciﬁc for multi-agent systems. Whereas

Ebad in (Ebad, 2017), highlights that the Perspective

Based Reading (PBR) technique is one of the most

effective for requirements inspection. This technique

adapted was conceived to be applied on SRSDs pro-

duced by a speciﬁc requirements engineering process

for multi-agent systems we developed. The docu-

ments produced by this process use the notation of

Multi-Agent Systems Requirements Modeling Lan-

guage (MASRML) proposed by (Guedes et al., 2020).

We use MASRML because this notation supports

Belief-Desire-Intention (BDI) model, during the re-

quirements speciﬁcation, different from other nota-

tions that do not support this type of representation.

Furthermore, the MASRML notation uses some con-

cepts, as by example Internal Use Cases (IUC) and

AgentRoleActors.

In this study context, we propose a veriﬁcation

technique, considering the deﬁnition presented in the

study of (Ryan and Wheatcraft, 2017), in which the

use of veriﬁcation and validation terms and their

deﬁnitions according to the literature was analyzed.

In this study, the author deﬁnes that the veriﬁca-

tion focus is on the requirements text and structure,

determining whether they are correctly written and

structured according to the organization’s standards,

guidelines, rules, and checklists. On the other hand,

requirements validation makes it possible to deter-

mine whether the requirements are deﬁned in a clear

way and whether they communicate correctly the

stakeholders expectations and needs. It involves es-

tablishing whether the right thing is being built, as

deﬁned by the requirements set.

In order to assess the applicability and efﬁ-

ciency of our proposal to adapt the Perspective-

Based Reading technique, we are applying two quasi-

experiments. The ﬁrst with students of Veriﬁcation

and Validation discipline of a Software Engineering

undergraduate course. The second quasi-experiment

is being applied to specialists, master’s students, and

ﬁnal year students of an undergraduate software en-

gineering course. Most of the subjects have profes-

sional experience in the software engineering area.

Due to the limited space in this work, the results

of the quasi-experiments will be published in a future

work.

2 BACKGROUND

2.1 Requirements Engineering

The objectives of Requirements Engineering are: (I)

identifying software requirements; (II) analysing re-

quirements so to classify them and to derive ad-

ditional requirements, as well as to solve conﬂicts

among them; (III) documenting the requirements;

(IV) validating the documented requirements (Beren-

bach et al., 2009).

In SWEBOK (Bourque et al., 2014) – a reference

book in the area – it is stated that the requirements en-

gineering process covers four main subareas, (I) Re-

quirements Elicitation; (II) Requirements Analysis;

(III) Requirements Speciﬁcation; and (IV) Require-

ments Validation.

Requirements elicitation investigates how to ex-

tract requirements and which are its origins. Require-

ments analysis aims to detect and to solve conﬂicts

among the requirements and to discover the system

limits. Requirements speciﬁcation, by its turn, pro-

duces requirements documents that can be systemati-

cally reviewed, evaluated, and approved. Finally, re-

quirements validation evaluates the requirements doc-

uments to ensure the requirements are understand-

able, correct, consistent, and complete.

2.2 Requirements Veriﬁcation

Weak alignment of requirements engineering with

veriﬁcation can lead to problems in the deliver of soft-

ware products, such as lack in the accomplishments of

deadlines and poor quality (Bjarnason et al., 2014).

According to (Dzida and Freitag, 1998) veriﬁcation is

related to the requirements correctness.

Requirements veriﬁcation is the conﬁrmation by

examination that the requirements (individually or in

a set) are well formed (ISO/IEC/IEEE 29148, 2011)

(ISO/IEC/IEEE 29148, 2018). According to (Ryan

and Wheatcraft, 2017), this means that a requirement

or a set of requirements has been revised to ensure that

the characteristics of good requirements are achieved.

ICAART 2022 - 14th International Conference on Agents and Artiﬁcial Intelligence

258

According to (Khan et al., 2015), experts be-

lieve that review and inspection are the best strate-

gies to remove or mitigate requirements veriﬁcation

and validation challenges. In this sense, (Ryan and

Wheatcraft, 2017) states that requirements veriﬁca-

tion conﬁrms, through inspection, that the require-

ments contain the necessary elements and have the

characteristics of a well-formed requirement.

2.3 Agents and Multi-Agent Systems

An agent is a process situated in an environment

designed to achieve a purpose by means of an au-

tonomous and ﬂexible behavior. The environment is

the application domain where the agent will act (Vi-

cari and Gluz, 2007).

A multi-agent system (MAS) consists of a set of

agents that can interact among themselves. Agents

are able to act in an environment and have different

“inﬂuence spheres”, where they can control or inﬂu-

ence different parts of the environment (Wooldridge,

2009).

Agents use to play roles. An agent role contains a

part of the social behavior of an agent and it is char-

acterized by having a goal and/or providing a service.

The goal of each role is to contribute to the accom-

plishment of a part of the organization (or environ-

ment) requirements in which the agent is contained

(Cossentino and Seidita, 2014). The agent roles rep-

resent the functions the agents can perform inside the

system. The agents can take more than one role, but

generally not at the same time.

2.4 Internal Use Cases and

AgentRoleActors

The speciﬁcation proposed in our work uses the no-

tation established in MASRML (Guedes et al., 2020)

language, a modeling language extended from UML

speciﬁcally to the multi-agent systems requirements

representation.

The AgentRoleActors represent roles taken by

agents. These agent roles are modeled inside the sys-

tem boundary. Internal Use Cases (IUC) are use cases

that are not accessed by external actors. IUCs are

accessed by Agent Roles (AgentRoleActors). These

IUCs can have stereotypes of the Goal, Plan, Percep-

tion, or Action kind.

2.5 Belief-Desire-Intention Model

The Belief-Desire-Intention (BDI) model is a soft-

ware model developed for programming intelligent

agents. It includes beliefs, desires, and intentions in

the agent architecture (Bratman et al., 1987).

Beliefs represent the information state the agent

has about the environment, about himself, and even

about the other agents. The desires represent the goals

or situations that the agent wants to achieve. Lastly,

intentions represent the desires the agent believes he

can achieve and acts to achieve it (Rao and Georgeff,

1995).

According to (Bordini et al., 2021) asserts that the

unique strengths of BDI agent languages provide an

ideal framework for integrating the wide range of AI

capabilities needed to progress towards the next gen-

eration of intelligent systems.

BDI agents are among the most widely studied

models of rational agents (Torre and Parlato, 2020).

The Belief-Desire-Intention model is one of the most

popular models for developing rational agents based

on how humans act and on information derived from

an environment (Ujjwal and Chodorowski, 2019).

Furthermore, according to (Xu et al., 2018), the

BDI architecture, where agents are modeled based on

their beliefs, desires, and intentions, provides a practi-

cal approach to developing intelligent agent systems.

2.6 Multi-Agent Systems Requirements

Modeling Language

MASRML – Multi-Agent Systems Requirements

Modeling Language – is a UML-based Domain-

Speciﬁc Modeling Language (DSML) conceived for

requirements modeling in multi-agent system projects

(Guedes et al., 2020). This DSML extends the UML

metamodel in order the use-case diagram can be ap-

plied in the speciﬁc domain of multiagent systems.

MASRML provides mechanisms to represent the con-

cepts of agent role, goal (desire), perception, belief,

intention, plan, and action, supporting the concepts of

the BDI model.

In MASRML, new concepts were created inspired

by the concepts of the standard UML. The main

contribution was the creation of the AgentRoleActor

and InternalUseCase metaclasses to represent agent

roles and the internal functionalities assigned to them,

stereotyped in goals, perceptions, actions, and plans.

Some associations were also created in order to as-

sociate perceptions, actions, and plans to the goals

that an agent role wishes to achieve, thus establish-

ing the conditions for a goal to become an intention

and which plan will be executed in this case, as well

as the possible external actions performed during the

executing a plan.

In addition, MASRML internal use-cases docu-

mentation provides a clear view of the structure of

An Inspection Technique Proposal for the Veriﬁcation of Requirements Speciﬁcation Documents for Multi-Agent Systems

259

cognitive agents, allowing, for example, to determine

what is needed for a given goal to become an inten-

tion or to establish the steps to be performed when

executing a perception or a plan.

3 RELATED WORKS

Several methodologies were proposed supporting re-

quirements engineering. However, the requirements

validation is a subarea that has been neglected in these

methodologies. Based on the study of (Mendonc¸a

et al., 2021), in which, by means of a systematic re-

view sought to establish the state-of-art of methodolo-

gies or processes that covers requirement engineering

for multi-agent systems, we observed that only three

studies support the requirements validation subarea.

Although these three studies ((Cysneiros and Yu,

2002), (Haumer et al., 1999), (Bonjean et al., 2014))

contain in its phases the requirements validation

subarea, none of them proposed a speciﬁc valida-

tion technique for multi-agent systems requirements.

Thus, is evident the need of proposing a new approach

of requirements validation for this kind of system.

Several techniques have been proposed for in-

specting traditional systems, among which we can

quote Fagan in (Fagan, 1976), who proposed the use

of checklists for defect detection; Porter and Votta in

(Porter and Votta, 1994), who presented a scenario-

based technique that provides inspectors with more

speciﬁc instructions than checklists, allowing them to

classify defects and develop questions for each type

of defect; Thelin et al. in (Thelin et al., 2004) who in-

troduced the Usage-Based Reading (UBR), in which

the inspectors use a predeﬁned list of prioritized use

cases; UBR-ir (Thelin et al., 2003), a variation of

UBR that allows inspectors to classify use cases indi-

vidually at the beginning of the inspection process ac-

cording to the inspectors’ experience and understand-

ing. Dunsmore et al. in (Dunsmore et al., 2003),

who presented Use-Case Reading (UCR) to inspect

object-oriented systems considering dynamic interac-

tion with collaborative objects.

However, these techniques were proposed to be

applied in traditional systems, therefore they can-

not be fully used in the requirements veriﬁcation for

multi-agent systems due to the speciﬁc features of this

type of system.

4 PROPOSED ADAPTATION OF

PERSPECTIVE-BASED

READING TO INSPECT

REQUIREMENTS

SPECIFICATION DOCUMENTS

FOR MULTI-AGENT SYSTEMS

The study presented by Ebad in (Ebad, 2017), eval-

uated the evidence about the efﬁcacy of the reading

techniques in the inspection of artifacts produced dur-

ing the requirements, project, and coding phases. In

the requirements phase (requirements engineering),

Ebad states that the ad hoc technique is the simplest

of the techniques, but in this technique the inspec-

tors do not follow guidelines or orientations. In this

same study, the author highlights that the Perspective-

Based Reading (PBR) technique is one of the most

effective for requirements inspection.

PBR provides a set of procedures that can help

developers to solve software requirements inspection

problems. PBR reviewers represent speciﬁc stake-

holders interested in the document (as designers or

testers) to verify the requirements quality (Shull et al.,

2000). The combination of different perspectives re-

sult in a better analysis of the requirements speciﬁca-

tion document, making it possible that it can be com-

pletely checked (Pagliuso et al., 2002).

The PBR technique provides questions developed

speciﬁcally for each step of procedure and this way

it creates representations in order the reviewers can

answer a series of questions about the work product

(Pagliuso et al., 2002). Each inspector must deﬁne

his interest in the document so that it is inspected ac-

cording to the perspective of a speciﬁc involved part.

Thus, considering the evidences pointed by Ebad

in (Ebad, 2017) that PBR is one of the more efﬁcient

techniques for requirements inspection and consider-

ing the statement of Shull in (Shull et al., 2000) that,

depending on the environment where PBR is applied,

it can be ﬁnd a different set of more applicable per-

spectives, we decided to adapt this technique to the

inspection of a requirements speciﬁcation document

produced based on the ISO/IEC/IEEE 29148:2018

standard (ISO/IEC/IEEE 29148, 2018) extended for

the multi-agent system dominion.

That said, in this work, we are proposing the

Agent Simulator Perspective to SRSD inspecting con-

sidering multi-agent systems requirements speciﬁc

characteristics. This perspective aims to determine

whether the requirements describe properly the func-

tionalities to be performed by the agents. This per-

spective inspects Internal Use Cases (IUC), evaluat-

ing if the main, alternative, and exception scenarios

ICAART 2022 - 14th International Conference on Agents and Artiﬁcial Intelligence

260

are described correctly, as well as if the pre-conditions

are deﬁned.

Moreover, basing on the Agent Simulator perspec-

tive, it is possible to verify whether the agent roles

are identiﬁed and detailed, whether the initial beliefs

are described, whether the perceptions are associated

with the goals, and to verify the correctness of the

stereotypes or associations of the internal use cases.

The Agent Simulator Perspective follows a se-

quence of steps. Through these steps, the inspector

simulates the agents behaviors searching for errors or

failures in the requirements speciﬁcation document.

This process can be observed in Figure 1.

As can be seen in Figure 1 the inspection process

has a sequence of activities, however, due to lack of

space, in this paper we will discuss only the activities

performed by the inspector.

After receiving the SRSD, the inspector will per-

form a sequence of six steps. Each of these steps con-

tains a veriﬁcation list that must be followed during

the SRSD inspection. These steps correspond to I)

general inspection of the SRSD; II) general inspec-

tion of each IUC; III) inspection of the internal use

cases of Goal type; IV) inspection of the internal use

cases of Perception type; V) inspection of each partial

use-case diagram for each AgentRoleActor; and VI)

inspection of the general use-case diagram.

The activities performed by the requirements en-

gineering team and by the inspection manager are

similar to the traditional inspection process, however,

the differences between the traditional process and

ours are the activities performed by the inspector.

In our process, the inspector takes the agent per-

spective as discussed previously, so the SRSD will

be inspected considering the speciﬁc characteristics

of multi-agent systems, following the checklists that

we are developing for each of the inspection steps.

Next we will describe every step of our inspection

technique proposal.

4.1 First Step

In this step, the requirements speciﬁcation document

is inspected in a general way. The inspector will

search for completeness, correctness, and consistency

failures types. Some of them are related to the deﬁni-

tion of agent roles, the functionalities associated with

the agents, communication patterns used, and about

the beliefs identiﬁed.

4.2 Second Step

In this step, the inspector must analyse each IUC

searching for types of failures like incorrectness, am-

biguity, untraceability, incompleteness, and inconsis-

tency. Some of these failures are related to the general

structure of each IUC, lack of main scenarios, inter-

pretation ambiguities, or incorrectness in the use-case

scenario texts.

4.3 Third Step

In this step, the inspector must analyse each one of

the internal use cases of the Goal type, searching for

types of failures like correctness, consistency, and

completeness. Some of these failures are related to

stereotype correctness, clarity in the perceptions de-

scription that turns a goal into an intention, or the ex-

istence of perceptions associated with a goal.

4.4 Fourth Step

In this phase, the inspector will analyse each one of

the internal use cases of the Perception type, search-

ing for types of failures like correctness and complete-

ness. Some of these failures are related to stereotype

incorrectness, lack of identiﬁcation or clarity of the

initial beliefs, and lack of pre-conditions deﬁnition.

4.5 Fifth Step

In this step, the inspector must analyse each partial

use case diagram developed for each AgentRoleAc-

tor. The inspector will search for failure types like

correctness and consistency. Some of them are re-

lated to stereotypes incorrectness, incorrectness of the

associations among the diagram components, and in-

correctness of the associations direction.

4.6 Sixth Step

Lastly, in this step, the inspector must analyse the gen-

eral use-case diagram, searching to locate failures of

correctness and completeness type. Some of them are

related to agent roles stereotypes incorrectness, agent

roles and external users identiﬁed in incorrect places,

and the lack of attribution of at least one goal to each

agent role.

5 CONCLUSION AND FUTURE

WORKS

The requirements veriﬁcation and validation is an im-

portant phase of the requirements engineering and

plays a crucial role in the successful of any project

(Gupta et al., 2019). During the veriﬁcation and val-

idation phase the requirements speciﬁcation must be

An Inspection Technique Proposal for the Veriﬁcation of Requirements Speciﬁcation Documents for Multi-Agent Systems

261

Figure 1: Inspection Process of Multi-Agent Systems Requirements.

examined to ensure that all the requirements had been

declared in a non ambiguous way and free of incon-

sistencies, omissions, and errors (Pressman, 2011).

Several techniques were presented for require-

ments inspecting, as for example, the checklist-based

reading, scenarios-based inspection, perspective-

based reading (PBR), use-cases reading (UCR), and

Use-Based Reading (UBR) (Fagan, 1976) (Porter and

Votta, 1994) (Basili et al., 1996) (Dunsmore et al.,

2003) (Thelin et al., 2004).

However, all these techniques were applied to

inspect traditional systems, mainly object-oriented.

Nevertheless, according to Padmanaban et al. in (Pad-

manaban et al., 2016) conventional object-oriented

software tests cannot be applied to agent-oriented sys-

tems due the agents’ features, such as autonomy, pro-

activity, social capabilities, reactivity, and mobility.

Moreover, the new concepts and properties that arise

with the use of the agent paradigm, implies in the

construction of new veriﬁcation and validation ap-

proaches, different from the conventional software

engineering (Fuentes-Fern

andez et al., 2004).

Thus, we proposed in this work a veriﬁcation tech-

nique for a kind of SRSD produced based on an exten-

sion of ISO/IEC/IEEE 29148:2018 standard and on

the MASRML notation. To develop this veriﬁcation

technique we adapted the Perspective-Based Reading

technique, creating the Agent-Simulator perspective.

PBR must be adaptable to the particular docu-

ment it will be inspecting and to the notation used

to produce artifacts and diagrams contained in the

document. Moreover, any technique, including PBR

should be adapted to the particularities of a given en-

vironment in order to be more successful (Ciolkowski

et al., 1997).

To evaluate the applicability and efﬁciency of our

proposed inspection technique, we are applying our

technique in two quasi-experiments. The inspection

is being carried out from a document of requirements

speciﬁcation produced based on the ISO/IEC/IEEE

29148:2018 standard, that was extended to support

requirements for multi-agent systems. This extended

standard uses MASRML notation. The results of the

quasi-experiments will be published in a future work.

As a partial result of the ﬁrst quasi-experiment, we

noticed that, of the 23 failures out of the 25 injected

into the Software Requirements Speciﬁcation Docu-

ment (SRSD), about 92%, were discovered by at least

one of the twelve subjects who participated in the in-

spection.

Therefore, we concluded that the partial results

obtained in the ﬁrst quasi-experiment can indicate

the efﬁciency and applicability of our adaptation of

the PBR technique for the inspection of speciﬁca-

tion requirements documents for multi-agent systems.

Moreover, the quasi-experiment contributed to in-

crease the experience in software inspections of the

students participants.

We are ﬁnalizing the tabulation of the data

collected during the execution of the two quasi-

experiments. We intend to publish the full results in

future works.

ICAART 2022 - 14th International Conference on Agents and Artiﬁcial Intelligence

262

Furthermore, to complement our PBR adaptation

proposal, we are developing checklists for each of the

six steps presented in section 4. These checklists will

have a sequence of pre-deﬁned questions intended to

guide the inspectors through the evaluation process of

the requirements speciﬁcation document.

This work is part of a bigger project that aims to

propose a complete requirements engineering process

for the multi-agent systems development. Thus, this

study contributes to the proposition of a new approach

for multi-agent systems requirements veriﬁcation.

Our inspection proposal was developed for in-

specting SRSDs produced by a speciﬁc requirements

engineering process. These documents are structured

according to the standard ISO/IEC/IEEE 29148:2018

extended to the multi-agent systems context and its

use-case diagrams and documentation are produced

by means of the notation provided by MASRML

(Guedes et al., 2020). However, we believe our in-

spection technique proposal can be adapted to in-

specting other SRSDs produced by other processes of

requirements engineering for multi-agent systems.

As a future work we are developing a guide with

application orientations about our inspection tech-

nique. Thus, we also intend to add this guide to the

requirements engineering process currently in devel-

opment.

REFERENCES

Basili, V. R., Green, S., Laitenberger, O., Lanubile, F.,

Shull, F., Sørumg

ard, S., and Zelkowitz, M. V. (1996).

The empirical investigation of perspective-based read-

ing. Empirical Software Engineering, 1:133–164.

Berenbach, B., Paulish, D., Kazmeier, J., and Rudorfer, A.

(2009). Software & systems requirements engineer-

ing: in practice. McGraw-Hill, Inc.

Bilal, H. A., Ilyas, M., Tariq, Q., and Hummayun, M.

(2016). Requirements validation techniques: An em-

pirical study. International Journal of Computer Ap-

plications, 148(14):5–10.

Bjarnason, E., Per Runeson, M. B., Unterkalmsteiner, M.,

Engstr

om, E., Regnell, B., Sabaliauskaite, G., Locon-

sole, A., Gorschek, T., and Feldt, R. (2014). Chal-

lenges and practices in aligning requirements with

veriﬁcation and validation: a case study of six com-

panies. Empirical Software Engineering.

Bonjean, N., Mefteh, W., Gleizes, M. P., Maurel, C.,

and Migeon, F. (2014). ADELFE 2.0, pages 19–63.

Springer Berlin Heidelberg, Berlin, Heidelberg.

Bordini, R. H., El Fallah Seghrouchni, A., Hindriks, K., Lo-

gan, B., and Ricci, A. (2021). Agent programming in

the cognitive era. In Proceedings of the 20th Interna-

tional Conference on Autonomous Agents and Multi-

Agent Systems, AAMAS ’21, page 1718–1720, Rich-

land, SC. International Foundation for Autonomous

Agents and Multiagent Systems.

Bourque, P., Fairley, R. E., et al. (2014). Guide to the soft-

ware engineering body of knowledge (SWEBOK (R)):

Version 3.0. IEEE Computer Society Press.

Bratman, M. et al. (1987). Intention, plans, and practical

reason, volume 10. Harvard University Press Cam-

bridge, MA. 1-57586-192-5.

Ciolkowski, M., Differding, C., Laitenberger, O., and

unch, J. (1997). Empirical investigation of

perspective-based reading: A replicated experiment.

International Software Engineering Research Net-

work (ISERN).

Cossentino, M. and Seidita, V. (2014). PASSI: Process

for agent societies speciﬁcation and implementation,

pages 287–329. Handbook on Agent-Oriented Design

Processes.

Cuesta, P., G

omez, A., and Gonz

alez, J. C. (2007). Agent

oriented software engineering. Issues in Multi-Agent

Systems.

Cysneiros, L. and Yu, E. (2002). Requirements engineer-

ing for large-scale multi-agent systems. volume 2603,

pages 39–56.

Dunsmore, A., Roper, M., and Wood, M. (2003). The devel-

opment and evaluation of three diverse techniques for

object-oriented code inspection. IEEE Trans. Softw.

Eng., 29(8):677–686.

Dzida, W. and Freitag, R. (1998). Making use of scenarios

for validating analysis and design. IEEE Transactions

on Software Engineering, 24(12):1182–1196.

Ebad, S. A. (2017). Inspection reading techniques applied

to software artifacts - a systematic review. Comput.

Syst. Sci. Eng., 32.

Fagan, M. E. (1976). Design and code inspections to reduce

errors in program development. IBM Systems Journal,

15(3):182–211.

Fogelstr

om, N. and Gorschek, T. (2007). Test-case driven

versus checklist-based inspections of software re-

quirements - an experimental evaluation. In Proceed-

ings of the 10th Workshop on Requirements Engineer-

ing, pages 116–126.

Fuentes-Fern

andez, R., G

omez-Sanz, J. J., and Pav

on, J.

(2004). Veriﬁcation and validation techniques for

multi-agent systems. Upgrade, 5:15–19.

Fuentes-Fern

andez, R., G

omez-Sanz, J. J., and Pav

on, J.

(2009). Requirements elicitation and analysis of mul-

tiagent systems using activity theory. IEEE.

Genza, N. and Mighele, E. (2013). Review on multi-agent

oriented software engineering implementation. Inter-

national Journal of Computer and Information Tech-

nology, 2.

Guedes, G., Souza Filho, I., Gaedicke, L., Mendonc¸a, G.,

Vicari, R., and Brusius, C. (2020). Masrml - a domain-

speciﬁc modeling language for multi-agent systems

requirements. International Journal of Software En-

gineering & Applications (IJSEA), 11(5).

Guedes, G. T. A. and Vicari, R. M. (2010). A uml proﬁle

oriented to the requirements modeling in intelligent

tutoring systems projects. In Bramer, M., editor, Ar-

tiﬁcial Intelligence in Theory and Practice III, pages

An Inspection Technique Proposal for the Veriﬁcation of Requirements Speciﬁcation Documents for Multi-Agent Systems

263

133–142, Berlin, Heidelberg. Springer Berlin Heidel-

berg.

Gupta, A., Deraman, A., and Siddiqui, S. (2019). Bdi logics

for bdi architectures: old problems, new perspectives.

ARPN Journal of Engineering and Applied Sciences,

14(17):3046–3061.

Haumer, P., Heymans, P., Jarke, M., and Pohl, K. (1999).

Bridging the gap between past and future in re: a

scenario-based approach. In Proceedings IEEE In-

ternational Symposium on Requirements Engineering

(Cat. No.PR00188), pages 66–73.

ISO/IEC/IEEE 29148 (2011). Iso/iec/ieee interna-

tional standard - systems and software engineering

– life cycle processes –requirements engineering.

ISO/IEC/IEEE 29148, pages 1–94.

ISO/IEC/IEEE 29148 (2018). Iso/iec/ieee international

standard - systems and software engineering –

life cycle processes – requirements engineering.

ISO/IEC/IEEE 29148:2018(E), pages 1–104.

Khan, H., Asghar, I., Ghayyur, S., and Raza, M. (2015).

An empirical study of software requirements veriﬁca-

tion and validation techniques along their mitigation

strategies. pages 2321–5658.

Koscianski, A. and dos Santos Soares, M. (2007). Quali-

dade de Software-2

Edic¸

ao: Aprenda as metodolo-

gias e t

ecnicas mais modernas para o desenvolvi-

mento de software. Novatec Editora.

Labba, C., Bellamine ben Saoud, N., and Dugdale, J.

(2015). Towards a conceptual framework to support

adaptative agent-based systems partitioning. In 2015

IEEE/ACIS 16th SNPD, pages 1–5.

Mendonc¸a, G., Souza, Filho, I., and Guedes, G. (2021).

A systematic review about requirements engineering

processes for multi-agent systems. In 13th Inter-

national Conference on Agents and Artiﬁcial Intelli-

gence (ICAART 2021), volume 1, pages 69–79.

Padmanaban, R., Thirumaran, M., Suganya, K., and Priya,

R. (2016). Aose methodologies and comparison of

object oriented and agent oriented software testing.

pages 1–16.

Pagliuso, P., Tambascia, C., and Villas-Boas, A. (2002).

Melhoria da inspec¸

ao de requisitos segundo a t

ecnica

de leitura baseada em perspectiva. XI Semin

ario de

Computac¸

ao - XI SEMINCO, 32.

Pornphol, P. and Chittayasothorn, S. (2006). An agent-

based quality assurance assessment system. 5th

WSEAS International Conference on E-ACTIVITIES.

Porter, A. and Votta, L. (1994). An experiment to assess

different defect detection methods for software re-

quirements inspections. In Proceedings of 16th Inter-

national Conference on Software Engineering, pages

103–112.

Pressman, R. (2011). Software Engineering: A Practi-

tioner’s Approach. Bookman.

Rao, A. S. and Georgeff, M. P. (1995). Bdi agents: From

theory to practice. In In Proceedings of the First Inter-

national Conference on Multi-agent Systems (ICMAS-

95, pages 312–319.

Ryan, M. and Wheatcraft, L. (2017). On the use of the

terms veriﬁcation and validation. INCOSE Interna-

tional Symposium, 27:1277–1290.

Shull, F., Rus, I., and Basili, V. (2000). How perspective-

based reading can improve requirements inspections.

Computer, 33(7):73–79.

Sivakumar, N., Vivekan, K., and Kanimozhi, M. (2013).

Testing in prometheus methodology – plan oriented

approach.

Thelin, T., Runeson, P., and Wohlin, C. (2003).

An experimental comparison of usage-based and

checklist-based reading. IEEE Trans. Softw. Eng.,

29(8):687–704.

Thelin, T., Runeson, P., Wohlin, C., Olsson, T., and

Andersson, C. (2004). Evaluation of usage-

based reading—conclusions after three experiments.

9(1–2):77–110.

Torre, S. L. and Parlato, G. (2020). A ﬁxed-point model-

checker for bdi logics over ﬁnite-state worlds. In

OVERLAY.

Ujjwal, K. and Chodorowski, J. (2019). A case study of

adding proactivity in indoor social robots using be-

lief–desire–intention (bdi) model. Biomimetics, 4(74).

Vicari, R. M. and Gluz, J. C. (2007). An intelligent tutor-

ing system (its) view on aose. International Journal

of Agent-Oriented Software Engineering, 1(3-4):295–

333.

Wooldridge, M. (2009). An introduction to multiagent sys-

tems. John Wiley & Sons.

Wooldridge, M. and Jennings, N. R. (1995). Intelligent

agents: Theory and practice. The knowledge engineer-

ing review, 10(2):115–152.

Xu, M., Bauters, K., McAreavey, K., and Liu, W. (2018).

A formal approach to embedding ﬁrst-principles plan-

ning in BDI agent systems. In Ciucci, D., Pasi, G.,

and Vantaggi, B., editors, Scalable Uncertainty Man-

agement - 12th International Conference, SUM 2018,

Milan, Italy, October 3-5, 2018, Proceedings, volume

11142 of Lecture Notes in Computer Science, pages

333–347. Springer.

ICAART 2022 - 14th International Conference on Agents and Artiﬁcial Intelligence

264