Software Non-functional Requirements Research Articles

Performance analysis of Machine Learning Algorithms to classify Software Requirements

Building a software system requires a clear understanding of its purpose and its operational characteristics. Functional requirements establish the system's purpose, while non-functional requirements define its operational performance aspects. It is essential to identify and classify requirements accurately to develop reliable software. In this research paper, we aim to classify functional and non-functional software requirements using different Machine Learning algorithms and techniques. We utilized four popular classification models, including Logistic Regression, Support Vector Machines, Decision Tree, and Random Forest Multi-layer Perceptron Neural Network to classify the requirements. To enhance the accuracy of the classification, we also applied a technique based on cosine similarity to verify if the custom string provided as input is related to software requirements. The addition of cosine similarity improved the accuracy of classification and reduced the misclassification of non-requirements.

Class Balancing Methods Comparison for Software Requirements Classification on Support Vector Machines

Cost, time, and development effort can increase due to errors in analyzing functional and non-functional software requirements. To minimize these errors, previous research has tried to classify software requirements, especially non-functional requirements, on the PROMISE dataset using the Bag of Words (BoW) feature extraction and the Support Vector Machine (SVM) classification algorithm. On the other hand, the unbalanced distribution of class labels tends to decrease the evaluation result. Moreover, most software requirements are usually functional requirements. Therefore, there is a tendency for classifier models to classify test data as functional requirements. Previous research has performed class balancing on a dataset to handle unbalanced data. The study can achieve better classification evaluation results. Based on the previous research, this study proposes to combine the class balancing method and the SVM algorithm. K-fold cross-validation is used to optimize the training and test data to be more consistent in developing the SVM model. Tests were carried out on the value of K in k-fold, i.e., 5, 10, and 15. Results are measured by accuracy, f1-score, precision, and recall. The Public Requirements (PURE) dataset has been used in this research. Results show that SVM with class balancing can classify software requirements more accurately than SVM without class balancing. Random Over Sampling is the class balancing method with the highest evaluation score for classifying software requirements on SVM. The results showed an improvement in the average value of accuracy, f1 score, precision, and recall in SVM by 22.07%, 19.67%, 17.73%, and 19.67%, respectively.

Moderator factors of software security and performance verification

Context:Security and performance are critical software non-functional requirements. Therefore, verification activities should be included in the development process to identify related defects, avoiding failures after deployment. However, there is a lack of understanding on factors moderating the security and performance verification, which jeopardizes organizations to improve their verification activities to assure the releasing of software fulfilling these requirements. Objective:To identify moderator factors influencing security and performance verification and actions to promote them. Methods:Case study to identify security and performance moderators factors. Rapid Literature Reviews with Snowballing to strengthen moderator factors confidence. Practitioners Survey to classify the moderator factors relevance. Results:Identification of eight security and performance moderator factors regarding organizational awareness, cross-functional team, suitable requirements, support tools, verification environment, verification methodology, verification planning, and reuse practices. Rapid Reviews confirmed the moderator factors and revealed actions to promote each. A survey with 37 practitioners allowed us to classify the moderator factors and their actions regarding their relevancy. Conclusions:The moderator factors can be considered key points to software development organizations implement/improve security and performance verification activities in regular software systems. Further investigation is necessary to support the understanding of these moderator factors when building modern software systems.

THE ROLE OF SOFTWARE TESTING FOR TEAM DEVELOPMENT

The peculiarities of software product testing processes while working in the Scrum-team were studied. The types of testing characteristic of the flexible testing technique are singled out, that make it possible to make the testing process constantly integrated into teamwork, both at the stage of requirements formation and design, and at the stage of coding and generation of test sets. This is possible by making the tester's recommendations in the process of creating user stories, planning the release of the software version in terms of testing and defects, planning a sprint based on user stories and defects, performing a sprint with continuous testing, regression testing after sprint ends and reporting of results of testing. The article highlights the stages of the flexible testing process in the Scrum team. It is proposed to automate the process of flexible testing for a training team project in the Visual Studio software environment based on Team Foundation Server. Author demonstrates an example of automation of the process of flexible testing by dividing it into four quadrants to comply with the principles of working on a flexible methodology of software development. In the first quadrant there is a study of the quality of the internal code of the software product, the modular testing. To implement modular testing in Visual Studio, a new solution is created in order to generate a class for testing, where the conditions for testing are prescribed in the body of the class. The second quadrant implements the principles of system testing. At this stage the features of creating such a test artifact as test cases are demonstrated. That provides for the fulfillment of certain conditions to verify the functionality of the developing software product; linking between created test cases to user stories presented as team project tasks Product Backlog. The study demonstrates an example of manual testing using a special tool Microsoft Test Manager, which allows you to create plans, add and update test cases, perform manual tests. In the third quadrant, it was performed a trial test in Microsoft Test Manager and it was created another test artifact - error reports. The fourth quadrant automatically tests non-functional software requirements.

