Improve Software Quality Research Articles

Requirement Engineering Challenges for Social Sector Software Development: Insights from Multiple Case Studies

Diversity is a great challenge for software engineers in the social sector context. The objective of this paper is to contribute to the identification of the RE processes and associated challenges in releasing the software in the social sector markets for which an exploratory case study is conducted. The outcome of the case study indicates that the diversity limits the ability to involve the representative samples of user populations using the same set of RE tools and techniques as one size fits all solution for all segments. The diverse user base must be partitioned into different segments, with each segment triggered using a suitable set of RE techniques i.e., traditional and crowd-based RE. The diverse perspectives learned as a result of the interaction with each segment, must be merged together into a single perspective about the software meant to be used in the social sector. There is a need for a new RE process specially designed for handling the complexities of the social sector, which this paper terms as Social Sector Requirement Engineering (SSRE). There is an increased need for collaboration between government social sector institutions and software engineers to get access to diverse customers to improve software quality.

Development of an Ontology-based Approach for Knowledge Management in Software Testing

Software development organizations are seeking to add quality to their products. Testing processes are strategic elements to manage projects and product quality. However, advances in technology and the emergence of increasingly critical applications make testing a complex task and large volumes of information are generated. In fact, software testing is a knowledge intensive process. Because of this, these organizations have shown a growing interest in Knowledge Management (KM) programs, which in turn support the improvement of testing procedures. KM emerges as a means to manage testing knowledge, and, consequently, to improve software quality. However, there are only a few KM solutions supporting software testing. This paper reports experiences from the development of an approach, called Ontology-based Testing Knowledge Management (OntoT-KM), that aims to assist in launching KM initiatives in the software testing domain with the support of Knowledge Management Systems (KMSs). OntoT-KM provides a process guiding how to start applying KM in software testing. OntoT-KM is based on the findings of a systematic mapping on KM in software testing and the results of a survey with testing practitioners. Moreover, OntoT-KM considers the conceptualization established by a Reference Ontology on Software Testing (ROoST). As a proof of concept, OntoT-KM was applied to develop a KMS called Testing KM Portal (TKMP), which was evaluated in terms of usefulness, usability, and functional correctness. Results show that the developed KMS from OntoT-KM is a potential system for managing knowledge in software testing, so, the approach can guide KM initiatives in software testing.

Software Quality Model in the Presence of Culture Quality Factors

Researchers have often attempted to raise the success rate of software systems over the past century. Improve software quality models and other software elements to make it more customer satisfaction and achieve customer permanence. Several quality models and variables have been proposed to decrease software system failure and complexity. Also, several software quality models were proposed to assess the general and particular types of software products. These models have been proposed to determine the general or particular scopes of software products. The proposed models evaluate based on comparisons between the well-known models to customize the closed model. These comparisons are the leakage of criteria based on distinct views and knowledge of cultural and social requirements. A new factors proposed by the customize software quality models. The proposed cultural model has eight criterions namely: Language, Religion, social habits, publishing, custom, Ethics, and Law. We classified the new criterions factors into three main groups. The outcome of the proposed cultural model demonstrates that the eight criterions factors must be deemed to decrease the satisfactions of software failure and permanence variables. Finally we proposed a cultural language metric for measuring the satisfactions of software failure and permanence variables.

Meta‐heuristic optimization algorithm for predicting software defects

AbstractSoftware engineering companies strive to improve software quality by predicting software defects‐prone modules. Although various data mining methods have been developed, unstable accuracy rates are still critical issues owing to the imbalanced nature and high dimensionality of software defect datasets. To deal with this issue, we propose a spotted hyena, a novel meta‐heuristic optimization algorithm for predicting software defects. Support and confidence in classification rules are the basis of a multi‐objective fitness function that assists the spotted hyena algorithm in serving as a classifier by finding the fittest classification or standard rules among individuals. Experiments were conducted on four NASA software datasets, JM1, KC2, KC1, and PC3. The spotted hyena classifier provides an accuracy of 85.2, 84, 89.6, and 81.8%, respectively, for these datasets. These accuracy rates are better than those achieved using other popular data mining techniques. We also discuss other classification measures in connection with the experimental results, such as precision, recall, and confusion matrices, in connection with the experimental results. Moreover, the Gaussian mixture model is used to study the uncertainty quantification of the proposed classifier. The study proved the feasible performance of the spotted hyena classifier in four different case studies.

