Enhance Software Quality Research Articles

Enhancing Software Quality Assurance in Ubiquitous Learning Environments through Mutation Testing and Diverse Test Oracles

Ubiquitous learning enables software analysts to acquire knowledge and design test oracles from online resources including developer documentations, forums and collaborative platforms. Test oracles are primarily designed by humans and may contain quality defects. Mutation testing can facilitate the adaptability of ubiquitous learning to enhance software quality assurance. Unfortunately, mutation testing generates a large number of faulty versions known as mutants to analyze the quality of test oracles which is computationally expensive. In this paper, we proposed minimal path selection strategy to select fewer and non-trivial mutants to analyze diverse test oracles realizing ubiquitous learning environments. The proposed selection strategy explores the relationship between faulty conditions and output statements to identify feasible paths. To establish a ubiquitous learning setup, diverse test oracles are selected by incorporating user input, automated scripts and developer insights. This approach aims to enhance learner engagement and effectively design test oracles. The empirical evaluation and state-of-the-art comparison of various Java-built software programs demonstrated the potential of ubiquitous learning in software quality assurance by reducing 75% of the generated mutants. Furthermore, only 64% to 85% of adequate test oracles were required to meet the desired quality assurance criteria. The study highlights the significance of personalized and adaptive approaches to assure software quality in ubiquitous learning environments.

Deciphering refactoring branch dynamics in modern code review: An empirical study on Qt

Context:Modern code review is a widely employed technique in both industrial and open-source projects, serving to enhance software quality, share knowledge, and ensure compliance with coding standards and guidelines. While code review is extensively studied for its general challenges, best practices, outcomes, and socio-technical aspects, little attention has been paid to how refactoring is reviewed and what developers prioritize when reviewing refactored code in the ‘Refactor’ branch. Objective:The goal is to understand the review process for refactoring changes in the ‘Refactor’ branch and to identify what developers care about when reviewing code in this branch. Method:In this study, we present a quantitative and qualitative examination to understand the main criteria developers use to decide whether to accept or reject refactored code submissions and identify the challenges inherent in this process. Results:Analyzing 2154 refactoring and non-refactoring reviews across Qt open-source projects, we find that reviews involving refactoring from the ‘Refactor’ branch take significantly less time to resolve in terms of code review efforts. Additionally, documentation of developer intent is notably sparse within the ‘Refactor’ branch compared to other branches. Furthermore, through thematic analysis of a substantial sample of refactoring code review discussions, we construct a comprehensive taxonomy consisting of 12 refactoring review criteria. Conclusion:Our findings underscore the importance of developing precise and efficient tools and techniques to aid developers in the review process amidst refactorings.

Automated reporting and statistical analysis of test case results in continuous integration: A custom dashboard approach

CI has been one of the cornerstones of modern software development, where teams integrate code changes frequently and have automated testing to receive fast feedback. Running a large amount of test data, however, is overwhelming and can be fatiguing in extracting meaningful insights from traditional reporting methods like email notifications. The paper presents a bespoke dashboard, designed to support the extension of automation in test case result reporting and analysis within a CI environment by real-time data visualization, interactivity in filtering and sorting, and statistical insights that would make trends and anomalies easier for teams to detect. Implemented in a large software project, this solution brought immense improvement in decision-making, team collaboration, and efficiency, since the dashboard reduced time spent on manual report analyses and generations. The flexibility and ability to integrate with a number of CI tools make it a powerful solution for addressing traditional reporting shortcomings and let development teams focus on areas needing improvement, ultimately enhancing software quality.

Evaluating Thresholds for Object-Oriented Software Metrics

