Improve Software Quality Research Articles

Integrating AI in testing automation: Enhancing test coverage and predictive analysis for improved software quality

This research explores the integration of Artificial Intelligence (AI) in testing automation, focusing on its ability to enhance test coverage and enable predictive analysis for improved software quality. As software systems become increasingly complex, traditional testing methods often struggle to meet quality demands. This study evaluates various AI techniques, including machine learning and natural language processing, and their applications in generating test cases, optimizing testing processes, and predicting defects. Through empirical case studies from diverse organizations, we demonstrate significant improvements in test coverage and defect detection rates following AI implementation. The findings highlight the efficiency gains and quality enhancements achieved through AI-driven testing, while also addressing challenges such as data dependency, complexity of implementation, and the need for skilled personnel. This research contributes to the understanding of AI's role in software testing and encourages organizations to adopt these technologies for better quality assurance and faster development cycles.

Software Change Request in Software Development Project : Factors and Methods (Scoping Review Methods)

Software development is dynamic by nature, often requiring changes in software requirements through Software Change Requests (SCRs). This research aims to identify and analyze the key factors that influence SCRs in software development projects and evaluate the methods used to effectively manage these changes. This research uses the Scoping Review Method to systematically review and synthesize existing literature on SCRs, aiming to provide a comprehensive understanding of current practices, challenges, and strategies for managing software change requests. The review includes an extensive search of academic databases to identify relevant studies that address SCR factors and management methods. Key factors that influence SCR include project size, complexity, stakeholder involvement, and clarity of initial requirements. Methods for managing SCR are categorized into formal approaches, such as structured change control processes and tools, and informal approaches, which rely on ad-hoc communication and collaboration. The results underscore the importance of a well-defined change management process to mitigate the risks associated with SCR. Effective SCR management can improve project outcomes by improving software quality, increasing stakeholder satisfaction, and minimizing project delays. This research has practical implications for software development professionals by providing insight into effective SCR management techniques. This research also identifies gaps in the literature, recommending future research on the impact of agile methodologies and the use of automated tools in facilitating change management. Understanding these factors and methods enables practitioners to better navigate the complexities of software change, ensuring successful project delivery and maintaining high software quality.

CI/CD model for optimizing software deployment in SMEs

Small and Medium-sized Enterprises (SMEs) face unique challenges in software deployment, often dealing with limited resources, budget constraints, and the need for fast, reliable updates. This review outlines a Continuous Integration and Continuous Deployment (CI/CD) model specifically tailored to optimize software deployment in SME environments. The proposed CI/CD framework enhances operational efficiency by automating the integration, testing, and deployment processes, significantly reducing the risk of human error and deployment failures. The model leverages key CI/CD practices, including automated testing, version control, and continuous monitoring, to ensure seamless updates and minimal downtime. By integrating tools like Jenkins, GitLab, and Docker, SMEs can streamline code integration, enhance collaboration between development and operations teams, and enable faster, more frequent releases. Automated testing ensures that code changes are validated before deployment, identifying and addressing potential issues early in the development cycle. The framework also emphasizes rollback capabilities and monitoring systems to further reduce deployment risks. Rollbacks allow for quick recovery in case of failure, while continuous monitoring enables real-time detection of performance issues, helping SMEs maintain operational uptime and minimize service disruptions. Moreover, the model supports a microservices architecture, allowing SMEs to scale their applications efficiently without compromising stability. Incorporating CI/CD practices fosters agility, enabling SMEs to respond rapidly to market demands and customer feedback. This model not only improves software quality and deployment speed but also aligns with the budgetary and operational limitations of SMEs. It provides a cost-effective solution that enhances overall system reliability and reduces the frequency of software-related incidents. This CI/CD model serves as a practical approach to software deployment, empowering SMEs to optimize their software development lifecycle while ensuring continuous improvement and operational stability.

Code review in digital humanities

Abstract Software and computational methods offer tremendous possibilities for digital humanities research, both accelerating existing work and opening up entirely new questions. However, software also has the potential to introduce new kinds of errors into the research workflow. How do we know that the software developed for a digital humanities project is error free and does what we think it does? Code review is a widespread technique to improve software quality and reduce the number of flaws, where a programmer other than the author reviews and comments on the source code. However, given that many digital humanities developers work in developer teams of one, code review is often not possible. In this article, we share progress and insights from an effort to establish a community code review process for digital humanities, and provide background to help understand the need and potential impacts of this work.

