Conference PaperPDF Available

Figures

Content may be subject to copyright.
A Novel Approach for Software Requirement
Prioritization Based Upon Non Functional Requirements
Kashif Ayub, Farooque Azam, Muhammad Waseem Anwar, Anam Amjad and Muhammad Shah Jahan
Department of Computer Software Engineering, National University of Sciences & Technology (NUST),
Islamabad, Pakistan
Muhammad.kashif18@ce.ceme.edu.pk,Farooq@ceme.nust.edu.pk,waseemanwar@ceme.nust.edu.pk,
anam.amjad@ceme.nust.edu.pk,shah.jahan18@ce.ceme.edu.pk
Abstract- Software becomes an essential part of our lives
because of the required automation in every field. A software
requirement plays an important role in its development. In
requirement engineering, requirement prioritization is the
crucial activity to
successful
ly deliver the software system.
Numerous techniques exist for software requirement
prioritization such as Cumulative Voting, Hieratical
Cumulative Voting, Planning Games (PG), and MOSCOW etc.
But it is analyzed that these techniques are insufficient to
prioritize large number of requirements and in most of the
cases requirement engineer just prioritizes the functional
requirements and ignore non
-
functional requirements. It
becomes a challenge to prioritize Non-Functional
Requirements (NFRs) in order to justify which requirement
has higher priority along with functional requirements in large
software systems. In order to overcome this gap, we have
proposed a novel approach ”PGAHP” for Requirements
Prioritization by merging Planning Games (PG) and analytical
hierarchy process (AHP) c
oncepts. Proposed approach
PGAHP is validated using Library Management System case
study. Results shows that complexity to prioritize requirements
is decreased by using PGAHPby performing thirty one (31)
pair of comparison as compare to AHP which has (105) pair
wise comparison for the same number of functional and non-
functional requirements.
Keywords-Components: Software requirement
prioritization; analytical hierarchy process; Non-functional
requirements
I. INTRODUCTION
Requirements are very important aspect of software
development. Software projects like other projects have
tight schedule, scope and cost. There should be some type of
requirement prioritization so that the development team
manages their resource and the customer could get their
most important functionally as soon as possible. Among the
activities of Software Development Life Cycle (SDLC)
which includes feasibility study, requirement collection,
requirement validation, requirement specification and
management. Requirement prioritization is one of the most
important activities of requirement engineering process.
Until, we do not categorize the requirements according to
business value or its ro
le to obtain business goals, it is not
possible to achieve success of the software project.
For this purpose, we need to prioritize the Functional
requirements (FRs) [1] in such a way that we can visualize
which requirements should be implemented first and which
should be in next release. There are different requirement
prioritization techniques among which Analytical Hierarchy
Processing (AHP) is one of the popular techniques of
prioritizing requirements [2] which helps to find out the
order of requirements by comparing each requirement with
other requirements to ease requirement engineer.
Other well-known requirements prioritization techniques
are Planning Game (PG), Cumulative voting and MOSCOW
etc. [3]. A new trend is use of fuzzy logic in different
existing techniques for requirement prioritization like [1]
Fuzzy Logic [4] and Decision Tree Adaptive Fuzzy
Hierarchical Cumulative Voting and
Fuzzy Moscow etc.
The need to prioritize the requirements [5] is to avoid
project delays and failures. If we do not use appropriate
requirement prioritization technique, its leads to project
failure [6]. It is analyzed that most research studies focus on
the functional requirement prioritization and neglect the
NFRs while prioritizing FRs [1]. It is also observed that
non-functional requirements are avoide
d in those cases
where requirement engineer deals with large number of
requirements. It means if we have hundreds of requirements
and if we want to apply AHP on those requirements this
way will be very complex to deal with the N*M number of
requirements. If we have fifteen (15) requirements, we need
to construct one hundred and five (105) pairwise
comparisons. It becomes time consuming activity and it is
difficult to manage.
As shown in Fig.
1, our proposed novel approach [7]
“PGAHP” is the combination of planning games, AHP and
also Non-functional requirements. We will apply planning
games on all functional requirements which helps to reduce
the complexity by dividing all FRs into three sections
according to their business value and it will also resolve the
problem of the two or more requirements which have same
priority by the help of NFRs. User involvement is very
important because of the successful implementation of
planning games.
8
2019 7th International Conference in Software Engineering Research and Innovation (CONISOFT)
978-1-7281-2524-4/19/$31.00 ©2019 IEEE
DOI 10.1109/CONISOFT.2019.00013
Fig.1. Overview of research
Rest of the paper is structured as follows. Section II
provides the extensive literature review on requirement
prioritization techniques. In Section III, proposed
methodology is described. Section IV highlights the
validation of the proposed approach using case study. The
discussion is carried out in Section V. Finally, Section VI
concludes the research with future directions.
II. LITERATURE REVIEW
Umang Garg. [8] Presented that software system is
developed on the basis of functional requirements. If we do
not prioritize the functional requirements, then it will affect
badly while delivering the software because in most of the
cases prioritization is performed on the basis of functional
requirement and neglects the non-functional requirements.
In this paper, author has
used a pairwise comparison to
assign the important value to Non-Functional Requirements
(NFRs) and then prioritize the Functional Requirement
(FRs) on the basic of non-functional requirements using
Analytical Hierarchy Processing (AHP).
Richard R. Maiti. [9] describes that while developing
software in agile which is a quick pr
ocess of d
evelopment
also favors the functional requirement and disregard non-
functional requirements which can have adverse effect on
the software. Result will be low quality and high cost. They
use CEP methodology which use to Alpha Beta Gamma
Framework in prioritizing NFRs. The flexibility of the
process is the ease of allowing sub processes to be
interchange by other technique.
Fadoua Fellir [10] presented that in most of the cases
software applications are developed on the basis of FRs and
disregard NFRs which have negative impact on
development process and also on the of deployment will
increase the cost and time reduce the quality on the
software. In this paper, they present pairwise prioritization
process by considering interdependency relationship
between FR and NFR. This is also very useful to overcome
the weak points of the AHP.
Raj Kumar Chopra. [11] described the importance of the
non-
functional requirements which is not demanded by the
user. They use three approaches for requirement
prioritization for functional and nonfunctional requirements
using AHP and then prove the better approach. They have
proposed hybrid approach in which NFRs are prioritized
independently like FR but their selection must be
accordance to functionality of the software.
Mohamad Kassab. [12] Contributed in the direction of
NFRs which are very difficult to manage because they are
highly interdependent with each other and changing one
requirement can have a great effect on the other
requirements. To solve this problem, authors have used
NFRs existing framework with AHP to overcome the
problem of dependency. Similarly, in another paper,
Mohammad Dabbagh. [13] Highlighted that requirements
prioritization is critical but neglected during software
development. They introduce an approach Named Hybrid
Assessment Method (HAM) with state of the art approach
AHP to prioritize both function and non-functional
requirement at the same time.
Nelly Condori-Fernandez. [14] used nominal based
prioritization technique. This technique collects Top 10
requirements at which one requirement is more important
than the other. The ordinal based technique (e.g. CV and
ranking) are not able to quantify the relative priority of
ordered requirements.
Few research studies proposed new requirement
prioritization technique such as Sher, F., et al. [15] proposed
software requirement prioritization techniques depending
upon technical, business and client aspect. It compares not
only existing nine techniques like bubble sort, AHP, NAT
etc. but also a hybrid approach which is using Planning
Game(PG) with AHP. First divide requirements into three
groups which are on ordinal scale and then apply AHP.
Similarly,
Sadiq. [15] proposed
a new algorithm for
Software Requirement Prioritization which is
AHP_GORE_PSR. This algorithm works using AHP on
AGORA. In AGORA there is no support to check whether
the decision was consistent or nor. They apply AHP on this
set of requirements.
Among these requirement prioritization techniques,
every technique has advantages and disadvantages. To
overcome the issue of prioritizing large number of
functional and non-functional requirements, we have
selected planning game and AHP which are widely used in
existing literature.
9
A. Planning games
The planning game technique is mostly used in
the software planning process in context of
agile development [16]. The planning game is a meeting
consisting of both the developers and the customers.
Planning games is used to prioritize the requirements in
three sections defined by the user according to its business
objectives. These sections will be according to “th
ose
without which the system will not function”, “those that are
less essential but significant business value” and “Those
would be nice to have”. User will drop its extremely
important requirements in first section and very important in
second section and least important in third section
accordingly. This will reduce the complexity and of n (n-
1)/2
B. AHP
This is mostly used technique introduced by Thomas
Satty in 1970.Pairwise comparison[3, 17] is used in this
technique to estimate the importance of the requirements
with each other. By this we become able to justify which
requirement is most important and which is least important.
This helps us to determine which requirements should be
included in the first release and vice versa[18].
This technique uses pairwise comparison of all user
requirements. The requirement umber of comparison grows
polynomial, for example if we have n number of
requirements then the comparison, we need to do n(n-1)/2
comparisons which are quite complex for large set of
requirements.
III. PROPOSED METHODOLOGY
In this section, we will explain our proposed technique
which is the combination of planning games, AHP and non-
functional requirements. We will apply AHP on planning
games and then also resolve the problem of two or more
requirements having same priority.
Table I: PGAHP as novel approach
Planning Games
AHP
Categorization
Pairwise
Comparison
Ordinal
Ranking
Ranking
A. PGAHP”
Now, we will define our approach which is the
combination of planning games and AHP and NFRs at last
[19]. The main purpose of requirements prioritization is to
provide most important requirements of the user in first
release and so on. Planning games divide the requirements
into three sections which reduces the complexity while
handling and make us able to visualize which is most
important for user. If we are dealing with big project then
it’s very difficult to deliver all high priority requirements
which rely in first section at the same time. This is because
we will apply AHP on each section it will help us to make
us able to know which requirements have more priority in
same section. Our proposed methodology includes
following steps as represented in Fig.2.
1. Collect all functional and their related non-
functional requirements from the user using a good
elicitation technique and well defined format
2. Define three section (“1.those without which the
system will not function”, “2.those that are less
essential but significant business value” and
“3.Those would be nice to have”) and ask user to
drop i
ts requirements into these section according
to its business objectives.
3. Construct pairwise comparison of all the functional
requirements in section 1 and take sum of each
column.
4. Take average of each field and normalize the
requirements.
5. Take sum of each row and get priority sum and
produce percentage of each requirement.
6. Collect those functional requirements which
having
same probability. If yes move to step 7 else move
to step 10.
7. Collect NFRs of the functional requirements
related to them which have same probability.
8. Apply pairwise comparison using AHP on FRs and
their related NFRs.
9. Compare the requirements and produce the result
in prioritized form.
10. Make decision and start from step 3 for 2nd section
and so on till no section left.
F
ig.2.
Overview of PGAHP
PGAHP
10
As the user participation is increased it will help the
requirements engineer to give idea which requirements are
more important for user to achieve their business goal and
also provide idea which requirements are need to deliver
first. It is important to mention that requirements for
proposed solution are mentioned. It includes the following
requirements.
1. Collect all function and their related non-functional
requirements
2. Requirements should be in textual form using well
defined elicitation technique.
3. User should have knowledge of its business goals
and objectives to divide its requirements into three
sections in planning games.
4. Developer should have knowledge of non-
functional requirements related to each functional
requirement to get from user for applying AHP on
each section.
5. The format of output will be textual. Tabular data
will be presented.
IV. VALIDATION
Here, our proposed technique is validated using Library
Management System (LMS) case study. The aim of this
Library Management system is to provide functionality of
issues in book to the students of different courses. Library
Management System will show all the available books,
generate the priority of students, send SMS to users when
book available, candidate returned books on date if not then
will submit fine of RS.
20 per day as late returned fee.
Step 1: Collect all the functional requirements and NFRs in
well-defined format
R1: There should be a Login module of LMS
R2: There must be a Check the availability of the books
R3: The system would generate the priority of the students
R4: Information of availability of books would be sent
through SMS
R5: There should be list of Candidates who have submitted
books after due date
R6: fee should be submitted for late book
R7: It could inform the Chief Librarian, if the book is not
available for a particular course
R8: It must provide inter-library loan module
R9: The data of all users and books should be stored in
database
R10: There Must provide electronic packing slip when
provide a book as loan
R11: Should authenticate the checkout of journals, books
R12:
Check out the returning material must be using
barcode
R13: When a student brings personal books, it would be
registered
R14: The librarian should add new books or update existing
ones
R15: It must provide online public access catalog providing
search functionality
Step 2: Apply planning games technique on all FRs and ask
user to divide requirements into three set according to its
business objectives
Table II: Applying planning games
Section 1 (Extremely
Important)
Section
2(Important)
Section 3(Least
Important)
R1
R2
R3
R8
R5
R4
R10
R6
R7
R12
R9
R13
R15
R11
R14
User involvement is very important to make this partition.
This partition is totally defined on the basis of user business
priorities and according to the need of the user to get their
business goals. So we develop a partition As shown in Table
II, R1
, R8, R10, R12, R15 belongs to section 1 which means
“those without which the system will not function” we will
give these requirements in the first release. R2, R5, R6, R9,
R11, R14 belongs to section 2 which means “those that are
less essential but significant business value” and R3, R4,
R7, R13 belongs to section 3 which means “Those would be
nice to have”.
Step 3:Now apply AHP [10]on all functional requirements
of first section using pairwise comparison matrix.
Table III: Pairwise comparison matrix
R1
R8
R10
R12
R15
R1
1
7
7
7
1
R8
1/7
1
5
5
1/7
R10
1/7
1/5
1
3
1/7
R12
1/7
1/5
1/3
1
1/7
R15
1
7
7
7
1
Sum of
Column
10.4
8.73
9.4
9.4
1.56
As shown in Table III, we will construct a pairwise for
comparing FRs in section 1 with each other. We will
11
compare each requirement with all other requirements in
first section and assign intensity of importance to each
requirement as shown Table II. And then we will calculate
the sum of all the columns separately. Pairwise comparison
value for section 1 will be 5(5-1)/2=10. If do not apply
planning games then for all the requirements will be 15(15-
1)/2=105 and it becomes very difficult to deal with large
number of requirements.
Step 4: In this section we will take average of each field by
taking the sum of its related column and then normalize
them.
Table IV: Averaging and normalizing of matrix
R1
R8
R10
R12
R15
R1
0.41
0.47
0.34
0.30
0.41
R8
0.06
0.07
0.25
0.22
0.06
R10
0.06
0.01
0.05
0.13
0.06
R12
0.06
0.01
0.02
0.04
0.06
R15
0.41
0.47
0.34
0.30
0.41
Step 5: Take the sum of all the rows and then divide the sum
by the number of requirements
By performing this action, we will be able to visualize
which requirement has more probability and will generate
the percentage of each requirement by multiplying priority
sum by hundred.
Table V: Priority Values and Percentage
R1
R8
R10
R12
R15
Sum of Row
Priority
Sum/5
%age
R1
0.41
0.47
0.34
0.30
0.41
1.93
0.38
38%
R8
0.06
0.07
0.25
0.22
0.06
0.66
0.13
13%
R10
0.06
0.01
0.05
0.13
0.06
0.31
0.06
6%
R12
0.04
0.01
0.02
0.04
0.06
0.19
0.04
4%
R15
0.41
0.47
0.34
0.30
0.41
1.93
0.38
38%
Step 6: In this section we will collect functional
requirements R1 and R15 because both have same
probability as shown in Table V.
Table VI: Percentage
Serial
Number
Requirement
Number
Priority Percentage
1
R1
38%
5
R15
38%
Step 7: In this step we will collect NFRs[20], [10] related to
these two functional requirements. As we know both
requirements have same priority.
Table VII: Pairwise comparison
R1
R15
PRIORITY
R1
1/2
1/2
0.5
R15
1/2
1/2
0.5
R1 have following NFRs
NFR1: security
NFR2: budget constrain
NFR3: response time constraint
NFR4: Using C++ language is needed
R15 have following NFRs
NFR1: using existing software resources
NFR2: Usability
Step 8: In this step we will apply pairwise comparison
using AHP [10] on the both functional and their related
non-functional requirements.
AHP for R1
Comparison between R1 and its related non-functional
requirements
Table VIII: Pairwise comparison matrix
R1
NFR1
NFR2
NFR3
NFR4
R1
1
1/5
2
4
2
NFR1
5
1
7
9
7
NFR2
½
1/7
1
2
3
NFR3
¼
1/9
1/2
1
3
NFR4
½
1/7
1/3
1/3
1
Sum of column
7.45
1.60
10.83
16.33
16
Averaging and adjustment: In this step, we will divide
each field by the sum of columns.
12
Table IX: Averaging and normalizing of matrix
R1
NFR1
NFR2
NFR3
NFR4
R1
0.13
0.12
0.2
0.24
0.12
NFR1
0.70
0.62
0.65
0.55
0.43
NFR2
0.07
0.09
0.09
0.12
0.19
NFR3
0.03
0.07
0.05
0.06
0.19
NFR4
0.07
0.09
0.03
0.02
0.06
Get Sum of Rows And priority Sum: Here, we will take
the sum of each row and also calculate the priority sum by
dividing sum of row by number of requirements
.
Table X: Priority Values and percentage
R
1
NFR 1
NFR2
NFR3
NFR4
Sum of Rows
Priority Sum
%age
R1
0.13
0.12
0.2
0.24
0.12
0.81
0.16
16%
NFR1
0.70
0.62
0.65
0.55
0.43
2.95
0.59
59%
NFR2
0.07
0.09
0.09
0.12
0.19
0.56
0.11
11%
NFR3
0.03
0.07
0.05
0.06
0.19
0.40
0.08
8%
NFR4
0.07
0.09
0.03
0.02
0.06
0.27
0.05
5%
AHP for R15: Comparison between R15 and its related
non-functional requirements is shown below.
TABLE XI: Pairwise comparison matrix
R15
NFR5
NFR6
R15
1
3
5
NFR5
1/3
1
3
NFR6
1/5
1/3
1
Sum of Column
1.53
4.33
9
Averaging and adjustment: In this section we will divide
each field by the sum of column as presented.
Table XII: Averaging and normalizing of matrix
R15
NFR5
NFR6
R15
0.65
0.70
0.55
NFR5
0.21
0.23
0.33
NFR6
0.13
0.07
0.11
Get sum of rows And priority Sum: Here we will take the
sum of each row and also calculate the priority sum by
dividing sum of row by number of requirement.
Table XIII: Priority Values
R15
NFR5
NFR6
Sum of
Row
Priority
Sum
%age
R15
0.65
0.70
0.55
1.90
0.63
63%
NFR5
0.21
0.23
0.33
0.77
0.26
26%
NFR6
0.13
0.07
0.11
0.31
0.10
10%
Step 9: Here we will compare the functional requirement
priority or percentage with its related non-functional
requirements.
Before applying AHP on functional and its related non-
functional requirements.
R1=R15
0.5=0.5
After apply AHP on functional and its related non-
functional requirement NFR1 have greater priority then R1.
After this we can clearly see
R1>R15
After this the requirement engineer can clear visualize
which requirements out of both requirements have more
priority. And its help which implementation of the
requirements.
Step 10: In this section requirement engineer will implement
the requirements or leave this here and move to the next.
This step is up to the organization. After the completion of
this step, proceed to step 3 for 2nd
secti
on and implement all
the steps for second sections and so on till no section left.
V. DISCUSSION
As we defined before we are reducing the complexity and
memory of pairwise comparison by applying AHP. We can
prove it simply by applying the formula for counting the
total number of pairwise comparison n(n-1)/2. Here n is
number of requirements if put values in it.
Number of pairwise comparison for section 1
Numbers of requirements in section 1 are five (5). By
putting the values in formula we obtain following number of
pairwise comparisons.
13
5(5-1)/2
5(4)/2=10
Number of pairwise comparison for section 2
Numbers of requirements in section 2 are six (6) and by
putting the values in formula, we get following number of
pairwise comparisons.
6(6-1)/2
6(5)/2=15
Number of pairwise comparison for section 2
Numbers of requirements in section 3 are four (4) and by
putting the values in formula, we get the following results.
4(4-1)/2
4(3)/2=6
Total number of pairwise comparison for all three sections
will be thirty one (10+15+6=31).
Total number of comparison without planning games:
Total number of requirements is one. By putting values, we
get following number of comparisons.
15(15-1)/2
15(14)/2=105
As we can clearly see in Fig. 3, we can reduce the
complexity by applying planning games on requirements.
Fig.3. PGAHP and AHP pairwise comparison on 15 FRS
VI. CONCLUSION AND FUTURE WORK
In order to perform efficient requirement prioritization,
few problems are analyzed which are length of comparison
matrix for hundreds of requirements and ignorance of Non-
Functional Requirements. To resolve these fundamental
issues, PGAHP is proposed which is a novel approach for
software requirement prioritization based upon non-
functional requirements. Following contributions are made.
Firstly we are dealing with the length of pairwise
comparison for hundreds of requirements by dividing all the
fun
ctional requi
rements using planning games. Secondly,
prioritization of all the functional requirements by applying
AHP on each set of requirements is performed. Lastly, we
found those requirements which have same priority and also
find their related non-functional requirements. Our proposed
technique is applicable also on those projects which have
large number of requirements. Moreover, this approach can
be extended with user’s involvement which is also very
essential because of the planning games implement
ation.
REFERENCES
[1] Ahuja, H. and G. Purohit. Understanding
requirement prioritization techniques. in 2016
International Conference on Computing,
Communication and Automation (ICCCA). 2016.
IEEE.
[2] Sufian, M., et al. A Systematic Literature Review:
Software Requirements Prioritization Techniques.
in 2018 IEEE International Conference on
Frontiers of Information Technology (FIT). 2018.
[3] Amelia, T. and R.B. Mohamed. Review on Cost-
Value Approach for Requirements Prioritization
Techniques. in 2018 5th International Conference
on Information Technology, Computer, and
Electrical Engineering (ICITACEE). 2018. IEEE.
[4] Jawale, B.B., G.K. Patnaik, and A.T. Bhole.
Requirement prioritization using adaptive fuzzy
hierarchical cumulative voting. in 2017 IEEE 7th
International Advance Computing Conference
(IACC). 2017. IEEE.
[5] Yousuf, M., M.U. Bokhari, and M. Zeyauddin. An
analysis of software requirements prioritization
techniques: A detailed survey. in 2016 3rd
International Conference on
Computing for
Sustainable Global Development (INDIACom).
2016. IEEE.
[6] Chandani, P. and C. Gupta. Requirement Risk
Prioritization Using Analytic Hierarchy Process: A
Gateway to Identify Risky Requirements. in 2018
Eleventh International Conference on
Contemporary Computing (IC3). 2018. IEEE.
[7] Santos, R., A. Albuquerque, and P.R. Pinheiro,
Towards the Applied Hybrid Model in
Requirements Prioritization. Procedia Computer
Science, 2016. 91: p. 909-918.
[8] Garg, U. and A. Singhal. Software requirement
p
rioritization based on non-functional
requirements. in 2017 7th IEEE International
Conference on Cloud Computing, Data Science &
Engineering-Confluence. 2017.
[9] Maiti, R.R. and F.J. Mitropoulos. Prioritizing non-
functional requirements in agile software
engineering. in Proceedings of the SouthEast
Conference. 2017. ACM.
[10] Fellir, F., K. Nafil, and R. Touahni. System
requirements prioritization based on AHP. in 2014
Third IEEE International Colloquium in
Information Science and Technology (CIST). 2014.
IEEE.
[11] Chopra, R.K., V. Gupta, and D.S. Chauhan,
Experimentation on accuracy of non functional
requirement prioritization approaches for different
complexity projects. Perspectives in Science, 2016.
8: p. 79-82.
0
200
AHP PGAHP
Column2
Column1
14
[12] Kassab, M. An integrated approach of AHP and
NFRs framework. in IEEE 7th International
Conference on Research Challenges in Information
Science (RCIS). 2013.
[13] Dabbagh, M. and S.P. Lee, An approach for
integrating the prioritization of functional and
nonfunctional requirements. The Scientific World
Journal, 2014.
[14] Condori-Fernandez, N., M.F. Granda, and T.E.
Vos. Towards a functional requirements
prioritization with early mutation testing. in
Proceedings of the 5th ACM International
Workshop on Requirements Engineering and
Testing. 2018.
[15] Sher, F., et al. Requirements prioritization
techniques and different aspects for prioritization a
systematic literature review protocol. in 2014 8th.
IEEE Malaysian Software Engineering Conference
(MySEC). 2014.
[16] Asghar, A.R., et al. Impact and challenges of
requirements elicitation & prioritization in quality
to agile process: Scrum as a case scenario. in 2017
IEEE International Conference on Communication
Technologies (ComTech). 2017.
[17] Sadiq, M., T. Hassan, and S. Nazneen.
AHP_GORE_PSR: Applying analytic hierarchy
process in goal oriented requirements elicitation
method for the prioritization of software
requirements. in 2017 3rd IEEE International
Conference on Computational Intelligence &
Communication Technology (CICT). 2017.
[18] Asghar, A.R., et al., The impact of analytical
assessment of requirements prioritization models:
an empirical study. 2017.
[19] Shao, F., et al., DRank: A semi-automated
requirements prioritization method based on
preferences and dependencies. Journal of Systems
and Software, 2017. 126: p. 141-156.
[20] Ahmad, K.S., et al. Fuzzy_MoSCoW: A fuzzy
based MoSCoW method for the prioritization of
software requirements. in 2017 IEEE International
Conference on Intelligent Computing,
Instrumentation and Control Technologies
(ICICICT). 2017.
15
Article
Purpose: Research involves the creation and implementation of new ideas by keeping the existing work as a foundation. The literature review done in this paper is to familiarise and to know about the domain of research to integrate the existing ideas with the new ones. Methodology: The literature that is required for this study is chosen from multiple secondary sources such as journals, conference proceedings, and web resources. All the pieces of literature are carefully studied and summarised. This is further used to arrive at Research agendas and Research gaps. Findings/Result: It has been observed and understood that Natural Language Processing (NLP) is a field involving analysis and processing of textual contents. It also requires Machine Learning Algorithms to support the processing. This combination has already been used in various domains, the important one being the health sector. EMR data is huge and NLP can successfully process and prioritize them in different dimensions. In that direction, the same concept and technology can be applied to Software Engineering also and Requirements can be prioritized. Originality: This literature review study is carried out using secondary data which is collected through various online sources. The information thus gathered will be used in the future to build upon existing theory and framework or build a new methodology. It is also seen that any conclusion or decision is not biased or unidirectional. A sincere effort is made to identify a research topic to carry out the research. Paper Type: Literature Review.
Article
Non‐functional requirements (NFRs) play a significant role in the software development process. However, the classical requirement prioritization methods for incremental software development, typically, consider the attributes of functional features only, often neglecting the non‐functional constraints. This might lead to catastrophic defects in the system design, as the conflicts among the NFRs are ignored. In this paper, a novel prioritization approach for functional requirements (FRs) is introduced within the incremental software development process. The proposed approach considers the conflicts among NFRs, in the prioritization process, to minimize the incon sistencies of software development. The devised NFR‐aware prioritization algorithm can be tuned according to the weights that the analyst assigns to NFR conflicts and FR‐NFR dependencies. We have assessed our prioritization approach using available requirements data sets and have compared the results in different scenarios.
Conference Paper
Full-text available
Abstract — Background: Requirement prioritization plays key role in software development process. It is essential to prioritize the requirements for making the correct decision for either a single or multiple release of a product. In this paper we performed a systematic analysis on some of the significant factors like importance of requirements, risks, cost and time in context of requirement prioritization. Objective: With benefits these prioritization methods also have some limitations and shortcoming that are brought up in this paper. Stakeholders, managers, developers or their representatives make decisions for prioritization of requirements. Many techniques are analyzed how to manage these prioritizations considering general goals and limitations. Method: For the identification and analyzing of research articles published during 2009-2017, Systematic Literature Review based method is used in this paper. Results: In recent researches 40 different requirement prioritizations techniques has been used. This SLR also shows the major research gaps regarding techniques and tools for software requirements prioritization. Conclusion: This research shows the major prioritization techniques and tools for requirements elicitation. Tools & techniques identified in this study will assist future researchers to expend their views in the context. Moreover, it will help requirement engineers and practitioners to choose requirement prioritization techniques and tools according to their needs. Keywords— classification, Requirements Engineering, Software Requirements prioritization tools, Software Requirements prioritization technique
Preprint
Full-text available
Researchers have proposed a number of prioritization techniques to help decision makers select an optimal combination of (non-) functional requirements to implement. However, most of them are defined based on an ordinal or nominal scale, which are not reliable because they are limited to simple operations of ranked or ordered requirements. We argue that the importance of certain requirements could be determined by their criticality level, which can be assessed using a ratio scale. The main contribution of the paper is the new strategy proposed for prioritizing functional requirements, using early mutation testing and dependency analysis.
Conference Paper
Requirements prioritization (RP) is considered as an important part of software requirements engineering in which requirements are ranked to develop high-quality software. Success of quality software depends on the selection of well-prioritized requirements. Different techniques are proposed and used to prioritize the software requirements. Requirements are assigned weights or ranked according to their importance and are placed in a priority list for implementation in successive releases. These techniques depend on many aspects that need to be addressed while prioritizing requirements. Requirements prioritization aspects are categorized into three major groups' technical aspects, business aspects and client aspects. Most of the existing techniques are unable to support these aspects, and it affects the quality of decision-making in the requirements prioritization process. Hence, there is a need to explore the different techniques and their support for different aspects. A comparison of the existing techniques is performed. The requirements prioritization aspects are selected to determine the current trends in the software requirements prioritization process. The issue of scalability and the business/client related aspects are the key focal points of this research paper. This paper describes the review protocol, as per guidelines of the Barbara Kitchenham, in order to conduct a systematic literature review.