Improve Software Quality Research Articles

Study of Software Quality Improvement through Reliability Metrics Models and Root Cause Analysis Program

Software quality is the most crucial requirement of any organization to survive in the current market scenario. The improvement of quality in software products depends on number of factors such as its architecture, quality metrics, reliability models and root cause analysis for defect handling. This paper focuses on the use of different reliability metrics to improve the reliability in software systems. Paper also emphasizes that removing defects for once is not beneficial for quality improvement, rather using a quality improvement program such as root cause analysis to get to base of defects and decrease the chances of occurrence of same defects again and again. Paper shows that effective root cause analysis program improves the learning process in any organization and helps in development of standards. This article provides an overview of software reliability metrics and root cause analysis program for the improvement of total software quality

Machine Learning to Improve Software Quality

CODE DEFECT AI TOOL IS ABLE TO PREDICT LIKELIHOOD OF BUGS IN SOURCE CODE.

Recommending refactorings via commit message analysis

Abstract Context The purpose of software restructuring, or refactoring, is to improve software quality and developer productivity. Objective Prior studies have relied mainly on static and dynamic analysis of code to detect and recommend refactoring opportunities, such as code smells. Once identified, these smells are fixed by applying refactorings which then improve a set of quality metrics. While this approach has value and has shown promising results, many detected refactoring opportunities may not be related to a developer’s current context and intention. Recent studies have shown that while developers document their refactoring intentions, they may miss relevant refactorings aligned with their rationale. Method In this paper, we first identify refactoring opportunities by analyzing developer commit messages and check the quality improvements in the changed files, then we distill this knowledge into usable context-driven refactoring recommendations to complement static and dynamic analysis of code. Results The evaluation of our approach, based on six open source projects, shows that we outperform prior studies that apply refactorings based on static and dynamic analysis of code alone. Conclusion This study provides compelling evidence of the value of using the information contained in existing commit messages to recommend future refactorings.

Novel Multiperspective Hiring Framework for the Selection of Software Programmer Applicants Based on AHP and Group TOPSIS Techniques

The selection of software programmer applicants based on multiperspective evaluation criteria (grade point average (GPA) and soft skills of the applicants) is needed instead of an interview because an interview does not necessarily lead to hiring the best candidate amongst the applicants. The selection of a suitable software programmer is considered a challenging task owing to the following factors: (1) data variation, (2) multiple evaluation criteria and (3) criterion importance. A general framework for the selection of the best software programmer applicants is not available in the existing literature. The present study aims to propose a novel multiperspective hiring framework based on multicriteria analysis to select the best software programmer amongst several applicants. A decision matrix (DM) is constructed for the selection of the best programmer applicants according to multiple criteria, namely, structured programming, object-oriented programming, data structure, database system and courseware engineering. Each criterion includes two parameters, namely, GPA and soft skills, and these criteria cross over with programmer applicants as alternatives. The standard and expert opinion of the Software Engineering Body of Knowledge is used to distribute the criteria in the DM. The two commonly used techniques of multicriteria decision-making are analytic hierarchy process (AHP) for weighing the criteria and technique for order performance by similarity to ideal solution (TOPSIS) for ranking the alternatives (programmer applicants). The data used in this study include 60 software engineering students who graduated in 2016 from Universiti Pendidikan Sultan Idris. Results show that integrating multilayer analytic hierarchy process (MLAHP) and group TOPSIS are effective for solving applicant selection problems. Group TOPSIS uses different contexts — internal and external aggregation — and indicates similar results. Objective validation is used for the ranking of the results, which are equally divided into four parts. Furthermore, the applicants are systematically ranked. This study benefits application software, system software and computer programming tool companies by providing a method that improves software quality whilst reducing time and cost in the selection process.

A Survey on Renamings of Software Entities

More than 70% of characters in the source code are used to label identifiers. Consequently, identifiers are one of the most important source for program comprehension. Meaningful identifiers are crucial to understand and maintain programs. However, for reasons like constrained schedule, inexperience, and unplanned evolution, identifiers may fail to convey the semantics of the entities associated with them. As a result, such entities should be renamed to improve software quality. However, manual renaming and recommendation are fastidious, time consuming, and error prone, whereas automating the process of renamings is challenging: (1) It involves complex natural language processing to understand the meaning of identifers; (2) It also involves difficult semantic analysis to determine the role of software entities. Researchers proposed a number of approaches and tools to facilitate renamings. We present a survey on existing approaches and classify them into identification of renaming opportunities, execution of renamings, and detection of renamings. We find that there is an imbalance between the three type of approaches, and most of implementation of approaches and evaluation dataset are not publicly available. We also discuss the challenges and present potential research directions. To the best of our knowledge, this survey is the first comprehensive study on renamings of software entities.