Software metrics measure quantifiable or countable software characteristics. Researchers may apply them to provide better product understanding, evaluate the process effectiveness, and improve the software quality. A threshold is a value that aids the proper interpretation of software measurements; it indicates whether or not a given value represents a quality risk. Thresholds are unknown for most software metrics, inhibiting their use in a software quality assessment process. In a previous paper, we proposed a catalog with 18 object-oriented software metrics thresholds, providing a preliminary case study in proprietary software to validate them. This article evaluates these thresholds more deeply, considering significant aspects. We show a new example of threshold derivation, discussing it qualitatively. We explain these software metrics and discuss their threshold values, presenting each one’s application level, definition, formula, and implications for the software design. We conduct a study with two software systems to evaluate the capacity of our thresholds to identify software quality enhancement after a restructuring process. We assess these thresholds using two case studies, comparing the evaluation provided by the thresholds with the qualitative analysis given by manual inspections. The study results indicate that the thresholds may lead to few false-positive and false-negative occurrences, i.e., the thresholds provide a proper quantitative assessment of software quality. This study contributes with empirical evidence that the metrics’ thresholds proposed in our previous work provide a proper interpretation of software metrics and, hence, may aid the application of software metrics in practice.

Software Product Line Engineering via Software Transplantation

Software Product Lines (SPLs) improve time-to-market, enhance software quality, and reduce maintenance costs. Current SPL re-engineering practices are largely manual and require domain knowledge. Thus, adopting and, to a lesser extent, maintaining SPLs are expensive tasks, preventing many companies from enjoying their benefits. To address these challenges, we introduce Foundry , an approach utilizing software transplantation to reduce the manual effort of SPL adoption and maintenance. Foundry enables integrating features across different codebases, even codebases that are unaware that they are contributing features to a software product line. Each product produced by Foundry is pure code, without variability annotation, unlike feature flags, which eases variability management and reduces code bloat. We realise Foundry in prodScalpel , a tool that transplants multiple organs ( i.e. , a set of interesting features) from donor systems into an emergent product line for codebases written in C. Given tests and lightweight annotations identifying features and implantation points, prodScalpel automates feature extraction and integration. To evaluate its effectiveness, our evaluation compares feature transplantation using prodScalpel to the current state of practice: on our dataset, prodScalpel’s use speeds up feature migration by an average of 4.8 times when compared to current practice.

Enhancing Software Testing Practices in Tanzanian Software Development Companies: A Case Study Approach

Purposes: The primary objective of this conducted research is to investigate and propose strategies for improving software testing practices in Tanzanian software development companies. Specifically, the study identify the current state of software testing practices, understand challenges faced by software development companies in Tanzania, propose effective solutions, and evaluate their impact. Methodology: A mixed-methods approach employed to achieve the research objectives. Qualitative and quantitative data collection methods, including surveys, interviews, observations, documentation analysis, and experimentation, utilized to gather comprehensive insights into software testing practices. Purposive sampling employed to select diverse software development companies across different regions in Tanzania. Thematic analysis and statistical analysis applied to analyze qualitative and quantitative data, respectively, ensuring a robust examination of software testing practices. Findings: The research findings reveal the prevailing software testing practices in Tanzanian software development companies. Challenges such as resource constraints, inadequate test coverage, and limited collaboration between developers and testers are identified. Additionally, the study identifies best practices and proposes context-specific solutions to enhance software testing practices in Tanzanian companies. Statistical analysis provides quantitative insights into the effectiveness of proposed solutions. Unique Contribution to Theory, Practices and Policy: The study contributes to bridging the gap between academic research and industrial practices in software testing. Through addressing the unique challenges and opportunities in the Tanzanian context, the research provides actionable recommendations for improving software testing practices. The findings underscore the importance of tailored strategies and collaboration between academia and industry to enhance software quality and reliability in Tanzanian software development companies.

Implementing Continuous Integration/Continuous Deployment (CI/CD) Pipelines for Large-Scale iOS Applications