Dynamics of Competition on Openness Strategies and Software Maintenance

Software firms are increasingly adopting an open source strategy, allowing them to leverage the effort exerted by the open source community toward improving software quality. In addition to embracing a proprietary or fully open source strategy, several firms choose a partial openness strategy wherein only certain parts of the code are open source while the rest is proprietary. Specifically, when adopting a partial openness strategy, a firm may choose to make the core software code open source while keeping the extension software code proprietary or keep the core proprietary and make the extension open source. When making decisions related to different openness strategies, firms need to take into account the level of effort they are exerting toward the improvement of the quality of software, the level of engagement of the open source community, and pricing. Hence, the decisions related to a firm’s openness strategy are not straightforward. While this is an important question for many firms, it has not been analyzed in the literature. In this research, we attempt to fill this important gap by analyzing different openness strategies in the context of resource allocation for fixing defects. Specifically, using a game-theoretic model, we explore when a firm should make its software fully open source or partially open source and when it should keep it proprietary. Our results show that when the baseline demand for the firm increases with the extent of openness, the firm should either make its software fully open or keep it proprietary and, importantly, should not rely on partial openness. Next, in scenarios where customers are highly sensitive to security risks, the demand loss to efficiency gain ratio has an important role in determining a firm’s optimal openness strategies. These findings provide important insights to firms on how to effectively plan their openness strategies and also establish a basis for future research on the topic of partial openness.

Improving Source Code Quality by Minimizing Refactoring Effort

Software maintenance is a time-consuming and costly endeavor. As a part of maintenance, refactoring is aimed at enhancing quality. Due to project deadlines and limited resources, developers need to prioritize refactoring activities. In this paper, we present a livestock management-inspired approach for identifying and prioritizing classes to refactor within an object-oriented program. This approach empowers developers to enhance the time/quality ratio. The novelty of our approach lies in utilizing established metrics for detecting code defects to prioritize each class. To validate its effectiveness, the approach was tested on four distinct Pharo-based open source programs. The results demonstrate the approach's efficacy in improving software quality, reducing development time, and enhancing team productivity

RESEARCH ON ARTIFICIAL INTELLIGENCE TOOLS FOR AUTOMATING THE SOFTWARE TESTING PROCESS

The subject matter of the article is artificial intelligence (AI) tools for automating the software testing process. The rapid development of the software development industry in recent decades has led to a significant increase in competition in the IT technology market and, as a result, stricter requirements for corresponding products and services. AI-driven test automation is becoming increasingly relevant due to its ability to solve complex tasks that previously required significant human resources. The goal of the work is to investigate the possibilities of using AI technologies to automate manual testing processes, which will increase testing efficiency, reduce costs, and improve software quality. The following tasks were solved in the article: analysis of existing tools and approaches to test automation using AI; development of a conceptual model of a system that integrates AI into the testing process; exploring the potential of AI to automate various aspects of software testing, such as generating test scenarios, detecting defects, predicting errors, and automatically analyzing test results. The following methods are used: theoretical analysis of the literature and existing solutions in the field of test automation, experimental study of the effectiveness of the proposed test automation methods. The following results were obtained: the concept of a system that integrates AI technologies for automating software testing is presented. It has been found that the use of AI allows automating routine testing tasks, significantly reducing the number of human errors, and improving the quality of software products and the effectiveness of verification and validation processes. Conclusions: The development and implementation of AI-based testing automation systems are extremely relevant and promising. The use of AI technologies makes it possible to significantly increase the efficiency of testing, reduce the costs of its implementation, and improve the quality of software. The proposed approach to the development of an AI-based test automation system can be used as a basis for further research and development in this field.

Machine Learning-Based Methods for Code Smell Detection: A Survey