Impact of Design Patterns on Software Complexity and Size

Many different factors influence the quality of software. Among the most important of these factors is software complexity. One way to improve software quality, therefore, is to minimize its complexity making it more understandable and maintainable. The design phase of the software development life cycle plays an instrumental role in fostering quality in software. Seasoned designers often use past design best practices codified in the form of design patterns to make their designs and the resultant code more elegant, robust, and resilient to change. Little work, however, has been done to empirically assess the quantitative impact of design patterns on software complexity. This research is an attempt to fill this gap. A comparative analysis of before and after versions of program pairs written without and with design patterns was performed for all twenty three GoF (Gang of Four) design patterns. These program pairs were collected (or, in some cases, developed) and compared with respect to their complexity and size. The results of this comparative analysis reveal that the cyclomatic complexity of the programs written using design patterns was less for most of the design patterns as compared to the programs written without using design patterns. However, the values of CK metrics, number of classes, and software size SLOC (Source Lines of Code) increased when design patterns were used.

Software Defect Prediction Using Heterogeneous Ensemble Classification Based on Segmented Patterns

Software defect prediction is a promising approach aiming to improve software quality and testing efficiency by providing timely identification of defect-prone software modules before the actual testing process begins. These prediction results help software developers to effectively allocate their limited resources to the modules that are more prone to defects. In this paper, a hybrid heterogeneous ensemble approach is proposed for the purpose of software defect prediction. Heterogeneous ensembles consist of set of classifiers of different learning base methods in which each of them has its own strengths and weaknesses. The main idea of the proposed approach is to develop expert and robust heterogeneous classification models. Two versions of the proposed approach are developed and experimented. The first is based on simple classifiers, and the second is based on ensemble ones. For evaluation, 21 publicly available benchmark datasets are selected to conduct the experiments and benchmark the proposed approach. The evaluation results show the superiority of the ensemble version over other well-regarded basic and ensemble classifiers.

How Usability Defects Defer from Non-Usability Defects? : A Case Study on Open Source Projects

Usability is one of the software qualities attributes that is subjective and often considered as a less critical defect to be fixed. One of the reasons was due to the vague defect descriptions that could not convince developers about the validity of usability issues. Producing a comprehensive usability defect description can be a challenging task, especially in reporting relevant and important information. Prior research in improving defect report comprehension has often focused on defects in general or studied various aspects of software quality improvement such as triaging defect reports, metrics and predictions, automatic defect detection and fixing. In this paper, we studied 2241 usability and non-usability defects from three open-source projects - Mozilla Thunderbird, Firefox for Android, and Eclipse Platform. We examined the presence of eight defect attributes - steps to reproduce, impact, software context, expected output, actual output, assume cause, solution proposal, and supplementary information, and used various statistical tests to answer the research questions. In general, we found that usability defects are resolved slower than non-usability defects, even for non-usability defect reports that have less information. In terms of defect report content, usability defects often contain output details and software context while non-usability defects are preferably explained using supplementary information, such as stack traces and error logs. Our research findings extend the body of knowledge of software defect reporting, especially in understanding the characteristics of usability defects. The promising results also may be valuable to improve software development practitioners' practice.

Preface to the special section on improving software quality through formal methods

This special issue is dedicated to the presentation of novel results in the scope of formal methods for the verification and testing of software. The papers included in the special issue showcase approaches that successfully combine a rigorous and formal background with the capability to address real software applications in realistic settings.

An automated approach to assess the similarity of GitHub repositories

Open source software (OSS) allows developers to study, change, and improve the code free of charge. There are several high-quality software projects which deliver stable and well-documented products. Most OSS forges typically sustain active user and expert communities which in turn provide decent levels of support both with respect to answering user questions as well as to repairing reported software bugs. Code reuse is an intrinsic feature of OSS, and developing a new system by leveraging existing open source components can reduce development effort, and thus it can be beneficial to at least two phases of the software life cycle, i.e., implementation and maintenance. However, to improve software quality, it is essential to develop a system by learning from well-defined, mature projects. In this sense, the ability to find similar projects that facilitate the undergoing development activities is of high importance. In this paper, we address the issue of mining open source software repositories to detect similar projects, which can be eventually reused by developers. We propose CrossSim as a novel approach to model the OSS ecosystem and to compute similarities among software projects. An evaluation on a dataset collected from GitHub shows that our proposed approach outperforms three well-established baselines.