An Empirical Investigation on the Effect of Code Smells on Resource Usage of Android Mobile Applications

Code smells refer to suboptimal coding practices which impact software quality and software non-functional requirements such as performance, maintainability, and resource usage. Although desktop application code smells have been extensively studied in the literature, mobile applications are relatively new in nature, and the effect of code smells is only recently being studied on mobile devices. This paper investigates the effect of code refactoring on enhancing both CPU usage and Memory usage. It presents a study of three code smells: HashMap Usage, Member Ignoring Method and Slow Loop, and eight open-source applications were selected from Github for testing purposes. The three aforementioned code smells were refactored individually and cumulatively to study their effects on a mobile phone’s resource usage, with CPU usage and memory usage as the metrics of choice. The resource usage of five different versions of eight different mobile applications were measured to find the optimal refactoring strategy. The results obtained suggest that refactoring HashMap Usage and Member Ignoring Methods yielded significantly an average improvement in CPU usage of 12.7% and 13.7% respectively, while the refactoring of all three code smells yielded an improvement of up to 7.1% in memory usage. This research shows that certain refactoring methods have significant impacts on improving both the CPU usage and Memory usage. These statistically significant results can be used as the basis of guidelines to assist in writing codes which utilize smartphones’ resources more efficiently and enhance their quality.

CAPTURING SOFTWARE REQUIREMENTS FOR BUSINESS PROCESS MODEL ANALYSIS AND IMPROVEMENT

This paper considers the problem of software requirements capturing for business process model evaluation and recommendations generation to suggest how detected modeling errors may be eliminated in order to improve business process model correctness. Existing software tools for business process model analysis are based on metrics and thresholds that allow assume presence of errors in business process models, but they are not capable to recommend structural changes required to eliminate detected modeling errors. Therefore, business process model analysis and improvement tasks become relevant, since early detection and elimination of possible errors presented in business process models may allow organizations avoid extra costs that may occur on any of the steps of business process lifecycle. Since business process models are shared organizational assets, it is also necessary to consider the capabilities of collaborative and concurrent usage of business process models by multiple stakeholders. Hence, the workflow of business process model analysis and improvement was analyzed and its key steps, which describe expected user and software behavior, were formalized using the IDEF0 functional model. Functional software requirements were captured in the form of user stories according to modern agile practices of software development. These user stories are based on features and drawbacks of existing software tools for business process model analysis. Captured user stories were formalized using the use case modeling. Non-functional software requirements were also captured; they include maintainability, readability, testability, understandability, integrability, and complexity requirements. Captured requirements can be used to design and develop business process model analysis and improvement software capable to provide recommendations to eliminate detected modeling errors.

Application of high-level methods of compromise optimization for control of autonomous robotized open pit mining