Code smells are early warning signs of potential issues in software quality. Various techniques are used in code smell detection, including the Bayesian approach, rule-based automatic antipattern detection, antipattern identification utilizing B-splines, Support Vector Machine direct, SMURF (Support Vector Machines for design smell detection using relevant feedback), and immune-based detection strategy. Machine learning (ML) has taken a great stride in this area. This study includes relevant studies applying ML algorithms from 2005 to 2024 in a comprehensive manner for the survey to provide insight regarding code smell, ML algorithms frequently applied, and software metrics. Forty-two pertinent studies allow us to assess the efficacy of ML algorithms on selected datasets. After evaluating various studies based on open-source and project datasets, this study evaluated additional threats and obstacles to code smell detection, such as the lack of standardized code smell definitions, the difficulty of feature selection, and the challenges of handling large-scale datasets. The current studies only considered a few factors in identifying code smells, while in this study, several potential contributing factors to code smells are included. Several ML algorithms are examined, and various approaches, datasets, dataset languages, and software metrics are presented. This study provides the potential of ML algorithms to produce better results and fills a gap in the body of knowledge by providing class-wise distributions of the ML algorithms. Support Vector Machine, J48, Naive Bayes, and Random Forest models are the most common for detecting code smells. Researchers can find this study helpful in better anticipating and taking care of software development design and implementation issues. The findings from this study, which highlight the practical implications of ML algorithms in software quality improvement, will help software engineers fix problems during software design and development to ensure software quality.

Mining software insights: uncovering the frequently occurring issues in low-rating software applications.

In today's digital world, app stores have become an essential part of software distribution, providing customers with a wide range of applications and opportunities for software developers to showcase their work. This study elaborates on the importance of end-user feedback for software evolution. However, in the literature, more emphasis has been given to high-rating & popular software apps while ignoring comparatively low-rating apps. Therefore, the proposed approach focuses on end-user reviews collected from 64 low-rated apps representing 14 categories in the Amazon App Store. We critically analyze feedback from low-rating apps and developed a grounded theory to identify various concepts important for software evolution and improving its quality including user interface (UI) and user experience (UX), functionality and features, compatibility and device-specific, performance and stability, customer support and responsiveness and security and privacy issues. Then, using a grounded theory and content analysis approach, a novel research dataset is curated to evaluate the performance of baseline machine learning (ML), and state-of-the-art deep learning (DL) algorithms in automatically classifying end-user feedback into frequently occurring issues. Various natural language processing and feature engineering techniques are utilized for improving and optimizing the performance of ML and DL classifiers. Also, an experimental study comparing various ML and DL algorithms, including multinomial naive Bayes (MNB), logistic regression (LR), random forest (RF), multi-layer perception (MLP), k-nearest neighbors (KNN), AdaBoost, Voting, convolutional neural network (CNN), long short-term memory (LSTM), bidirectional long short term memory (BiLSTM), gated recurrent unit (GRU), bidirectional gated recurrent unit (BiGRU), and recurrent neural network (RNN) classifiers, achieved satisfactory results in classifying end-user feedback to commonly occurring issues. Whereas, MLP, RF, BiGRU, GRU, CNN, LSTM, and Classifiers achieved average accuracies of 94%, 94%, 92%, 91%, 90%, 89%, and 89%, respectively. We employed the SHAP approach to identify the critical features associated with each issue type to enhance the explainability of the classifiers. This research sheds light on areas needing improvement in low-rated apps and opens up new avenues for developers to improve software quality based on user feedback.

SDP-MTF: A Composite Transfer Learning and Feature Fusion for Cross-Project Software Defect Prediction

Software defect prediction is critical for improving software quality and reducing maintenance costs. In recent years, Cross-Project software defect prediction has garnered significant attention from researchers. This approach leverages transfer learning to apply the knowledge from existing projects to new ones, thereby enhancing the universality of predictive models. It provides an effective solution for projects with limited historical defect data. Nevertheless, current methodologies face two main challenges: first, the inadequacy of feature information mining, where code statistical information or semantic information is used in isolation, ignoring the benefits of their integration; second, the substantial feature disparity between different projects, which can lead to insufficient effect during transfer learning, necessitating additional efforts to narrow this gap to improve precision. Addressing these challenges, this paper proposes a novel methodology, SDP-MTF (Software Defect Prediction using Multi-stage Transfer learning and Feature fusion), that combines code statistical features, deep semantic features, and multiple feature transfer learning methods to enhance the predictive effect. The SDP-MTF method was empirically tested on single-source cross-project software defect prediction across six projects from the PROMISE dataset, benchmarked against five baseline algorithms that employ distinct features and transfer methodologies. Our findings indicate that SDP-MTF significantly outperforms five classical baseline algorithms, improving the F1-Score by 8% to 15.2%, thereby substantively advancing the precision of cross-project software defect prediction.