A Multi-Objective Approach for Software Quality Improvement

Software industry always demands high-quality software that must be reliable, robust, flexible, reusable, effective, and extendable. To improve software quality refactoring is an efficient and frequently opted technique. Most of the refactoring work has been done on the source code level less work has been done on model-based. Model base refactoring is more difficult to estimate. In this research paper, the multi-objective evolutionary algorithm based on decomposition (MOEA/D) is applied to find how software quality is affected by refactoring technique. It impacts the software quality in both positive as well as negative way.

Detecting vulnerability in source code using CNN and LSTM network

Automated vulnerability detection has become a research hot spot because it is beneficial for improving software quality and security. The code metric (CM) is one class of important representations of vulnerability in source code. The implicit relationships among different metric attributes have not been sufficiently considered in traditional vulnerability detection based on CMs. In this paper, in view of the local perception capability of convolutional neural network (CNN) and the time-series prediction capability of long short-term memory (LSTM), we propose VulExplore, a compound neural network model for vulnerability detection that consists of a CNN for feature extraction and an LSTM network for deep representation. Moreover, to further indicate the vulnerability features in the source code, we reconstruct a CM dataset that includes two additional important attributes: maintainability index and average number of vulnerabilities committed per line. Our proposed numerical method can obtain both false-negative rate (FNR) and false-positive rate (FPR) under 20% and, meanwhile, achieve recall and precision over 80%, respectively.

Guest Editorial: A Retrospective of Special Sections on Software Testing and Program Analysis

Software plays an integral part in our lives today because of its near-ubiquitous influence on our increasingly technological society. Taking appropriate steps to improve software quality is of paramount importance. This has fueled a surge of techniques in program testing and analysis. Unfortunately, these techniques still suffer from immaturity and impracticality, which have hindered truthful benefits to the software industry. The Special Sections on Software Testing and Program Analysis solicited original work that would provide novel techniques and/or comprehensive empirical validation applicable to real-world software. We successfully attracted more than 70 submissions covering diverse hot topics. After rigorous evaluations by hard-working reviewers, possibly with recommendations for major and minor revisions, we have published 26 articles in five issues of the IEEE Transactions on Reliability in June, September, and December 2018, January 2019, and June 2021. The articles represent a comprehensive cross section of testing and analysis techniques, as well as a wide variety of applications to practical projects. The present retrospective provides readers with interesting details about our great success and a small challenge.

Developing bug severity prediction models using word2vec

Bug tracking systems use repositories to keep track of the bugs to improve software quality. A manual analysis of each bug and classifying it according to its severity is an unmanageable job. Therefore, it is imperative to correctly classify the severity of a bug, which otherwise might be misclassified by a laymen user. Text mining techniques have the potential to analyze such massive databases of the textual description of bug reports to classify bug severity levels adequately. Word embedding is a state-of-art text mining technique that captures the semantics of the text and group the words according to their relevance in a document. Words are embedded into real-valued vectors through word-embedding models. Word2vec is a word embedding model, proven to be effective in representing word meanings. However, the configuration of hyperparameters and feature selection affects the performance of word2vec. Tuning hyperparameter is a time-consuming process, and it is crucial to identify the correct set of parameters. The paper outlines the effectiveness of word2vec technique on the efficiency of classifiers to predict a bug severity from a bug report and examines the impact of different averaging methods, including the configuration of word embedding parameters on the classifiers’ efficiency. Results show that the bigger window size enhances the performance of classifiers; however, the influence of the minimum word count parameter was found to be mixed and depends on the selected data sets. Further, out of the classifiers used, Random Forest and Xgboost could classify the severity level for classes with few records or a rare occurrence of words specific to each class. Otherwise, Support Vector Machine and Naive Bayes classifiers performed better and worst, respectively.

A Survey on Software Defect Prediction Using Deep Learning

Defect prediction is one of the key challenges in software development and programming language research for improving software quality and reliability. The problem in this area is to properly identify the defective source code with high accuracy. Developing a fault prediction model is a challenging problem, and many approaches have been proposed throughout history. The recent breakthrough in machine learning technologies, especially the development of deep learning techniques, has led to many problems being solved by these methods. Our survey focuses on the deep learning techniques for defect prediction. We analyse the recent works on the topic, study the methods for automatic learning of the semantic and structural features from the code, discuss the open problems and present the recent trends in the field.

