Due to the budgetary deadlines and time to market constraints, it is essential to prioritize software requirements. The outcome of requirements prioritization is an ordering of requirements which need to be considered first during the software development process. To achieve a high quality software system, both functional and nonfunctional requirements must be taken into consideration during the prioritization process. Although several requirements prioritization methods have been proposed so far, no particular method or approach is presented to consider both functional and nonfunctional requirements during the prioritization stage. In this paper, we propose an approach which aims to integrate the process of prioritizing functional and nonfunctional requirements. The outcome of applying the proposed approach produces two separate prioritized lists of functional and non-functional requirements. The effectiveness of the proposed approach has been evaluated through an empirical experiment aimed at comparing the approach with the two state-of-the-art-based approaches, analytic hierarchy process (AHP) and hybrid assessment method (HAM). Results show that our proposed approach outperforms AHP and HAM in terms of actual time-consumption while preserving the quality of the results obtained by our proposed approach at a high level of agreement in comparison with the results produced by the other two approaches.
The ultimate goal of developing any software system is to satisfy various stakeholders’ needs [
However, due to the budgetary deadlines and time to market constraints, it could be a challenge for requirements engineers to decide which requirements lead to high stakeholder satisfaction and need to be considered first. To address this concern and in order to reduce the cost and duration of a software project as well, it is essential to address the high-priority requirements before considering the low-priority ones [
The requirements engineering community has classified the requirements of a software system into two main categories: functional requirements and nonfunctional requirements [
Numerous methods on requirements prioritization have been introduced in recent years, the most widely known of which being analytic hierarchy process (AHP) [
In this paper, we introduce integrated prioritization approach (IPA), an approach which prioritizes both functional and nonfunctional requirements simultaneously, producing two prioritized lists of functional requirements and nonfunctional requirements separately. The key contribution of IPA over existing work is to provide a requirements prioritization framework which considers both functional and nonfunctional requirements during the prioritization process. One major characteristic of IPA is that it requires only one decision matrix to perform the prioritization task. In this paper, we have used the term nonfunctional requirements and quality attributes interchangeably to mean the same. Furthermore, in this paper, we describe an empirical study which has been conducted to compare the IPA with the two state-of-the-art-based approaches, analytic hierarchy process (AHP) and hybrid assessment method (HAM).
The remainder of this paper is organized as follows. Requirements prioritization methods from the literature are introduced in Section
As the complexity of software systems increases, practitioners are forced to make trade-offs between conflicting requirements in order to complete projects on predefined schedule. Priority assessment of requirements is one of the techniques which can be useful to assist practitioners to resolve trade-offs. Thus, requirements prioritization has become an increasingly important part of ensuring the success of a project, and, consequently, various works pointed out the importance of the problem of requirements prioritization in the software engineering domain.
Even though prioritization techniques have mostly been adopted with respect to functional requirements [
A rich literature on requirements prioritization is available in the research literature. It includes studies that investigate the requirements prioritization role in software development processes, proposing a number of approaches to carry out requirements prioritization and a growing set of empirical studies dedicated to evaluations giving an account of the benefits and drawbacks of applying a particular approach. Focusing on requirements prioritization approaches, they can be split into two categories, depending on the order relation they ultimately produced. The rank assigned to requirements by a prioritization approach may define either a total ordering of the requirements or a partial ordering. Having a total ordering could simplify the allocation of requirements to the next release. Our work belongs to the first category. In the following, some of the important ones are explained briefly.
One of the powerful and flexible techniques which has been widely used to prioritize requirements is the analytic hierarchy process (AHP), first introduced by Saaty [
In [
Our approach for prioritizing functional and nonfunctional requirements assists practitioners to obtain a prioritized list of nonfunctional requirements (NFRs) along with a prioritized list of functional requirements (FRs). According to Berander and Andrews [
The framework produces a prioritized list of NFRs by calculating the total importance degree of each NFR with respect to all FRs. In other words, it means that an NFR which achieves the greatest total importance degree among all FRs may be assigned as a high-priority NFR with respect to all FRs. Furthermore, it provides a prioritized list of FRs according to the importance degrees of NFRs.
In order to integrate the prioritization of functional and nonfunctional requirements, we proposed an approach, namely, integrated prioritization approach (IPA), consisting of five steps, as shown in Table
Steps of IPA for integrating the prioritization of FRs and NFRs.
Step number | Description |
---|---|
1 | Determine candidate FRs and NFRs |
2 | Construct the decision matrix |
3 | Elicit the importance degree of each NFR with respect to each FR |
4 | Calculate NFRs final ranking with respect to all FRs using triangular fuzzy numbers and alpha cut approach |
5 | Compute FRs final ranking using weighted average decision matrix and weights determined in Step |
The integrated process of generating the prioritized lists of functional and nonfunctional requirements.
As can be observed in Table
The first step of IPA is to identify the FRs and NFRs which are required to be prioritized for inclusion in a software system. Let
The second step is to generate an
The third step elicits the decision maker judgements for determining the importance degree of each NFR for a given FR. To elicit such an extent, the IPA uses two scales: nominal scale and actual scale. Nominal scale is an interface scale which is utilized in order to enhance the user-friendliness of IPA for interacting with decision makers so that the decision maker does not have to know details about the actual scale. On the other side, the actual scale is a numerical scale which is used for internal calculations within IPA. In fact, IPA exploits a five-point scale as actual scale. Table
IPA nominal scale and IPA actual scale.
IPA nominal scale | IPA actual scale |
---|---|
Very high importance (VHI) | 1 |
High importance (HI) | 0.75 |
Low importance (LI) | 0.5 |
Very low importance (VLI) | 0.25 |
No importance (NI) | 0.001 |
Given a pair of FR and NFR (selected from rows and columns of matrix
When all pairs have been evaluated, IPA carries out the priority assessment of NFRs with respect to all FRs, which represents the weights for Step
First, IPA converts all values of the decision matrix
In order to aggregate the different importance degrees of each NFR for different FRs, the triangular fuzzy number (TFN) is calculated. TFN is capable of aggregating the subjective opinions of a decision maker through fuzzy set theory. In this study, we applied TFN since it is the most popular fuzzy number among the various shapes of fuzzy numbers. The triangular fuzzy number
After calculating the TFN value for each NFR, the fuzzy priority vector, namely,
Fuzzy priority vector,
IPA exploits the alpha cut approach, proposed by Lious and Wang [
In this context,
Finally, by normalizing the calculated priority vector,
By applying the steps stated above, a decision maker is provided with a prioritized list of NFRs along with their corresponding importance values with respect to all existing FRs.
During the previous steps, we obtained the priority value of each NFR with respect to all FRs (i.e., NW in Step
Weighted average decision matrix for priority assessment of FRs.
NFRs weights |
|
|
|
|
---|---|---|---|---|
|
|
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
The aggregation method to determine the prioritization of functional requirements in the fifth step of the IPA process is again the calculation of the geometric means but using the obtained normalized priority vector of NFRs (see Substep
The decreasing ordered functional requirements indicate the final ranking, where the most important functional requirement is the one with the highest
An intuitive comprehension of the proposed approach can be achieved by applying the IPA to an example, step by step, to demonstrate how the five steps of the IPA could be utilized for a prioritization problem.
Let us consider a prioritization problem defined over a set of four functional requirements
In this step, a decision matrix of
To fill up the elements of the decision matrix, the judgments of a decision maker are elicited and inserted into the matrix, as indicated in (
To calculate the priority vector of NFRs with respect to all FRs, the elements of matrix
Example of computing NFRs priority vector with respect to all FRs.
|
|
|
| |
---|---|---|---|
|
( |
|
|
|
( |
|
|
|
( |
|
|
In this phase, the ratings (
Example of computing FRs priority vector.
NFRs weights |
|
|
|
|
|
---|---|---|---|---|---|
|
|
| |||
|
|
|
0.25 | 0.637 | 0.249 (3) |
|
|
|
0.25 | 0.388 | 0.152 (4) |
|
0.5 | 1 | 0.75 | 0.704 | 0.275 (2) |
|
|
|
0.75 | 0.828 | 0.324 (1) |
The IPA approach is supported by a software tool called tool-supported integrated prioritization approach (TIPA) which allows automating the steps of the IPA process shown in Figure
A snapshot of the graphical user interface showing a pair of requirements (availability and withdraw money) under evaluation in TIPA.
The tool supports the user in the whole elicitation process. In particular, after the authentication, TIPA presents the user with an agenda of elicitations. The user can analyze the description of requirements for each pair (i.e., FR and NFR) and specify the preference value in terms of the importance degree of every nonfunctional requirement for achieving each functional requirement, by selecting one of the radio buttons indicated in Figure
The tool was developed in Microsoft Visual Studio 2008 and. NET Framework 3.5 using C
Here, we describe in detail the experiment which we carried out during this study. Table
Overview of empirical assessment performed on IPA.
Goal | Analyze the actual time-consumption property of three different prioritization approaches: IPA, AHP-based, and HAM |
Independent variable | Prioritization approaches: IPA; AHP-based, and HAM |
Dependent variable and measure | Actual time-consumption (measured as computing the difference between start and end time of the prioritization task); results quality (measured in terms of agreement) |
Empirical study approach | Simulated case study with real subject: banking software system; 20 requirements including 15 functional requirements and 5 nonfunctional requirements |
The main goal of this experiment is to investigate the actual time-consumption property while using the IPA (see Section which approach between IPA and AHP-based approach is less time-consuming in performing the whole prioritization task? are ranks obtained by IPA and AHP similar? which approach between IPA and HAM is less time-consuming in performing the whole prioritization task? are ranks obtained by IPA and HAM similar?
The ultimate goal is to collect evidence whether IPA outperforms the two state-of-the-art-based approaches with respect to the actual time-consumption property.
To perform an effective assessment of a requirement prioritization approach, a key issue is to decide which approches’ properties need to be measured [
Furthermore, in order to have a measure of the difference between the rankings produced by IPA and the rankings generated by AHP as well as HAM, we use the agreement measure which has been proposed in [
To be able to perform a comparative evaluation of IPA, we present here another prioritization approach which aims to prioritize functional requirements and nonfunctional requirements separately using a state-of-the-art method such as AHP [
The analytic hierarchy process (AHP) [
Possible scales used for AHP’s pairwise comparison [
Relative intensity | Definition | Explanation |
---|---|---|
1 | Of equal value | Two requirements are of equal value |
3 | Slightly more value | Experience slightly favors one requirement over another |
5 | Essential or strong value | Experience strongly favors one requirement over another |
7 | Very strong value | A requirement is strongly favored and its dominance is demonstrated in practice |
9 | Extreme value | The evidence favoring one over another is of the highest possible order of affirmation |
|
Intermediate values between two adjacent judgments | When comprise is needed |
Reciprocals |
If requirement |
In our case, to obtain the prioritized lists of functional and nonfunctional requirements, two tasks should be performed separately, applying the AHP method on the candidate list of functional requirements and also applying the AHP method on the candidate list of nonfunctional requirements.
This section describes the tool that was developed within our study for applying the AHP method named Csharp analytic hierarchy process (CAHP) which allows automating the steps of the AHP method described in Section
A snapshot of the graphical user interface showing a pair of requirements (withdraw money, check balance) under evaluation in CAHP.
The tool supports the whole evaluation process. In particular, after the authentication, the tool presents the user with an agenda of
Analogously to TIPA, the CAHP was developed in Microsoft Visual Studio 2008 and .NET Framework 3.5 using C
In this section, we describe briefly the hybrid assessment method (HAM), proposed by Ribeiro et al. [
HAM is an integrated multiple criteria decision-making method that combines one pairwise comparison matrix with one classical multicriteria decision matrix to support the process of prioritizing a set of alternatives based on a set of criteria. In fact, HAM is a two-phase method which begins the prioritization task by eliciting the criteria and the alternatives. The second step performs trade-offs between criteria using pairwise comparisons. The third step is to calculate the criteria priority vector, normalize the respective weights, and calculate the consistency ratio. These three steps belong to Phase 1 of the HAM and correspond to an automated determination of weights for the decision matrix. Phase 2 starts in step four, which elicits the contributions of each alternative with respect to each criterion, using a classical weighted average decision matrix. The fifth and final step is an aggregation process to determine the prioritization of alternatives (ranking) using a geometric aggregation operator. This step concludes HAM’s process by providing the ratings for each alternative. Interested readers may refer to [
In this study, we used the HAM with the goal of integrating the prioritization of functional and nonfunctional requirements. In such case, we consider nonfunctional requirements and functional requirements as the criteria and the alternatives of HAM’s process, respectively. Therefore, Phase 1 of HAM’s process is applied in order to obtain the prioritized list of nonfunctional requirements while the second phase is performed to produce the prioritized list of functional requirements. The following section illustrates the tool that implements the desired tasks.
This section explains the software tool that was developed within our research for implementing the HAM method, namely, Csharp hybrid assessment method (CHAM), aiming at automating the steps of the HAM method explained in Section
A snapshot of the graphical user interface showing a pair of nonfunctional requirements (availability, security) under evaluation in CHAM.
A snapshot of the graphical user interface showing a pair of nonfunctional and functional requirements (availability, withdraw money) under evaluation in CHAM.
The tool supports the whole prioritization process. In particular, after the authentication, CHAM displays to the user an agenda of pairwise comparisons of nonfunctional requirements (see Figure
The tool was developed in Microsoft Visual Studio 2008 and .NET Framework 3.5 using C
We are interested in giving experimental evidence of the capability of the IPA to reduce the actual time-consumption of the prioritization task while preserving the results quality.
For this purpose, during this study, we carried out the experiment aims at investigating the actual time-consumption property of the proposed approach, IPA, in comparison with the other two state-of-the-art-based approaches such as AHP and HAM. Moreover, to analyze the quality of the results produced as output by the IPA approach, we compared IPA’s results (i.e., the prioritized lists of functional and nonfunctional requirements) with the results obtained by AHP and HAM. To achieve the desired goals, we evaluated two variables called actual time-consumption and results quality throughout this experiment. To evaluate the actual time-consumption property, we monitored automatically the start time as well as the end time of the prioritization task while using the IPA, AHP, and HAM. In addition, in order to assess the quality of the results produced by IPA in comparison with AHP and HAM, we used the agreement measure which has been described in Section
The outline of the experiment is given in the following. The twenty requirements used during our experiment were the requirements of a simulated banking software system, which were divided into two different categories: 15 functional requirements and 5 nonfunctional requirements. These requirements were high level and rather independent requirements that have been selected taking into consideration that they have to be clear enough even for novice users. All requirements were represented as simple textual descriptions. The prioritization was performed without taking into account dependencies among requirements. The subject involved in the experiment is a researcher who has a Ph.D. degree with experience in industrial and research projects and currently has been served as Postdoc at Wisma R&D, University of Malaya, Kuala Lumpur, Malaysia. He has also a good knowledge about different types of software requirements, programming languages, and software engineering domain since he has got his B.S., M.S., and Ph.D. degrees in software engineering. So, we believe that the selected subject for our experiment can be considered not far from industrial developer/analyst.
Before running the experiment, we provided a brief presentation to the subject who participated in our experiment with the purpose of giving an introduction on the requirements, prioritization problem and on available methods, IPA, AHP, and HAM, as well as the simulated banking software system. Examples of functional and nonfunctional requirements of the banking software system were explained in order to clarify them. Moreover, we provided a short training on the tools, TIPA, CAHP, and CHAM. Those tools were also tested on a small set of requirements.
The experiment took place in a research laboratory room equipped with computers. A computer with access to TIPA, CAHP, and CHAM has been provided to the subject. The twenty requirements, including 15 functional requirements and 5 nonfunctional requirements, were inserted in advance to the software tools. Given the same set of functional and nonfunctional requirements, the subject executed the three prioritization tasks sequentially. The order of executions was assigned randomly in order to minimize the effect of the order. The experiment took more than 2 hours, including introductory presentation and training on the tools, as well as the short break of 8 minutes between the two prioritization tasks.
This section describes the main results obtained from the experiment we conducted. The analysis was performed using Microsoft Excel.
Actual time-consumption for the prioritization.
IPA | AHP | Difference | |
---|---|---|---|
Actual |
944 sec (15.7 min) | 1425 sec (23.7 min) | 481 sec (8 min) |
% | — | — | 34% |
The actual time-consumption for each prioritization task, derived from start/end times recording automatically by the prioritization tools.
Agreement between the IPA and AHP rankings of functional requirements.
Agreement between the IPA and AHP rankings of nonfunctional requirements.
Actual time-consumption for the prioritization.
IPA | HAM | Difference (HAM − IPA) | |
---|---|---|---|
Actual time-consumption | 944 sec (15.7 min) | 1055 sec (17.5 min) | 111 sec (1.8 min) |
% | — | — | 11% |
The actual time-consumption for each prioritization task, derived from start/end times recording automatically by TIPA and CHAM.
Agreement between the IPA and HAM rankings of functional requirements.
Agreement between the IPA and HAM rankings of nonfunctional requirements.
The observations concerning the actual time-consumption of the three prioritization approaches, IPA, AHP, and HAM, indicate that our proposed approach, IPA, outperforms the other two state-of-the-art-based approaches while at the same time the analysis of the agreement of the rankings produced by these approaches for both functional and nonfunctional requirements shows that IPA preserves the quality of the results obtained by this approach at a high level of agreement in comparison with the results produced by the other two approaches (i.e., AHP and HAM). Regarding the actual time-consumption, the difference between the three approaches seems to depend mainly on the number of comparisons requested to the subject by these approaches where it is 115 for AHP, 85 for HAM, and 75 for IPA. Furthermore, the different range of the values used for expressing a preference applied by the three approaches could have contributed to this difference in time-consumption.
As a final observation, the results point out that IPA should be preferred to AHP and HAM in the prioritization problems with the following characteristics: in those problems, the prioritization of both functional and nonfunctional requirements is needed early in the life cycle meanwhile the time-consumption is a main issue within those problems for performing the prioritization tasks.
We believe that the analysis of the specific results for actual time-consumption and the level of agreement may be used as a pilot study for identifying trends before conducting a study in industry since it gives useful information to guide the selection of the most appropriate approach when deciding which prioritization approach to use for a given project in an organization.
In this paper, we presented a detailed description of the IPA approach for software requirements prioritization.
The software engineering community has been criticizing the lack of an approach which enables practitioners to integrate the prioritization of functional and nonfunctional requirements [
The effectiveness of the proposed approach has been evaluated through an empirical experiment aimed at comparing the IPA with the two state-of-the-art-based approaches, AHP and HAM. We focused mainly on two measures: the actual time-consumption and the results quality. The experiment has been conducted on a simulated case study which consists of twenty requirements including 15 functional and 5 nonfunctional requirements. The main conclusion that can be drawn from the results of the experiment is that the IPA is superior to both AHP and HAM regarding the actual time-consumption while the results produced by IPA are very similar to the results obtained by the other two approaches. Although the generalization of the presented experiment to industrial practice is not straightforward, the results are an important basis for the planning of industrial case studies.
We are currently conducting the same experiment with the one performed in this study but with the participation of more subjects to get a larger data set and thereby to find a stronger basis for our conclusions. As part of the future work, it would be of interest to carry out a controlled experiment in a real industrial setting to see how similar are the results with our findings.
The authors declare that there is no conflict of interests regarding the publication of this paper.
This work has been carried out within the framework of the research project conducted at the University of Malaya. The research project is supported by High Impact Research Grant with Reference UM.C/625/1/HIR/MOHE/FCSIT/13, funded by the Ministry of Education, Malaysia.