Automated construction of reference model for software remodularization through software evolution

AbstractThe undocumented evolution of a software project and its underlying architecture underscores the need to recover the architecture from the software's implementation‐level artifacts. Despite the existence of various software remodularization techniques, they often suffer from inaccuracies, and evaluating their effectiveness is challenging due to the absence of accurate “ground‐truth” architectures or reference models. Prior studies on reference model construction are time‐consuming and labor‐intensive as it heavily relies on manual analysis by domain experts. Besides, other existing approaches that directly utilize the directory or package structure of the latest version can be unreliable, lacking in‐depth analysis of the employed software structure. To address the above limitations, in this paper, we propose Automated Construction of Reference Model (ACRM), an approach for automatically constructing reference models by assigning weights to classes for various software projects using the metadata of all software versions and historical maintenance records. We evaluate ACRM through both quantitative and qualitative analyses. The experiment results provide quantitative validation and show that the generated reference models are reasonable, as confirmed by the relationship between proposed reference models and architectural smells or bugs. Furthermore, we conduct a survey among the practitioners from industry, to gain insights from practitioners' practices and further validate the generated reference models. The survey shows that, on average, 87% of the participants agree with the reference models generated by ACRM. Moreover, we propose an improved metric, wc2c, which analyzes the strengths and weaknesses of different types of software clustering techniques using the proposed reference models of the given software. Finally, we discuss the potential benefits of using ACRM in analyzed projects, particularly in terms of improving software quality, reducing maintenance costs, and enhancing developer productivity.

Data preparation for Deep Learning based Code Smell Detection: A systematic literature review

Code Smell Detection (CSD) plays a crucial role in improving software quality and maintainability. And Deep Learning (DL) techniques have emerged as a promising approach for CSD due to their superior performance. However, the effectiveness of DL-based CSD methods heavily relies on the quality of the training data. Despite its importance, little attention has been paid to analyzing the data preparation process. This systematic literature review analyzes the data preparation techniques used in DL-based CSD methods. We identify 36 relevant papers published by December 2023 and provide a thorough analysis of the critical considerations in constructing CSD datasets, including data requirements, collection, labeling, and cleaning. We also summarize seven primary challenges and corresponding solutions in the literature. Finally, we offer actionable recommendations for preparing and accessing high-quality CSD data, emphasizing the importance of data diversity, standardization, and accessibility. This survey provides valuable insights for researchers and practitioners to harness the full potential of DL techniques in CSD.

Towards a framework for reliable performance evaluation in defect prediction

Enhancing software reliability, dependability, and security requires effective identification and mitigation of defects during early development stages. Software defect prediction (SDP) models have emerged as valuable tools for this purpose. However, there is currently a lack of consensus in evaluating the predictive performance of newly proposed models, which hinders accurate measurement of progress and can lead to misleading conclusions. To tackle this challenge, we present MATTER (a fraMework towArd a consisTenT pErformance compaRison), which aims to provide reliable and consistent performance comparisons for SDP models. MATTER incorporates three key considerations. First, it establishes a global reference point, ONE (glObal baseliNe modEl), which possesses the 3S properties (Simplicity in implementation, Strong predictive ability, and Stable prediction performance), to serve as the baseline for evaluating other models. Second, it proposes using the SQA-effort-aligned threshold setting to ensure fair performance comparisons. Third, it advocates for consistent performance evaluation by adopting a set of core performance indicators that reflect the practical value of prediction models in achieving tangible progress. Through the application of MATTER to the same benchmark data sets, researchers and practitioners can obtain more accurate and meaningful insights into the performance of defect prediction models, thereby facilitating informed decision-making and improving software quality. When evaluating representative SDP models from recent years using MATTER, we surprisingly observed that: none of these models demonstrated a notable enhancement in prediction performance compared to the simple baseline model ONE. In future studies, we strongly recommend the adoption of MATTER to assess the actual usefulness of newly proposed models, promoting reliable scientific progress in defect prediction.