A hybrid DevOps process supporting software reuse: A pilot project

AbstractLarge software development organizations manage reusable software components through a reusable software repository in order to reduce development time and cost and to improve software quality and productivity. This paper presents a hybrid DevOps process with a systematic reuse‐based software development and management process to reduce the effort and cost required for the rework and to increase productivity. The proposed approach promotes the systematic reuse of software components based on both information retrieval and ontology‐based retrieval techniques. The reusable assets are presented in different styles to ease and support the reuse process with fine‐grained reusable artifacts. To evaluate our proposed process, a pilot project, aiming to monitor the health of a patient, was developed and monitored the reuse activities throughout the whole experiment. The results revealed that our proposed process got an average gain of 35.2% in terms of developed function points by reusing 30.63% of reusable artifacts available in the reuse repository.

The Influence of Deep Learning Algorithms Factors in Software Fault Prediction

The discovery of software faults at early stages plays an important role in improving software quality; reduce the costs, time, and effort that should be spent on software development. Machine learning (ML) have been widely used in the software faults prediction (SFP), ML algorithms provide varying results in terms of predicting software fault. Deep learning achieves remarkable performance in various areas such as computer vision, natural language processing, speech recognition, and other fields. In this study, two deep learning algorithms are studied, Multi-layer perceptron’s (MLPs) and Convolutional Neural Network (CNN) to address the factors that might have an influence on the performance of both algorithms. The experiment results show how modifying parameters is directly affecting the resulting improvement, these parameters are manipulated until the optimal number for each of them is reached. Moreover, the experiments show that the effect of modifying parameters had an important role in prediction performance, which reached a high rate in comparison with the traditional ML algorithm. To validate our assumptions, the experiments are conducted on four common NASA datasets. The result shows how the addressed factors might increase or decrease the fault detection rate measurement. The improvement rate was as follows up to 43.5% for PC1, 8% for KC1, 18% for KC2 and 76.5% for CM1.

Statistical model checking for blockchain-based applications

Blockchain-based applications have become increasingly popular in recent years. Security concerns are rising as blockchain users are becoming aware of how their private data is stored across this decentralized network of computing nodes. Formal verification allows developers to improve software quality and hence make it more secure. The main hypothesis of this paper is that it is achievable to perform formal verification of a model that represents a smart contract responsible for user registration. In order to test the hypothesis, we have created a model of such a smart contract and checked it against a set of formal constraints. As a result of the conducted study, a conclusion can be made that the hypothesis is correct.

A Maturity Model for Secure Software Design: A Multivocal Study

Security is one of the most important software quality attributes. Software security is about designing and developing secure software that does not allow the integrity, confidentiality, and availability of its code, data, or service to be compromised. Organizations tend to consider security as an afterthought, and they continue to suffer from security risks. Developing secure software requires taking security into consideration in all phases of the Software Development Life Cycle (SDLC). Several approaches have been developed to improve software quality, such as Capability Maturity Model Integration (CMMI). However, software security issues have not been addressed in a proper manner and incorporating security practices into the SDLC remains a challenge. The objective of this paper is to develop a framework to improve the process of designing secure products in software development organizations. To achieve this objective, a Multivocal Literature Review (MLR) was conducted to identify the relevant studies in both the formal and grey literature. A total of 38 primary studies were identified, and available evidence was synthesized into 8 knowledge areas and 65 best practices to build a Secure Software Design Maturity Model (SSDMM). The framework was developed based on the structure of CMMI v2.0 and evaluated through case studies in real-world environments. The case study results indicate that SSDMM is useful in measuring the maturity level of an organization for the secure design phase of SDLC. SSDMM will assist organizations in evaluating and improving their software design security practices. It will also provide a foundation for researchers to develop new software security approaches.

Testability as a Measure for Improving Software Quality in System Analysis and Design

Testability as a Measure for Improving Software Quality in System Analysis and Design

Machine Learning Algorithm Application in Software Quality Improvement using Metrics