A user task design notation for improved software design.

System design is recognized as one of the most critical components of a software system that bridges system requirements and coding. System design also has a significant impact on testing and maintenance activities, and on further improvements during the lifespan of the software system. Software design should reflect all necessary components of the requirements in a clear and understandable manner by all stakeholders of the software system. To distinguish system elements, separation of concerns in software design is suggested. In this respect, identification of the user tasks, i.e., the tasks that need to be performed by the user, is not currently reflected explicitly in system design documents. Our main assumption in this study is that software quality can be improved significantly by clearly identifying the user tasks from those that need to be performed by the computer system itself. Additionally, what we propose has the potential to better reflect the user requirements and main objectives of the system on the software design and thereby to improve software quality. The main aim of this study is to introduce a novel notation for software developers in the frame of UML Activity Diagram (UML-AD) that enables designers to identify the user tasks and define them separately from the system tasks. For this purpose, an extension of UML-AD, named UML-ADE (UML-Activity Diagram Extended) was proposed. Afterwards, it was implemented in a serious game case for which the specification of user tasks is extremely important. Finally, its effectiveness was analyzed and compared to UML-AD experimentally with 72 participants. The defect detection performance of the participants on both diagrams with two real-life serious game scenarios was evaluated. Results show a higher level of understandability for those using UML-ADE, which in turn may indicate a better design and higher software quality. The results encourage researchers to develop specific design representations dedicated to task design to improve system quality and to conduct further evaluations of the impact of these design on each of the above mentioned potential benefits for the software systems.

A Review on Machine-learning Based Code Smell Detection Techniques in Object-oriented Software System(s)

Background: Code smells are symptoms that something may be wrong in software systems that can cause complications in maintaining software quality. In literature, there exist many code smells and their identification is far from trivial. Thus, several techniques have also been proposed to automate code smell detection in order to improve software quality. Objective: This paper presents an up-to-date review of simple and hybrid machine learning-based code smell detection techniques and tools. Methods: We collected all the relevant research published in this field till 2020. We extracted the data from those articles and classified them into two major categories. In addition, we compared the selected studies based on several aspects like code smells, machine learning techniques, datasets, programming languages used by datasets, dataset size, evaluation approach, and statistical testing. Results: A majority of empirical studies have proposed machine-learning based code smell detection tools. Support vector machine and decision tree algorithms are frequently used by the researchers. Along with this, a major proportion of research is conducted on Open Source Softwares (OSS) such as Xerces, Gantt Project and ArgoUml. Furthermore, researchers pay more attention to Feature Envy and Long Method code smells. Conclusion: We identified several areas of open research like the need for code smell detection techniques using hybrid approaches, the need for employing valid industrial datasets, etc.

Human microservices: A framework for turning humans into service providers

SummaryDuring the last decade, the mobile application market has grown steadily thanks to the massive use of smartphones and the emergence of cloud computing for offloading computation tasks and improving the quality of experience. With the more recent deployment of Internet of Things (IoT) devices, this cloud‐based architectural design and the corresponding communication flow has been maintained. Nevertheless, the increasing amount of information exchanged, the stringent requirements of many IoT applications, and the need for these applications to adapt their behavior in real time to the user's context set these architectural assumptions a challenge. Paradigms such as mobile, mist, and edge computing have recently been proposed to exploit the computational and storage capabilities of current smartphones and IoT devices in order to onload some tasks onto them, reducing the overhead on both the cloud and the network. Currently, the application of these paradigms requires much attention from skilled developers to create ad hoc systems, as there lack standards and tools facilitating their use. This communication introduces Human Microservices as a framework facilitating the deployment of APIs on companion devices in order to provide personal and updated information that can be consumed by other entities. The framework improves the integration of humans in the IoT loop and facilitates the deployment of computation units in devices closer to end users, enhancing system response time by reducing the stress on cloud and network infrastructure. The proposed framework is based on existing standards in order to improve software quality and shorten the learning curve.

Exploratory study of the impact of project domain and size category on the detection of the God class design smell