Development of optimised software fault prediction model using machine learning

Software fault prediction is a crucial task, especially with the rapid improvements in software technology and increasing complexity of software. As identifying and addressing bugs early in the development process can significantly minimize the costs and enhance the software quality. Software fault prediction using machine learning algorithms has gained significant attention due to its potential to improve software quality and save time in the testing phase. This research paper investigates the impact of classification models on bug prediction performance and explores the use of bio-inspired optimization techniques to enhance model results. Through experiments, it is demonstrated that applying bio-inspired algorithms improves the accuracy of fault prediction models. The evaluation is based on multiple performance metrics and the results show that KNN with BACO (Binary Ant Colony Optimization) generally outperform the other models in terms of accuracy. The BACO-KNN fault prediction model attains the accuracy of 96.39% surpassing the previous work.

Improving accuracy of code smells detection using machine learning with data balancing techniques

Code smells indicate potential symptoms or problems in software due to inefficient design or incomplete implementation. These problems can affect software quality in the long-term. Code smell detection is fundamental to improving software quality and maintainability, reducing software failure risk, and helping to refactor the code. Previous works have applied several prediction methods for code smell detection. However, many of them show that machine learning (ML) and deep learning (DL) techniques are not always suitable for code smell detection due to the problem of imbalanced data. So, data imbalance is the main challenge for ML and DL techniques in detecting code smells. To overcome these challenges, this study aims to present a method for detecting code smell based on DL algorithms (Bidirectional Long Short-Term Memory (Bi-LSTM) and Gated Recurrent Unit (GRU)) combined with data balancing techniques (random oversampling and Tomek links) to mitigate data imbalance issue. To establish the effectiveness of the proposed models, the experiments were conducted on four code smells datasets (God class, data Class, feature envy, and long method) extracted from 74 open-source systems. We compare and evaluate the performance of the models according to seven different performance measures accuracy, precision, recall, f-measure, Matthew’s correlation coefficient (MCC), the area under a receiver operating characteristic curve (AUC), the area under the precision–recall curve (AUCPR) and mean square error (MSE). After comparing the results obtained by the proposed models on the original and balanced data sets, we found out that the best accuracy of 98% was obtained for the Long method by using both models (Bi-LSTM and GRU) on the original datasets, the best accuracy of 100% was obtained for the long method by using both models (Bi-LSTM and GRU) on the balanced datasets (using random oversampling), and the best accuracy 99% was obtained for the long method by using Bi-LSTM model and 99% was obtained for the data class and Feature envy by using GRU model on the balanced datasets (using Tomek links). The results indicate that the use of data balancing techniques had a positive effect on the predictive accuracy of the models presented. The results show that the proposed models can detect the code smells more accurately and effectively.

Design of Software Reliability Prediction using Radial Basis Function Networks with Nonlinear Analysis and Topological Considerations

This study presents a thorough methodology for predicting software reliability by employing Radial Basis Function Networks (RBFNs). By using machine learning methodologies such as Radial Basis Function Networks (RBFNs), software development teams are enabled to make well-informed decisions, optimize resource allocation, and proactively mitigate potential dependability concerns. Consequently, this results in improved software quality and heightened customer happiness. This methodology involves multiple stages, starting with data collection and preprocessing. We assemble a comprehensive dataset comprising historical software performance metrics, defect reports, and relevant development process information. After data cleansing and feature engineering, we split the dataset into training, validation, and testing subsets. The core of this approach lies in the construction and training of RBFNs. These neural networks consist of an input layer, a hidden layer with radial basis functions, and an output layer. The architecture parameters, particularly the number of hidden neurons and the spread parameter of the radial basis functions, are optimized through a systematic hyperparameter tuning process using the validation dataset. Upon achieving an optimal model configuration, we rigorously evaluate the RBFN predictive capabilities using the testing dataset.

Rand-Index Target Projective Gradient Deep Belief Network for Software Fault Prediction