Continuous integration and continuous deployment pipelines have become essential components of modern software development, particularly in creating large-scale iOS apps. The automation of procedures for creating, testing, and deploying is facilitated by them, which results in an increase in both the speed and reliability of the release process. The complexity and scope of the codebase, the need for rigorous testing across a broad range of devices and operating system versions, and the regular necessity of updates to address bugs or bring new features all contribute to the conclusion that continuous integration and continuous delivery pipelines are an integral component of major iOS projects. The integration of continuous integration with continuous delivery provides developers with the assurance that code changes are automatically tested and delivered, hence lowering the need for human intervention, and reducing the chance of mistakes. In addition, this arrangement makes it possible to do parallel testing, which is useful when working with many test cases and device configurations. It is also possible to design continuous integration and continuous delivery pipelines to do tests for code quality, security scans, or other automated checks, which will ensure that the codebase is not compromised.By increasing communication among development teams, continuous integration and continuous delivery pipelines in big iOS projects provide yet another key advantage. It guarantees that every member of the team always has access to the most recent version of the code, which is essential in situations when many teams are working on various aspects or components of the application. In addition, continuous integration and continuous delivery pipelines enhance software quality by accelerating feedback loops, which enables engineers to resolve problems more expediently. Nevertheless, the establishment of continuous integration and continuous delivery pipelines for large-scale iOS apps involves several issues, such as the management of build times, the certification of compatibility with various devices, and the upkeep of the infrastructure. It is necessary to carefully design and optimize the CI/CD procedures to overcome these problems. This may be accomplished by choosing the appropriate tools and configurations adapted to the project's requirements.

Improving Software Defect Prediction With a Combination of Feature Selection Based On Ant Colony Optimization and Ensemble Technique

Software defect prediction plays a vital role in enhancing software quality and minimizing maintenance costs. This study aims to improve software defect prediction by employing a combination of Ant Colony Optimization (ACO) for feature selection and ensemble techniques, particularly Gradient Boosting. The research utilizes three NASA MDP datasets: MC1, KC1, and PC2, to evaluate the performance of four machine learning algorithms: Random Forest, Support Vector Machine (SVM), Decision Tree, and Naïve Bayes. Data preprocessing involved handling class imbalances using the SMOTE technique and transforming categorical data into numerical representations. The results indicate that the integration of ACO and Gradient Boosting significantly enhances the accuracy of all four algorithms. Notably, the Random Forest algorithm achieved the highest accuracy of 99% on the MC1 dataset. The findings suggest that combining ACO-based feature selection with ensemble techniques can effectively boost the performance of software defect prediction models, offering a robust approach for early detection of potential softwaredefects and contributing to improved software reliability and efficiency.

Sistem Informasi Bimbingan Tugas Akhir Mahasiswa menggunakan Model SDLC Berbasis Iconix Process

The final thesis assignment plays a crucial role in enabling students to meet the graduation requirements from college. However, the process of scheduling guidance for the final assignment between students and lecturers still relies on several common applications such as WhatsApp or email, which are not specifically designed for this purpose. The accumulation of incoming messages and various types of message information poses a challenge in the guidance process, leading to missed messages between students and lecturers and a lack of recorded information regarding the history of the process and guidance materials. These are some of the current issues. This paper aims to evaluate the functionality, quality, and reliability of the system by conducting black box testing on the application developed for the student final project guidance information system. This application uses the Iconix process-based SDLC (system development life cycle) model, covering student and lecturer profile information, guidance information, proposal submission, progress of the final thesis assignment, meeting schedule, guidance material, discussion forum, survey evaluation, and contact information. The SDLC model is employed in this research because it can effectively and efficiently achieve project targets, enhance software quality standards, and assist in better risk management and adaptation to change. The model comprises planning, needs analysis, design using the Iconix process, implementation, system testing, and maintenance. The Iconix process is utilized for system design modeling and analysis. Black box testing is performed on the system to verify that the system’s functional requirements are operating correctly. The findings of this research can serve as a control for management in the service and administration of final assignment guidance in higher education.

The role of psychological safety in promoting software quality in agile teams