Design smell detection has proven to be an efficient strategy to improve software quality and consequently decrease maintainability expenses. This work explores the influence of the information about project context expressed as project domain and size category information, on the automatic detection of the god class design smell by machine learning techniques. A set of experiments using eight classifiers to detect god classes was conducted on a dataset containing 12, 587 classes from 24 Java projects. The results show that classifiers change their behavior when they are used on datasets that differ in these kinds of project information. The results show that god class design smell detection can be improved by feeding machine learning classifiers with this project context information.

Prediction of software vulnerability based deep symbiotic genetic algorithms: Phenotyping of dominant-features

The detection of software vulnerabilities is considered a vital problem in the software security area for a long time. Nowadays, it is challenging to manage software security due to its increased complexity and diversity. So, vulnerability detection applications play a significant part in software development and maintenance. The ability of the forecasting techniques in vulnerability detection is still weak. Thus, one of the efficient defining features methods that have been used to determine the software vulnerabilities is the metaheuristic optimization methods. This paper proposes a novel software vulnerability prediction model based on using a deep learning method and SYMbiotic Genetic algorithm. We are first to apply Diploid Genetic algorithms with deep learning networks on software vulnerability prediction to the best of our knowledge. In this proposed method, a deep SYMbiotic-based genetic algorithm model (DNN-SYMbiotic GAs) is used by learning the phenotyping of dominant-features for software vulnerability prediction problems. The proposed method aimed at increasing the detection abilities of vulnerability patterns with vulnerable components in the software. Comprehensive experiments are conducted on several benchmark datasets; these datasets are taken from Drupal, Moodle, and PHPMyAdmin projects. The obtained results revealed that the proposed method (DNN-SYMbiotic GAs) enhanced vulnerability prediction, which reflects improving software quality prediction.

A family of experiments on test-driven development

Context:Test-driven development (TDD) is an agile software development approach that has been widely claimed to improve software quality. However, the extent to which TDD improves quality appears to be largely dependent upon the characteristics of the study in which it is evaluated (e.g., the research method, participant type, programming environment, etc.). The particularities of each study make the aggregation of results untenable.Objectives:The goal of this paper is to: increase the accuracy and generalizability of the results achieved in isolated experiments on TDD, provide joint conclusions on the performance of TDD across different industrial and academic settings, and assess the extent to which the characteristics of the experiments affect the quality-related performance of TDD.Method:We conduct a family of 12 experiments on TDD in academia and industry. We aggregate their results by means of meta-analysis. We perform exploratory analyses to identify variables impacting the quality-related performance of TDD.Results:TDD novices achieve a slightly higher code quality with iterative test-last development (i.e., ITL, the reverse approach of TDD) than with TDD. The task being developed largely determines quality. The programming environment, the order in which TDD and ITL are applied, or the learning effects from one development approach to another do not appear to affect quality. The quality-related performance of professionals using TDD drops more than for students. We hypothesize that this may be due to their being more resistant to change and potentially less motivated than students.Conclusion:Previous studies seem to provide conflicting results on TDD performance (i.e., positive vs. negative, respectively). We hypothesize that these conflicting results may be due to different study durations, experiment participants being unfamiliar with the TDD process, or case studies comparing the performance achieved by TDD vs. the control approach (e.g., the waterfall model), each applied to develop a different system. Further experiments with TDD experts are needed to validate these hypotheses.

Uncovering the Benefits and Challenges of Continuous Integration Practices

In 2006, Fowler and Foemmel defined ten core Continuous Integration (CI) practices that could increase the speed of software development feedback cycles and improve software quality. Since then, these practices have been widely adopted by industry and subsequent research has shown they improve software quality. However, there is poor understanding of how organizations implement these practices, of the benefits developers perceive they bring, and of the challenges developers and organizations experience in implementing them. In this paper, we discuss a multiple-case study of three small- to medium-sized companies using the recommended suite of ten CI practices. Using interviews and activity log mining, we learned that these practices are broadly implemented but how they are implemented varies depending on their perceived benefits, the context of the project, and the CI tools used by the organization. We also discovered that CI practices can create new constraints on the software process that hurt feedback cycle time. For researchers, we show that how CI is implemented varies, and thus studying CI (for example, using data mining) requires understanding these differences as important context for research studies. For practitioners, our findings reveal in-depth insights on the possible benefits and challenges from using the ten practices, and how project context matters.

DEJIT: A Differential Evolution Algorithm for Effort-Aware Just-in-Time Software Defect Prediction