In most software engineering approaches, software design begins with defining functional requirements, which is well suited to web-based software development projects. When designing high-critical large-scale software intended for industrial use, accounting for non-functional software requirements is also required. The main idea of the proposed document-oriented approach is to design a stable architectural solution as early as possible, taking into account the nonfunctional characteristics of the software: reliability, security, maintainability and performance (quality attributes). At the same time, the key issue is the coordination of functional requirements, taking into account technical limitations and business requirements achieved during the steady interaction of customer and developer teams. To increase the flexibility of the designed solutions and prevent crisis situations when developing highly critical large-scale software, it is proposed to use the approach integrating the architecture-centric design method (ACDM), the architecture-tradeoff analysis method (ATAM) with a matrix enterprise architecture matrix (EAM). This allows getting a result that is adequate to the required level of responsibility and reliability. Consideration of quality attributes within the framework of the method of compromise analysis makes it possible to select and make certain decisions in software design taking into account the scale of the software and its scope. The main attributes of product quality are highlighted (ISO 25010 standard), critical scenarios are defined for each of them (templates and use cases). The use of these templates for detailed software design with the necessary parameters of functional requirements, business conditions and technological limitations reduces the risk of developing unpredictable and uncertain system behavior. Based on the proposed approach, an architectural solution is presented for highly critical, responsible, large-scale software for managing autonomous robotic open-pit mining of minerals. Critical attributes for creating the specified software were identified and ranked, and the architecture of the solution according to the SWEBOK software development standard was described. Further, taking into account the nature, scale and scope of the software solution, recommendations are given on high-level architectural templates for the system design, including layers, pipelines and microservices. The proposed architecture-oriented development method is suitable for industrial-level software in various subject areas.

Proposed T-Model to cover 4S quality metrics based on empirical study of root cause of software failures

<span>There are various root causes of software failures. Few years ago, software used to fail mainly due to functionality related bugs. That used to happen due to requirement misunderstanding, code issues and lack of functional testing. A lot of work has been done in past on this and software engineering has matured over time, due to which software’s hardly fail due to functionality related bugs. To understand the most recent failures, we had to understand the recent software development methodologies and technologies. In this paper we have discussed background of technologies and testing progression over time. A survey of more than 50 senior IT professionals was done to understand root cause of their software project failures. It was found that most of the softwares fail due to lack of testing of non-functional parameters these days. A lot of research was also done to find most recent and most severe software failures. Our study reveals that main reason of software failures these days is lack of testing of non-functional requirements. Security and Performance parameters mainly constitute non-functional requirements of software. It has become more challenging these days due to lots of development in the field of new technologies like Internet of things (IoT), Cloud of things (CoT), Artificial Intelligence, Machine learning, robotics and excessive use of mobile and technology in everything by masses. Finally, we proposed a software development model called as T-model to ensure breadth and depth of software is considered while designing and testing of software. </span>

Tradeoff Analysis for Conflicting Software Non-Functional Requirements

The need for particular software non-functional requirements (NFRs) leads a project team to use specific design strategies to fulfill these NFRs. However, some of the strategies may cause deficiencies in other software NFRs. These strategies are called conflicting strategies. Making the tradeoff decision of these conflicting strategies for NFRs is crucial. Therefore, a conflicting NFRs tradeoff framework (CNTF) and the corresponding method are proposed. Firstly, the NFRs are obtained from stakeholders. Fuzzy set theory is used to express stakeholder assessments on the importance of each NFR. The assessment results are ranked using a fuzzy ranking method. Then, adapting from production theory in microeconomics, the degree of satisfaction by which NFRs are affected by conflicting strategies are plotted as tradeoff curves. Borrowing the concept from the linear programming in management science, a tradeoff method is presented to help software project teams make the best tradeoff decision for conflicting NFRs. Finally, feasibility and limitations of the CNTF are elaborated in a case study.

COST AND COMPLEXITY RESEARCH OF SOFTWARE DEVELOPMENT TO SOLVE THE PROBLEM OF INVENTORY MANAGEMENT

The article describes the process of estimating the cost and complexity of software development for the task of inventory management of a commercial enterprise to improve the decision-making process at the stage of formation of requirements for similar software products. There are different approaches to inventory management of a commercial enterprise. The algorithms implemented in the system are based on the constraint theory tool – dynamic inventory buffer management. Inventory management according to the theory of restrictions allows to provide a high level of availability of goods with minimal inventory in the system. After analyzing the subject area of inventory management and the methodology of dynamic inventory buffer management, a list of functional and non-functional software requirements was formed, and a data model was designed. The information obtained was used to compile a list of logical files and transactions specific to a particular requirement. From the resulting list of files and transactions, it is determined which elementary data, elementary records and links to files they consist of. The information obtained was used to estimate the size of the software at non-aligned functional points. To take into account the impact of non-functional requirements on the complexity of software development, the VAF alignment factor was calculated, for which it is necessary to give a qualitative assessment of the impact of system-wide requirements on the complexity of the software. The estimation of the complexity of the development was obtained using the COCOMO II methodology, namely, using seven multipliers of the complexity for the case of the initial assessment at the stage of approval of requirements. The calculations were obtained for teams with different professional level and equipment, in the conditions of a significant tightening of the development process, a high level of certainty of risks, without a rigid schedule of work. The cost of development was calculated for several common programming languages: J2EE, C#, C++.