Psychological safety continues to pique the interest of scholars in a variety of disciplines of study. Recent research indicates that psychological safety fosters knowledge sharing and norm clarity and complements agile values. Although software quality remains a concern in the software industry, academics have yet to investigate whether and how psychologically safe teams provide superior results. In this study, we explore how psychological safety influences agile teams’ quality-related behaviors aimed at enhancing software quality. To widen the empirical coverage and evaluate the results, we chose a two-phase mixed-methods research design with an exploratory qualitative phase (20 interviews) followed by a quantitative phase (survey study, N = 423). Our findings show that, when psychological safety is established in agile software teams, it induces enablers of a social nature that advance the teams’ ability to pursue software quality. For example, admitting mistakes and taking initiatives equally help teams learn and invest their learning in their future decisions related to software quality. Past mistakes become points of reference for avoiding them in the future. Individuals become more willing to take initiatives aimed at enhancing quality practices and mitigating software quality issues. We contribute to our endeavor to understand the circumstances that promote software quality. Psychological safety requires organizations, their management, agile teams, and individuals to maintain and propagate safety principles. Our results also suggest that technological tools and procedures can be utilized alongside social strategies to promote software quality.

Evolution-aware Constraint Derivation Approach for Software Remodularization

Existing software clustering techniques tend to ignore prior knowledge from domain experts, leading to results (suggested big-bang remodularization actions) that can not acceptable to developers. Incorporating domain experts knowledge or constraints during clustering ensures the obtained modularization aligns with developers’ perspectives, enhancing software quality. However, manual review by knowledgeable domain experts for constraint generation is time-consuming and labor-intensive. In this paper, we propose an evolution-aware constraint derivation approach, Escort, which automatically derives clustering constraints based on the evolutionary history from the analyzed software. Specifically, Escort can serve as an alternative approach to derive implicit and explicit constraints in situations where domain experts are absent. In the subsequent constrained clustering process, Escort can be considered as a framework to help supplement and enhance various unconstrained clustering techniques to improve their accuracy and reliability. We evaluate Escort based on both quantitative and qualitative analysis. In quantitative validation, Escort, using generated clustering constraints, outperforms seven classic unconstrained clustering techniques. Qualitatively, a survey with developers from five IT companies indicates that 89% agree with Escort’s clustering constraints. We also evaluate the utility of refactoring suggestions from our constrained clustering approach, with 54% acknowledged by project developers, either implemented or planned for future releases.

Bug Tracker User Guide

ABSTRACT___ The Bug Tracking Tool project addresses the pressing need for efficient bug tracking and management in contemporary software development. By leveraging modern web technologies and agile methodologies, the project aims to develop a comprehensive solution that streamlines bug identification, tracking, and resolution processes. Through a literature survey, key observations and shortcomings in existing bug tracking tools were identified, guiding the proposed work. The project’s methodology encompasses requirements gathering, design, implementation, testing, and deployment, focusing on user-centric design and functionality. Preliminary results demonstrate progress towards achieving project objectives, highlighting the tool’s potential to enhance software quality assurance practices and user satisfaction. Despite encountering challenges such as technical complexity and resource constraints, the project lays a solid foundation for future enhancements and optimizations. Overall, the Bug Tracking Tool project represents a significant step towards improving bug tracking practices and delivering higher-quality software products to end-users INDEX TEARMS – HTML, CSS , JavaScript, Python, Django Framework, SQLlite.

Bug Tracking System