Machine learning purely concerned on the concept with building the program that improves the tasks performance through experience. Machine learning algorithms have proven to be of great practical value in a variety of application domains. the field of software engineering turns out to be a fertile ground where many software development tasks could be formulated as learning problems, analyzing design and testing plays the major role and approached in terms of learning algorithms We discuss several metrics in each of five types of software quality metrics: product quality, in-process quality, testing quality, maintenance equality, and customer satisfaction quality.

Every build you break: developer-oriented assistance for build failure resolution

Continuous integration is an agile software development practice. Instead of integrating features right before a release, they are constantly being integrated into an automated build process. This shortens the release cycle, improves software quality, and reduces time to market. However, the whole process will come to a halt when a commit breaks the build, which can happen for several reasons, e.g., compilation errors or test failures, and fixing the build suddenly becomes a top priority. Developers not only have to find the cause of the build break and fix it, but they have to be quick in all of it to avoid a delay for others. Unfortunately, these steps require deep knowledge and are often time-consuming. To support developers in fixing a build break, we propose Bart, a tool that summarizes the reasons for Maven build failures and suggests possible solutions found on the internet. We will show in a case study with 17 participants that developers find Bart useful to understand build breaks and that using Bart substantially reduces the time to fix a build break, on average by 37%. We have also conducted a qualitative study to better understand the workflows and information needs when fixing builds. We found that typical workflows differ substantially between various error categories, and that several uncommon build errors are both very hard to investigate and to fix. These findings will be useful to inform future research in this area.

Prioritizing software refactoring opportunities using multi-objective optimization

Software refactoring aims to improve software quality and developer productivity. It has gained significant attention from both academia and software industry. Therefore, numerous approaches have been proposed to automate refactoring that consider software quality maximization as their prime objective. However, this objective is not enough to generate good and efficient refactoring sequences as refactoring also involves several other uncertainties related to smell severity, history of applied refactoring activities and class severity. To address these concerns, we propose a multi-objective optimization approach to generate refactoring solutions that maximize the (1) software quality, (2) use of smell severity and (3) consistency with class importance. To this end, we use Multi-objective Spotted Hyena Optimizer (MOSHO) to obtain the best compromise between these three objectives. The proposed approach is evaluated on five open source datasets and its performance is compared with five different well-known state-of-the-art meta-heuristic and non-meta-heuristic approaches. The experimental results demonstrate that the refactoring solutions provided by MOSHO are significantly better than other algorithms when class importance and code smell severity scores are used.

How does object-oriented code refactoring influence software quality? Research landscape and challenges

ContextSoftware refactoring aims to improve software quality and developer productivity. Numerous empirical studies investigating the impact of refactoring activities on software quality have been conducted over the last two decades. ObjectiveThis study aims to perform a comprehensive systematic mapping study of existing empirical studies on evaluation of the effect of object-oriented code refactoring activities on software quality attributes. MethodWe followed a multi-stage scrutinizing process to select 142 primary studies published till December 2017. The selected primary studies were further classified based on several aspects to answer the research questions defined for this work. In addition, we applied vote-counting approach to combine the empirical results and their analysis reported in primary studies. ResultsThe findings indicate that studies conducted in academic settings found more positive impact of refactoring on software quality than studies performed in industries. In general, refactoring activities caused all quality attributes to improve or degrade except for cohesion, complexity, inheritance, fault-proneness and power consumption attributes. Furthermore, individual refactoring activities have variable effects on most quality attributes explored in primary studies, indicating that refactoring does not always improve all quality attributes. ConclusionsThis study points out several open issues which require further investigation, e.g., lack of industrial validation, lesser coverage of refactoring activities, limited tool support, etc.

Analyzing Evolution Patterns of Object-Oriented Metrics

Software evolution is mandatory to keep it useful and functional. However, the quality of the evolving software may degrade due to improper incorporation of changes. Quality can be monitored by analyzing the trends of software metrics extracted from source code as these metrics represent the structural characteristics of a software such as size, coupling, inheritance etc. An analysis of these metric trends will give insight to software practitioners regarding effects of software evolution on its internal structure. Thus, this study analyzes the trends of 14 object-oriented (OO) metrics in a widely used mobile operating system software, Android. The study groups the OO metrics into four dimensions and analyzes the trends of these metrics over five versions of Android software (4.0.2-4.3.1). The results of the study indicate certain interesting patterns for the evaluated dimensions, which can be helpful to software practitioners for outlining specific maintenance decisions to improve software quality.