Automated Quantitative Verification for Service-Based System Design: A Visualization Transform Tool Perspective

Service-based systems are a new software mode for distributed business processes integration. It is difficult for traditional testing methods to verify the functional and nonfunctional requirements of software. To address this problem, this paper proposes a visual verification platform to quantitatively compute the reliability and cost for evaluating the performance of service-based systems in the design phase. First, an extended automata model namely Probabilistic Reward Labeled Transition System (PRLTS) is proposed to formalize both the functional behaviors and nonfunctional features. Then, the formal language of probabilistic model checker PRISM is introduced to show the grammar of the target verification codes that we want to transform. Second, XML description tags of Business Process Execution Language (BPEL) is parsed to generate the functional behaviors using different kinds of transformation rules, based on which the probability matrix and reward concept are employed to denote the service’s reliability and cost, respectively. Third, the PRLTS model is turned into the input language of PRISM, where the graphic description language DOT of Graphviz is used as an intermediary to display system behaviors in a visual way. The model layout allows the designer to manually adjust the behaviors of the PRLTS model, where verification codes can be dynamically updated according to the changes in modified information. Fourth, to perform quantitative verification, the verification property in the form of the Probabilistic Computation Tree Logic (PCTL) formula can be automatically generated when the requirement model of the service-based system is inputted, during which the threshold value of qualitative property will be initially computed and returned as a recommended value. This allows the user to modify the qualitative property in an interactive way. Furthermore, experimental analysis of the real-world case study demonstrates the feasibility of the proposed method. Thus, our platform provides guidance for quantitative verification and graphical visualization for effectively generating formal models and checking the quantitative properties for service-based systems.

Designing video games for the blind: results of an empirical study

Understanding non-functional software requirements and developing realizable operationalizations of them are critical to the success of any information system. Non-functional requirements dealing with accessibility and usability are especially important considerations when developing information systems for visually impaired stakeholders; however, this is not, yet, an area well understood in information systems development. This work aims to better understand the non-functional software requirements and realizable operationalizations needed to address the accessibility and usability challenges in computer gaming for the visually impaired. Building on previous work, this paper provides the analysis, results, and recommendations stemming from a systematic qualitative analysis of elicited qualitative text using adaptations of the grounded theory method. To do so, the authors developed a PC version of a 1980’s, 2D, Arcade style video game incorporating joystick controls and sound effects and gathered user experience data from six visually impaired users through a closed, pre-game and post-game interviews. The contribution of this work is part of a larger effort to develop systematic requirements engineering approaches, utilizing qualitative methods, to elicit, analyze, and operationalize non-functional software requirements within the information systems development process, to provide equal access to information systems for visually impaired users.

Detecting, classifying, and tracing non-functional software requirements

In this paper, we describe a novel unsupervised approach for detecting, classifying, and tracing non-functional software requirements (NFRs). The proposed approach exploits the textual semantics of...

Using ontologies with UML class-based modeling: The TwoUse approach

UML class-based models and OWL ontologies constitute modeling approaches with different strengths and weaknesses that make them appropriate for specifying distinct aspects of software systems. We propose an integrated use of both modeling approaches in a coherent framework — TwoUse. We present a framework involving different concrete syntaxes for developing integrated models and use a SPARQL-like approach for writing query operations. We illustrate TwoUse's applicability with a case study and conclude that TwoUse achieves enhancements of non-functional software requirements like maintainability, reusability and extensibility.

Software quality, non-functional software requirements and IT-business alignment

`High quality' might seem an obvious requirement for any piece of software, but do the different stakeholder groups involved in its production and use conceptualize this requirement in the same way...