For many years, bug-tracking mechanisms have been employed only in some of the large software development houses. Most of the others never bothered with bug tracking at all, and instead simply relied on shared lists and email to monitor the status of defects. This procedure is error-prone and tends to cause those bugs judged least significant by developers to be dropped or ignored. Bug Tracking System is an ideal solution to track the bugs of a product, solution or an application. Bug Tracking System allows individuals or groups of developers to keep track of outstanding bugs in their product effectively. This can also be called the Defect Tracking System. The Bug Tracking System can dramatically increase the productivity and accountability of individual employees by providing a documented workflow and positive feedback for good performance. Moreover, the project explores the use of machine learning for automated root cause analysis, assisting developers in identifying underlying issues contributing to bug occurrences. Recommendation systems are also developed to suggest potential fixes or solutions for reported bugs based on past incidents and code repositories, aiding developers in efficient bug resolution. Through these ML-driven functionalities, the proposed bug tracking software aims to revolutionize the bug management process, enabling faster bug detection, prioritization, and resolution, thereby enhancing software quality, user satisfaction, and overall development productivity. Key Words: Bug Tacking system, apps, users.

A new binary chaos-based metaheuristic algorithm for software defect prediction

Software defect prediction is a critical challenge within software engineering aimed at enhancing software quality by proactively identifying potential defects. This approach involves selecting defect-prone modules ahead of the testing phase, thereby reducing testing time and costs. Machine learning methods provide developers with valuable models for categorising faulty software modules. However, the challenge arises from the numerous elements present in the training dataset, which frequently reduce the accuracy and precision of classification. Addressing this, selecting effective features for classification from the dataset becomes an NP-hard problem, often tackled using metaheuristic algorithms. This study introduces a novel approach, the Binary Chaos-based Olympiad Optimisation Algorithm, specifically designed to select the most impactful features from the training dataset. By selecting these influential features for classification, the precision and accuracy of software module classifiers can be notably improved. The study's primary contributions involve devising a binary variant of the chaos-based Olympiad optimisation algorithm to meticulously select effective features and construct an efficient classification model for identifying faulty software modules. Five real-world and standard datasets were utilised across both the training and testing phases of the classifier to evaluate the proposed method's effectiveness. The findings highlight that among the 21 features within the training datasets, specific metrics such as basic complexity, the sum of operators and operands, lines of code, quantity of lines containing code and comments, and the sum of operands have the most significant influence on software defect prediction. This research underscores the combined effectiveness of the proposed method and machine learning algorithms, significantly boosting accuracy (91.13%), precision (92.74%), recall (97.61%), and F1 score (94.26%) in software defect prediction.

Behaviour-driven development and metrics framework for enhanced agile practices in scrum teams

ContextAgile methodologies highlight collaborative efforts among software engineering groups for iterative, high-quality product delivery within short timeframes. However, Scrum teams face persistent challenges in achieving these objectives, stemming from difficulties in seamless collaboration and effective communication among various roles, such as developers and testers. To address these issues, Scrum teams are increasingly adopting Behaviour-Driven Development (BDD), a testing technique fostering collaboration and shared understanding through test scenarios. ObjectivesThis research investigates the adoption of BDD practices in Scrum teams and the formulation of a metrics framework tailored for optimizing Scrum practices and product quality. MethodsEmploying action research, this study extends over two and half years, actively engaging Scrum team members and stakeholders to encompass their collaborative contributions, insights, and perspectives. It commences with defining a metrics framework through exploration within agile teams to measure and evaluate Scrum team performance. Subsequently, the focus shifts to implementing BDD practices systematically, employing training sessions, workshops, and iterative refinements. ResultsThe results of the study emphasize the substantial role of Behaviour-Driven Development (BDD) in improving collaboration, communication, and the comprehension of requirements within the Scrum team. Concurrently, the tailored metrics framework bolsters quality assurance practices, enhancing software quality and customer satisfaction. BDD adoption expedites automation and product delivery, while the metrics framework enables informed decision-making. ConclusionsCombining BDD practices with a custom metrics framework offers a holistic strategy for addressing Scrum challenges. Enhanced collaboration, communication, and requirements comprehension, resulting from BDD, synergize with the metrics framework to elevate Scrum teams' performance, software quality, and customer value. This research underlines the importance of adopting BDD as a testing methodology to achieve these improvements in Scrum teams.

A type system for formal verification of cyber-physical systems C/C++ software