Software defect prediction is an effective approach to save testing resources and improve software quality, which is widely studied in the field of software engineering. The effort-aware just-in-time software defect prediction (JIT-SDP) aims to identify defective software changes in limited software testing resources. Although many methods have been proposed to solve the JIT-SDP, the effort-aware prediction performance of the existing models still needs to be further improved. To this end, we propose a differential evolution (DE) based supervised method DEJIT to build JIT-SDP models. Specifically, first we propose a metric called density-percentile-average (DPA), which is used as optimization objective on the training set. Then, we use logistic regression (LR) to build a prediction model. To make the LR obtain the maximum DPA on the training set, we use the DE algorithm to determine the coefficients of the LR. The experiment uses defect data sets from six open source projects. We compare the proposed method with state-of-the-art four supervised models and four unsupervised models in cross-validation, cross-project-validation and timewise-cross-validation scenarios. The empirical results demonstrate that the DEJIT method can significantly improve the effort-aware prediction performance in the three evaluation scenarios. Therefore, the DEJIT method is promising for the effort-aware JIT-SDP.

Locating Core Modules through the Association between Software Source Structure and Execution

To improve software quality, the source code that composes software has to be improved, and improving the important code that largely affects the software quality should be a cost-effective method. Static analysis defines important codes as those that occupy important positions in the source network, while dynamic analysis defines important codes as those with high execution frequency. However, neither method analyzes the association between network structure and execution frequency, and both have their disadvantages. Thus, this study analyzed the association between source network structure and execution frequency to solve their disadvantages. The source function of Notepad++ was analyzed, and the function ranking was derived using the association between network structure and execution frequency. For verification, the Spearman correlation between the newly derived function ranking and the function ranking of the network and execution frequency obtained with the conventional method was measured. By measuring the Spearman correlation, the newly derived function ranking had strong correlations with execution frequency and included the network structure’s characteristics. Moreover, similar to the Pareto principle, the analysis showed that 20% of Notepad++’s functions could be categorized as important functions, largely affecting the software’s quality.

Efficient Feature Selection for Static Analysis Vulnerability Prediction.

Common software vulnerabilities can result in severe security breaches, financial losses, and reputation deterioration and require research effort to improve software security. The acceleration of the software production cycle, limited testing resources, and the lack of security expertise among programmers require the identification of efficient software vulnerability predictors to highlight the system components on which testing should be focused. Although static code analyzers are often used to improve software quality together with machine learning and data mining for software vulnerability prediction, the work regarding the selection and evaluation of different types of relevant vulnerability features is still limited. Thus, in this paper, we examine features generated by SonarQube and CCCC tools, to identify those that can be used for software vulnerability prediction. We investigate the suitability of thirty-three different features to train thirteen distinct machine learning algorithms to design vulnerability predictors and identify the most relevant features that should be used for training. Our evaluation is based on a comprehensive feature selection process based on the correlation analysis of the features, together with four well-known feature selection techniques. Our experiments, using a large publicly available dataset, facilitate the evaluation and result in the identification of small, but efficient sets of features for software vulnerability prediction.

Large Scale Evaluation of Natural Language Processing Based Test-to-Code Traceability Approaches

Traceability information can be crucial for software maintenance, testing, automatic program repair, and various other software engineering tasks. Customarily, a vast amount of test code is created for systems to maintain and improve software quality. Today's test systems may contain tens of thousands of tests. Finding the parts of code tested by each test case is usually a difficult and time-consuming task without the help of the authors of the tests or at least clear naming conventions. Recent test-to-code traceability research has employed various approaches but textual methods as standalone techniques were investigated only marginally. The naming convention approach is a well-regarded method among developers. Besides their often only voluntary use, however, one of its main weaknesses is that it can only identify one-to-one links. With the use of more versatile text-based methods, candidates could be ranked by similarity, thus producing a number of possible connections. Textual methods also have their disadvantages, even machine learning techniques can only provide semantically connected links from the text itself, these can be refined with the incorporation of structural information. In this paper, we investigate the applicability of three text-based methods both as a standalone traceability link recovery technique and regarding their combination possibilities with each other and with naming conventions. The paper presents an extensive evaluation of these techniques using several source code representations and meta-parameter settings on eight real, medium-sized software systems with a combined size of over 1.25 million lines of code. Our results suggest that with suitable settings, text-based approaches can be used for test-to-code traceability purposes, even where naming conventions were not followed.