Predicting defective software modules before testing is a valuable operation that reduces time and cost of software testing. Source code fault prediction plays a vital role in improving software quality that effectively assists in optimization testing resource allocation. Several machine learning and ensemble learning techniques has been extensively evolved over the recent few years to predict defect at an early stage. These techniques made predictions based on historical defect data, the software metrics. Nevertheless, the time efficient and accurate fault predictions are the major challenging tasks that yet have to be addressed. In order to ensure accurate software fault prediction, a method called Rand-Index Target Projective Gradient Deep Belief Network (RTPGDBN) is designed. The proposed RTPGDBN method comprises of three processes namely acquiring JAVA packages, software metric selection and classification. First, the number of JAVA packages is used as input from the dataset. Second with the JAVA packages obtained as input, Rand similarity indexive target projection function is applied for selecting the most significant software metrics in order to minimize time complexity of fault prediction. Third, with the selected metrics, classification is performed using Tversky Gradient Deep Belief neural network. Also, gradient descent function is applied to minimize classification error, therefore ensuring accurate software fault classification results obtained at the output layer. Experimental setup of proposed RPGDDBN and existing methods are implemented in Java language and the dataset collected from smell prediction replication package. Performance analysis is carried out with different quantitative metrics such as accuracy, precision, recall, F-measure, and time complexity and space complexity. Through extensive experiments on repository data, experimental results indicate that our RPGDDBN method outperforms two state-of-the-art defect detection methods in terms of different performance metrics.

Multi-mechanism neural machine translation framework for automatic program repair

Automatic program repair (APR) is crucial to improve software quality. Recently, neural machine translation (NMT) based modeling for bug fixes has demonstrated great potential. However, these approaches still have two major challenges. One is that their search space is limited due to the out-of-vocabulary (OOV) problem. The other is that the NMT-based APR models tend to ignore past translation information, which often leads to over-translation and under-translation. To address the above challenges, we propose MNRepair, a new NMT-based APR approach that combines multiple mechanisms to fix bugs in source code. Specifically, we devise an encoder-decoder NMT framework with the attention mechanism. Our framework combines the copy mechanism to overcome the OOV problem that occurs with source code. To deal with the over-translation and under-translation, we utilize a coverage mechanism to record past translation information. MNRepair is able to capture a wide range of repair operators and fix 26 bugs in Defects4J. Our evaluation shows the effectiveness of multiple mechanisms in the repair process.

Toward a novel taxonomy to capture code smells caused by refactoring

Code smells tend to have an impact on software quality attributes such as reusability, maintainability, and understandability. These are code flaws that do not necessarily prevent the system from operating; rather, they increase the possibility of defects occurring in the future. Hence, to maintain code quality, code smells should be detected and corrected through refactoring. The objective of this paper is to investigate the associated risk of applying refactoring techniques and reveal the bad smells that may appear when fixing other bad smells. We conducted several controlled experiments to identify the smells that emerge after refactoring. The experiments resulted in a novel taxonomy revealing 9 bad smells that may appear as a result of fixing other bad smells. This represents the first study attempting to systematically identify and organize such refactoring-smell relationships into a taxonomy. The research results can assist developers in relating different bad smells to each other and helping them determine the refactoring technique that should be applied when certain smells are present. Moreover, the results can be beneficial in breaking the cycle of bad smells. Such knowledge tends to enhance code refactoring, which in turn will improve software quality and avoid technical debt.

Predicting the Number of Software Faults using Deep Learning

The software testing phase requires considerable time, effort, and cost, particularly when there are many faults. Thus, developers focus on the evolution of Software Fault Prediction (SFP) to predict faulty units in advance, therefore, improving software quality significantly. Forecasting the number of faults in software units can efficiently direct software testing efforts. Previous studies have employed several machine learning models to determine whether a software unit is faulty. In this study, a new, simple deep neural network approach that can adapt to the type of input data was designed, utilizing Convolutional Neural Networks (CNNs) and Multi-Layer Perceptron (MLP), to predict the number of software faults. Twelve open-source software project datasets from the PROMISE repository were used for testing and validation. As data imbalance can negatively impact prediction accuracy, the new version of synthetic minority over-sampling technique (SMOTEND) was used to resolve data imbalance. In experimental results, a lower error rate was obtained for MLP, compared to CNN, reaching 0.195, indicating the accuracy of this prediction model. The proposed approach proved to be effective when compared with two of the best machine learning models in the field of prediction. The code will be available on GitHub.