The subject: This study focuses on improving the quality of Cyber-Physical System (CPS) software by eliminating incorrect usage of units of measurement and orientation in C/C++ programs. Incorrect usage often leads to critical errors that conventional systems cannot effectively prevent. Manual examination of code using dimensional and orientation analysis can detect these errors in physical equations, but these methods become impractical when dealing with complex physical computations. Objectives: As suggested by Siano, the proposed approach uses physical quantities and prefixes defined by the International System of Units and orientation operations on physical objects. The elaborated system incorporates dimensional and orientation analysis and metaprogramming techniques. The methods used are dimensional & orientational analysis and metaprogramming. The following results were obtained: ensuring consistency of the units, incorporating orientation operations into the programming model for accurately handling physical object rotations and alignments, and using Siano’s work to precisely manipulate object orientation, thereby reducing the likelihood of orientation-related errors. Checking physical dimensions and orientations during the compilation stage identifies potential software defects before code execution, thereby reducing debugging time and lowering the cost of addressing issues later in development. The elaborated system represents a crucial step towards safer and more dependable Cyber-Physical System applications. This approach allows us to identify approximately 90% of incorrect usage of program variables; additionally, it detects over 50% of erroneous operations during compilation and execution of large-scale programs in real-world conditions. Conclusions. Scientific novelty: it proposed and developed a specialized C++-type library for formal compile-time software verification of Cyber-Physical Systems software. The proposed C++-type library leverages dimensional and orientational analysis to enhance software quality, reliability, and real-time formal verification. Although the proposed method for formal verification is not tailor-made for cyber-physical objects and systems, given its primary focus on software-level concerns, it does exhibit adaptability for verifying general-purpose software that incorporates various physical parameters. This versatility extends to diverse domains such as educational, gaming, and simulation software.

Revisiting Code Smell Severity Prioritization using learning to rank techniques

Code Smell Severity Prioritization (CSSP) is crucial in helping software developers minimize software maintenance costs and enhance software quality, particularly when faced with limited refactoring resources. Traditional code smell prioritization methods rely heavily on manual and semi-automatic approaches based on developer experience, often demanding considerable time and effort from experienced experts. Leveraging automated machine learning techniques can effectively overcome these limitations. However, most existing machine learning-based CSSP works have only considered limited pointwise Learning To Rank (LTR) algorithms and have used inappropriate metrics (e.g., Accuracy, Spearman, and MAE) to assess the performance of models. To address these limitations, we make a comprehensive comparison of 41 pointwise, 4 pairwise, and 4 listwise LTR algorithms for CSSP on four code smell severity datasets. Furthermore, we propose the adoption of Severity@20% and Cumulative Lift Chart (CLC) as the primary evaluation metrics to assess CSSP models more effectively. The results show that: (1) The ordinal Bagging (O-Bagging) algorithm demonstrates the highest performance for CSSP, achieving superior results in Severity@20% and CLC. (2) The ordinal classification method can help the top-performing base classification algorithms Bagging and XGBoost achieve better performance for CSSP tasks. (3) A higher (lower) Accuracy, higher (lower) Spearman, and lower (higher) MAE do not reliably indicate better (worse) performance for CSSP. This further underscores that Accuracy, Spearman, and MAE are unsuitable metrics for evaluating CSSP models’ effectiveness. To summarize, our study suggest that developers employ the O-Bagging algorithm for CSSP, with Severity@20% and CLC serving as the primary evaluation metrics.

Enhancing Software Quality through Early-Phase of Software Verification and Validation Techniques

Purpose: The core objectives of this conducted research were threefold: first, to assess whether early-phase verification and validation (V&V)techniques, encompassing software design review, code review, and inspection, significantly contribute to defect prevention throughout the software development process; second, to evaluate the impact of these techniques on the efficiency of software development in terms of time, cost, and resource allocation; and third, to conduct a comprehensive comparative analysis between early-phase verification and validation (V&V)techniques and traditional post-development testing regarding their effectiveness in defect prevention and software quality improvement.
 Methodology: Employing an experimental approach, this study conducted case studies within Tanzanian software development organizations. Data were meticulously gathered through surveys and interviews involving software professionals. Both quantitative and qualitative data were systematically analyzed to ensure data reliability and ethical considerations.
 Findings: The research findings indicate that early-phase verification and validation (V&V) techniques shine as powerful tools for defect prevention, leading to a substantial reduction in defect counts and elevating software quality metrics, such as reliability and user satisfaction. Notably, these techniques demonstrated a favorable impact on software development efficiency by shortening development cycles and curtailing costs. When compared to traditional post-development testing, early-phase verification and validation (V&V) techniques consistently outperformed in the realm of defect prevention and software quality enhancement.
 Unique Contribution to Theory, Practice and Policy: The study's outcomes underscore the transformative potential of early-phase verification &validation techniques, urging the software development industry to pivot from defect detection to defect prevention. The insights garnered here offer practical guidance for organizations aiming to streamline their software development processes, economize costs, and deliver top-notch software products that closely align with user expectations. While conducted in a Tanzanian context, these findings reverberate across the global software development landscape, underscoring the universal relevance of early-phase verification and validation (V&V) techniques as pivotal enablers of software quality assurance and operational efficiency.

Principles of autonomous testing of high-performance .NET application

In the landscape of software development for high-performance .NET applications, autonomous testing emerges as a critical strategy to ensure reliability, scalability, and performance. This article delves into the practice of autonomous, or unattended, testing—where automated test cases are executed independently without human intervention. Our exploration is grounded in the application of autonomous testing in environments handling large data volumes and supporting high concurrency, which are typical scenarios for mission-critical .NET applications. We discuss the benefits of autonomous testing, including its ability to significantly increase test coverage, enhance defect detection at early stages, and ensure consistent and reliable testing outcomes across various scenarios. The implementation of robust testing frameworks such as NUnit, xUnit, or MSTest, which support features like parallel test execution and test parameterization, plays a foundational role in the effective deployment of autonomous testing systems. Moreover, the article highlights the necessity of integrating autonomous testing into continuous integration and deployment pipelines to facilitate continuous testing. This integration ensures that every code change is thoroughly validated before deployment, thereby enhancing software quality and accelerating delivery cycles. We also examine the challenges and best practices in fostering a culture that supports autonomous testing within organizations. By emphasizing the strategic importance of training, cross-functional collaboration, and continuous improvement, we propose methods to overcome resistance to change and enhance the adoption of autonomous testing practices.

Boosting Software Fault Prediction: Addressing Class Imbalance With Enhanced Ensemble Learning

Software fault prediction (SFP) is a crucial aspect of software engineering, aiding in the early identification of potential defects. This proactive approach significantly contributes to enhancing software quality and reliability. However, a common challenge in SFP is class imbalance (CI). Ensemble learning (EL) is a powerful strategy for refining SFP models in object‐oriented systems with imbalanced data and improving sensitivity to minority classes. This study aimed to improve the effectiveness of ensemble classes in SFP within object‐oriented systems, tackling the challenges associated with imbalanced data. It focuses on enhancing the performance of three ensemble classifiers, BalancedBagging, RUSBoost, and EasyEnsemble, explicitly designed for imbalanced datasets. In Enhanced_BalancedBagging (E_BB) and ROSBoost, random undersampling (RUS) is substituted with random oversampling (ROS). Meanwhile, Enhanced_EasyEnsemble (E_EE) replaces RUS with ROS and AdaBoost with XGBoost. The experimental results demonstrate the superior performance of E_BB, ROSBoost, and E_EE over their base models, achieving the highest F‐measure, balanced accuracy, and AUC. Statistical tests, such as the Wilcoxon signed‐rank test, provide robust support for the enhanced models, highlighting their practical significance through substantial improvements in F‐measure and AUC, as indicated by low negative rank sums and large effect sizes.