Search

Software reliability is a far more important factor that influences quality of the software. Software bug identification is a critical aspect of software development method. Software reliability is greatly impacted by the existence of defects in the software, so must anticipate bugs in software. Nevertheless, software bug detection may be insufficiently accurate for practical application, and wide benefits of various may be used. To address these concerns, Modified Deep Neural Network (MDNN) is suggested for predicting software defects. Initially, raw data's are collected and pre-processed by using min–max normalisation that reorganises the data as in database. Then, utilizing principal component evaluation for reduce the dimensionality of pre-processed data. After reducing dimension select appropriate features using correlation based Fuzzy C-means Clustering Method (FCM). First, unnecessary characteristics are removed employing FCM, and then non-redundant features were extracted from every cluster utilising correlations value. After that selected features are given as an input for MDNN. MDNN is developed through optimal selection of weight parameter using Reptile Search Optimization (RSA) algorithm providing error as fitness. Finally, classifier predict bugs in software module which is used to improve software reliability performance is achieved. According to the simulation study, the proposed method achieves 98% accuracy, 0.02% error, 95% specificity, 90% recall, and 95% precision. This indicates that the proposed approach performs better than all prior options. Based on this proposed classification bugs are predicted and software reliability performance is improved. [ABSTRACT FROM AUTHOR]

Software engineering workflows use version control systems to track changes and handle merge cases from multiple contributors. This has introduced challenges to testing because it is impractical to test whole codebases to ensure each change is defect-free, and it is not enough to test changed files alone. Just-in-time software defect prediction (JIT-SDP) systems have been proposed to solve this by predicting the likelihood that a code change is defective. Numerous techniques have been studied to build such JIT software defect prediction models, but the power of pre-trained code transformer language models in this task has been underexplored. These models have achieved human-level performance in code understanding and software engineering tasks. Inspired by that, we modeled the problem of change defect prediction as a text classification task utilizing these pre-trained models. We have investigated this idea on a recently published dataset, ApacheJIT, consisting of 44k commits. We concatenated the changed lines in each commit as one string and augmented it with the commit message and static code metrics. Parameter-efficient fine-tuning was performed for 4 chosen pre-trained models, JavaBERT, CodeBERT, CodeT5, and CodeReviewer, with either partially frozen layers or low-rank adaptation (LoRA). Additionally, experiments with the Local, Sparse, and Global (LSG) attention variants were conducted to handle long commits efficiently, which reduces memory consumption. As far as the authors are aware, this is the first investigation into the abilities of pre-trained code models to detect defective changes in the ApacheJIT dataset. Our results show that proper fine-tuning improves the defect prediction performance of the chosen models in the F1 scores. CodeBERT and CodeReviewer achieved a 10% and 12% increase in the F1 score over the best baseline models, JITGNN and JITLine, when commit messages and code metrics are included. Our approach sheds more light on the abilities of language models in software engineering tasks, promoting their use in production environments and ensuring that deployed software is defect-free efficiently. [ABSTRACT FROM AUTHOR]

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. [ABSTRACT FROM AUTHOR]

Refactoring is a well-established topic in contemporary software engineering, focusing on enhancing software's structural design without altering its external behavior. Commit messages play a vital role in tracking changes to the codebase. However, determining the exact refactoring required in the code can be challenging due to various refactoring types. Prior studies have attempted to classify refactoring documentation by type, achieving acceptable results in accuracy, precision, recall, F1-Score, and other performance metrics. Nevertheless, there is room for improvement. To address this, we propose a novel approach using four ensemble Machine Learning algorithms to detect refactoring types. Our experimentation utilized a dataset containing 573 commits, with text cleaning and preprocessing applied to address data imbalances. Various techniques, including hyperparameter optimization, feature engineering with TF-IDF and bag-of-words, and binary transformation using one-vs-one and one-vs-rest classifiers, were employed to enhance accuracy. Results indicate that the experiment involving feature engineering using the TF-IDF technique outperformed other methods. Notably, the XGBoost algorithm with the same technique achieved superior performance across all metrics, attaining 100% accuracy. Moreover, our results surpass the current state-of-the-art performance using the same dataset. Our proposed approach bears significant implications for software engineering, particularly in enhancing the internal quality of software. [ABSTRACT FROM AUTHOR]

Software fault prediction aims to improve software quality by anticipating faults early in the software development process. It is possible to anticipate software faults with the aid of specific machine learning techniques. However, certain conventional learning techniques may struggle with the datasets' uneven class distribution since they are more skewed toward the non-faulty class and produce inaccurate prediction results. It becomes more complicated when there is a presence of noise in imbalanced datasets. Fixing these data quality concerns is crucial for improving the classifier's output. Existing under-sampling algorithms have the limitation of not addressing the elimination of noisy occurrences prior to the under-sampling technique, which may lead to the loss of valuable data. To remove noisy instances from majority classes and prevent the loss of important data from the majority of instances, clustering using a graph-based under-sampling technique is applied. This paper proposes an improved DBSCAN-based Induced graph under-sampling method (IDBIG-US), which comprises Density-Based Spatial Clustering Applications with Noise (DBSCAN) to filter noisy instances and ShapeGraph to deal with imbalanced classes. 19 benchmark datasets from the PROMISE repository are used in the experiment to demonstrate the effectiveness of the proposed method. The proposed method effectively eliminates noise and improves the classifier's performance. The experimental results and statistical analysis indicate that the proposed method outperforms state-of-the-art methods with respect to Area Under the Curve (AUC), G-mean, Recall (PD), Probability of False alarms (PF), Point of Predictive Task (Popt), and Area Under the Cumulative Count Curve (ACC). [ABSTRACT FROM AUTHOR]

In the industrial Internet, industrial software plays a central role in enhancing the level of intelligent manufacturing. It enables the promotion of digital collaborative services. Effective anomaly detection of multivariate time series can ensure the quality of industrial software. Extensive research has been conducted on time series anomaly detection to identify abnormal data. However, detecting anomalies in multivariate time series, which consist of high-dimensional, high-noise, and random data, poses significant challenges. The states of different timestamps within a time series sample can influence the overall correlation of sensor features. Unfortunately, existing methods often overlook this impact, making it difficult to capture subtle variations in the delayed response of attacked sensors.Consequently, there are false alarms and abnormal omissions. To address these limitations, this paper proposes an anomaly detection method called DGINet. DGINet leverages a dynamic graph attention network and Informer to capture and integrate feature correlation across different time states. By combining GRU and Informer, DGINet effectively captures continuous correlations in long time series. Moreover, DGINet simultaneously optimizes the reconstruction and forecasting modules, enhancing its overall performance. Experimental results on four benchmark datasets demonstrate that DGINet outperforms state-of-the-art methods by achieving up to a 2 % improvement in accuracy. Further analysis reveals that DGINet excels in accurately detecting anomalies in long time series and locating candidate abnormal attack points. [ABSTRACT FROM AUTHOR]

As information technology continues to advance, software applications are becoming increasingly critical. However, the growing size and complexity of software development can lead to serious flaws resulting in significant financial losses. To address this issue, Software Defect Prediction (SDP) technology is being developed to detect and resolve defects early in the software development process, ensuring high software quality. As a result, SDP research has become a major focus for academics worldwide. This study aims to compare various machine learning-based SDP algorithm models and determine if traditional machine learning algorithms affect SDP outcomes. Unlike previous studies that aimed to identify the best prediction model for all datasets, this paper constructs SDP superiority models separately for different datasets. Using the publicly available ESEM2016 dataset, 13 machine learning classification algorithms are employed to predict software defects. Evaluation indicators such as Accuracy, AUC(Area Under the Curve), F-measure, and Running Time(RT) are utilized to assess the performance of the classification algorithms. Due to the serious class imbalance problem in this dataset, 10 sampling methods are combined with the 13 machine learning algorithms to explore the effect of sampling techniques on the performance of traditional machine learning classification models. Finally, a comprehensive evaluation is conducted to identify the best combination of sampling techniques and classification models to construct the final dominant model for SDP. [ABSTRACT FROM AUTHOR]

Software inspection is a widely-used approach to software quality assurance. Human-Machine Pair Inspection (HMPI) is a novel software inspection technology proposed in our previous work, which is characterized by machine guiding programmers to inspect their own code during programming. While our previous studies have shown the effectiveness of HMPI in telling risky code fragments to the programmer, little attention has been paid to the issue of how the programmer can be effectively guided to carry out inspections. To address this important problem, in this paper we propose to combine Risk Number with Code Inspection Diagram (CID) to provide accurate guidance for the programmer to efficiently carry out inspections of his/her own programs. By following the Code Inspection Diagram, the programmer will inspect every checking item shown in the CID to efficiently determine whether it actually contain bugs. We describe a case study to evaluate the performance of this method by comparing its inspection time and number of detected errors with our previous work. The result shows that the method is likely to guide the programmer to inspect the faulty code earlier and be more efficient in detecting defects than the previous HMPI established based on Cognitive Complexity. [ABSTRACT FROM AUTHOR]

Model transformation, which is a program targeting at transforming an input model to an output model, has been a critical basis for Model-Driven Engineering (MDE). The quality of model transformation programs directly affects the quality of software products built with MDE activities. Therefore, debugging model transformation programs has been crucial from the quality assurance point of view. One of the key impediments to the model transformation debugging is the high complexity and scale of the input models. In order to ameliorate the burden on model transformation debugging, this study proposes an effective approach to systematically reduce input models of model transformation programs. By combining the advantages of input simplification approaches for traditional programs and also the characteristics of model transformation, our approach leverages and adapts the delta debugging technique to model simplification. We conduct experiments to evaluate the proposed approach from two aspects: its effectiveness in model simplification, and its effects on model transformation debugging. Our experimental results confirm the positive contributions of the approach in both aspects. It delivers promising reduction effectiveness, and it can also well support the fault localization in model transformations. [ABSTRACT FROM AUTHOR]

Sustainability in systems refers to applying sustainable principles and practices to create more resilient, efficient, and equitable systems that promote the well-being of people and the planet. Sustainability is an essential topic in contemporary software engineering, and its relationship with the characteristics and properties of a system or product called quality attributes is still an open question since each researcher has established their definition of sustainability in software. This has created diverse terms and concepts for distinct application environments and scopes, creating ambiguity and misconceptions. This work defines a domain ontology of Sustainability in Software named SinSO to address these issues. SinSO was implemented in OWL, using competency-based questions to validate. The findings show that this proposal satisfies several quality and content requirements. Also, using Protégé and the Hermit reasoner, we verified that SinSO is consistent since the ontology statements are coherent and do not lead to conflicting or contradictory conclusions. In addition, competency questions allowed us to demonstrate that SinSO does fulfill its purpose. FOCA methodology allowed us to evaluate SinSO quality. Also, SinSO was used in two case studies, one about software for senior-citizen smart-home, and the other, a simulator to develop and test smart-city applications, achieving positive outcomes. To verify its accuracy, completeness, and maintainability, further evaluations of SinSO are needed in real case studies. We conclude that SinSO can significantly contribute to reducing ambiguity and enhancing comprehension in this area. Furthermore, SinSO can be an effective tool for engineers to recognize the concepts and relationships in the sustainable domain to consider in the systems development life cycle to build sustainable systems. [ABSTRACT FROM AUTHOR]

Currently, the lack of physical activity can lead to health problems, with the increase in obesity in children between 8 and 18 years old being of particular interest because it is a formative stage. One of the aspects of trying to solve this problem is the need for a standardized, less subjective, and more efficient method of evaluating physical condition in these children compared to traditional approaches. Objective: Develop a multiplatform based on computer vision technology that allows the evaluation of the physical fitness of schoolchildren using smartphones. Methodology: A descriptive cross-sectional study was carried out on schoolchildren aged 8 to 18 years of both sexes. The sample was 228 schoolchildren (128 boys and 108 girls). Anthropometric measurements of weight, height, and waist circumference were evaluated. Body mass index (BMI) was calculated. Four physical tests were evaluated: flexibility (sit and reach), horizontal jump (explosive strength), biceps curl (right arm strength resistance), and sit-ups (abdominal muscle resistance). With the information collected traditionally and by filming the physical tests, a computer vision system was developed to evaluate physical fitness in schoolchildren. Results: The implemented system obtained an acceptable level of precision, reaching 94% precision in field evaluations and a percentage greater than 95% in laboratory evaluations for testing. The developed mobile application also obtained a high accuracy percentage, greater than 95% in two tests and close to 85% in the remaining two. Finally, the Systematic Software Quality Model was used to determine user satisfaction with the presented prototype. Regarding usability, a satisfaction level of 97% and a reliability level of 100% was obtained. Conclusion: Compared to traditional evaluation and computer vision, the proposal was satisfactorily validated. These results were obtained using the Expanded Systematic Software Quality Model, which reached an "advanced" quality level, satisfying functionality, usability, and reliability characteristics. This advance demonstrates that the integration of computer vision is feasible, highly effective in the educational context, and applicable in the evaluations of physical education classes. [ABSTRACT FROM AUTHOR]

When creating a software model, it is necessary that it accurately captures the desired behaviour, while at the same time ensuring that any undesired behaviour is excluded. On the one hand, formal verification tools can be used to check the internal consistency of a software system, ensuring that the behaviour of one software component does not contradict another. On the other hand, software testing is essential to check the external validity of the model more comprehensively. Unfortunately, software testing is often overlooked in curricula, resulting in graduates with inadequate software testing skills for industry. Software testing tools such as TesCaV can be used to help teachers teach software testing topics in a non-intrusive and less time-consuming way. Previous research has shown that TesCaV is easy to use and that novice users produce better quality software tests when using TesCaV. However, it has remained unclear whether learners retain the skills they gain from using TesCaV even when the tool is not offered for help. In order to understand the positive effect of TesCaV on learners' software testing skills, this study conducted an experiment with 45 participants. The experiment used a pretest-treatment-posttest design. The results show that participants feel equally confident about the completeness of their test coverage, even though they identify more test cases. It is concluded that for course design, a capsule such as TesCaV can help students to understand the full complexity of software testing and help them to be more systematic in their approach. [ABSTRACT FROM AUTHOR]

The quality of software test data is assessed through mutation testing. This technique involves introducing various modifications (mutants) to the original code of the program. The test data's effectiveness, known as the test score, is quantified by the proportion of mutants that are successfully detected. A prominent issue within software mutation testing is the generation of an excessive quantity of mutants in programs. The primary objectives of this research are to diminish the total count of mutants by consolidating those that are duplicative, to decrease the overall mutation testing time by lessening the quantity of mutants produced, and to lower the expenses associated with mutation testing. This research introduces a machine learning-based strategy to recognise and eliminate redundant mutants. Building a machine learning-based classifier to classify the instructions according to the rate of error propagation is the first contribution of this study. Next, the remaining instructions of the source code are analyzed by the designed parser to generate single-line mutants. Unlike traditional approaches, mutants are not generated as distinct full-fledged programs. Instead, mutants consisting of a single line are selectively run using a developed instruction evaluator. Following this, a clustering technique is employed to categorise single-line mutants yielding identical outcomes into groups, where only one complete execution is needed per group. Testing on Java benchmarks with the new method has shown a decrease in the mutant count by 56.33% and a time reduction of 56.71% when compared with parallel tests using the MuJava and MuClipse tools. Despite the marked decrease in both mutant count and testing time, the mutation score remained consistent. Comparable outcomes were also observed with other mutation testing tools such as Pitest, Jester, Jumble, and JavaLancer. [ABSTRACT FROM AUTHOR]

Quality and productivity needs are considered together in software. For this reason, any existing software should be tested automatically with test automation. Software test automations is automated software testing activities. Automating constantly manually written tests, on the other hand, saves time, reduces error rates, produces better quality software, and reduces costs. This study aims to produce an automatic unit testing framework that is planned to work in run-time on software products. This developed application performs unit test transformations that can respond to the desired test scenarios on the product being studied.. Java agent is used as the basis of all these transformations. All information about the objects, methods, and variables of the sample java classes to be worked on is converted into data in run-time using byte code. During this transformation, information is saved in the database, and unit tests are created automatically through the template engine. Compared to the products developed on automatic unit test generation in the literature, the opcode parsing method was developed for this study. This method reads a byte code at run-time, uses the properties of the java class it belongs to, and automatically creates the unit test class and test methods. The study can also examine different object definitions and conditional and loop structures within a method and produce alternative test scenarios. The automatic unit test scenario produced has been turned into a flexible framework that can encounter minimum errors at run-time. Considering the scarcity of studies in the field of national software testing; It is thought that the automatic unit test generation product developed within the scope of this study, using byte code, will contribute to the work area. [ABSTRACT FROM AUTHOR]

Software managers constantly look out for methods that ensure cost effective development of good quality software products. An important means of accomplishing this is by allocating more resources to weak classes of a software product, which are prone to changes. Therefore, correct prediction of these change‐prone classes is critical. Though various researchers have investigated the performance of several algorithms for identifying them, the search for an optimum classifier still persists. To this end, this study critically investigates the use of six Heterogenous Ensemble Classifiers (HEC) for Software Change Prediction (SCP) by empirically validating datasets obtained from 12 open‐source software systems. The results of the study are statistically assessed using three robust performance indicators (AUC, F‐measure and Mathew Correlation Coefficient) in two different validation scenarios (within project and cross‐project). They indicate the superiority of Average Probability Voting Ensemble, a heterogenous classifier for determining change‐proneness in the investigated systems. The average AUC values of software change prediction models developed using this ensemble classifier exhibited an improvement of 3%‐9% and 3%‐11% respectively when compared with its base learners and homogeneous counter parts. Similar observations were inferred using other investigated performance measures. Furthermore, the evidence obtained from the results suggests that the change in number of base learners or type of meta‐learner does not exhibit significant change in the performance of corresponding heterogenous ensemble classifiers. [ABSTRACT FROM AUTHOR]

The software development life cycle relies heavily on the software release note, a crucial document. Various practitioners, including project managers and clients, benefit from release notes as they provide an overview of the latest software release. However, the manual generation of release notes is a time‐consuming and stressful task. Researchers have recently proposed automated techniques to generate release notes, saving developers' time and enhancing their understanding of software projects. Unfortunately, the adoption of these tools in practice remains limited. To address this gap, we have taken steps to understand the expectations and requirements of practitioners regarding release note generation techniques before implementing new automated approaches. Consequently, our approach involves two main stages: First, we conduct a comprehensive review of the relevant literature and analyze existing release notes from GitHub repositories to gain insights into the current practices. Second, we conduct an online survey study to gather input from practitioners and understand their expectations regarding release notes. We have reviewed 16 papers related to release notes and explored 3347 release notes from 21 GitHub repositories. Our analysis revealed key artifacts present in release note contents, including issues (29%), pull requests (32%), commits (19%), and common vulnerabilities and exposures (CVE) issues (6%). Additionally, we conducted a survey study involving 32 professionals to understand the essential information that should be included in release notes based on users' roles. For instance, project managers were more interested in learning about new features rather than less critical bug fixes. Furthermore, we identified gaps in existing systems and essential factors to consider when implementing release notes techniques in software engineering. The insights gained from our study can guide future research directions and assist practitioners in generating release notes with relevant content, thus improving the overall quality of documentation in software development. [ABSTRACT FROM AUTHOR]

The software industry is evolving at a rapid pace, making it necessary to optimize efforts and accelerate the software development process. Software can be reused to achieve quality and productivity goals. Reusability is a crucial measure that can be used to increase the overall level of software quality in less time and effort. To better understand the necessity of enhancing the software reusability of ObjectOriented (O-O) systems, this study employed a semi-automated approach to measure the values of classlevel software metrics on an input dataset collected from the MAVEN repository. This paper explored several previous studies, data strategies, and tools to predict reusability in O-O software systems. This study compares various data mining techniques to identify the most suitable approach for enhancing the reusability of O-O software systems. The analysis was based on performance parameters such as precision, MSE, and accuracy rates. Due to its higher precision and lower MSE, the SOM technique is considered one of the top data mining approaches to increase the reusability of O-O software systems. However, the results show that the different levels of reusability in O-O software systems are not adequately addressed in current solutions. [ABSTRACT FROM AUTHOR]

In software that is free from defects or errors, a fixed method and technique of software testing is required. For this step, an Information System is needed to help eliminate software defects, so that testing or testing work is not a burden on software costs but is a perfection of software development work so that Zero Defect Application Software can be realized. From several software testing methods and techniques, a strategy suitable for the size of a software development project is required. So even though the software development project is small, it still requires a suitable test. And for software development testing to have reliable quality, it is necessary to measure and criteria for each software testing practice, so that a software development project can be determined in quality. To support software testing work, an Information System is needed that supports the need for processors to assess a quality software development test. With the Software Defect Elimination Information System, an objective quality of software development testing can be produced. [ABSTRACT FROM AUTHOR]

Measurement, which can be done directly or indirectly, is the process of providing a quantitative indication of the scope, quantity, dimension, capacity, or characteristics of a process or product. Software may be measured directly in a number of ways, such as cost, effort, amount of code lines, functionality, speed of execution, memory size, documentation, number of inputs and outputs, and flaws in individual units. In contrast, features like functionality, efficiency, dependability, and maintainability are measured by indirect metrics like software quality. A metric is a quantitative measure of the degree of an attribute of an object, system, or process that is produced by the gathering of data for measurement. These metrics need to be gathered and converted into indicators in order to assess the quality of the program. Metrics, or sets of metrics, known as indicators, give management thorough information about a product and aid in process and product control. A system is made up of several interrelated parts that work together to accomplish a certain objective. These systems are broken down into more manageable subsystems that assist the main system. This research seeks to examine how software quality is measured on Marshal Suryadarma Aerospace University's Academic Information System. In addition to helping university administration regulate and enhance the information systems in use, this research is anticipated to offer a thorough grasp of the application of metrics and indicators in assessing and enhancing the caliber of academic software. [ABSTRACT FROM AUTHOR]

In software, competition in producing high-quality products has become a prominent factor for business success. In this regard, identifying and defining software quality metrics (SQM) to discover and continuously enhance current quality systems is very important. However, it is advisable to study and review current studies in this field, so that it is possible to analyze the current situation, and it also enables us to formulate expectations regarding future research areas. This research is concerned with studying and analyzing a large number of articles, focusing on the research literature published over the past decade. 70 research papers, articles, and conference papers were selected and analyzed, published from 2009 to 2023. A detailed description of these researches and their titles SQM was conducted. We used graphics, explanations, and structure design to display the results. The outputs from this research indicate the underlying knowledge in this field and the measurement mechanism and include trends between 2009 and 2023 and the gaps that are supposed to be available for study and development in this field. The study and analysis of articles aim to review studies, direct future studies, and focus on system development. Future studies encourage the adoption of quality metrics. Quality metrics include several areas of development systems, including network performance, and the Cloud of Things, which directs the adoption of more accurate metrics and components reusability, artificial intelligence, model performance, and predictive capacity metrics. [ABSTRACT FROM AUTHOR]

Summary: To ensure the quality of software systems, software engineers can make use of a variety of quality assurance approaches, for example, software testing, modern code review, automated static analysis, and build automation. Each of these quality assurance practices have been studied in depth in isolation, but there is a clear knowledge gap when it comes to our understanding of how these approaches are being used in conjunction, or not. In our study, we broadly investigate whether and how these quality assurance approaches are being used in conjunction in the development of 1454 popular open source software projects on GitHub. Our study indicates that typically projects do not follow all quality assurance practices together with high intensity. In fact, we only observe weak correlation among some quality assurance practices. In general, our study provides a deeper understanding of how existing quality assurance approaches are currently being used in Java‐based open source software development. Besides, we specifically zoom in on the more mature projects in our dataset, and generally we observe that more mature projects are more intense in their application of the quality assurance practices, with more focus on their ASAT usage, and code reviewing, but no strong change in their CI usage. [ABSTRACT FROM AUTHOR]

Code smells refer to poor design and implementation choices by software engineers that might affect the overall software quality. Code smells detection using machine learning models has become a popular area to build effective models that are capable of detecting different code smells in multiple programming languages. However, the process of building of such effective models has not reached a state of stability, and most of the existing research focuses on Java code smells detection. The main objective of this article is to propose dynamic ensembles using two strategies, namely greedy search and backward elimination, which are capable of accurately detecting code smells in two programming languages (i.e., Java and Python), and which are less complex than full stacking ensembles. The detection performance of dynamic ensembles were investigated within the context of four Java and two Python code smells. The greedy search and backward elimination strategies yielded different base models lists to build dynamic ensembles. In comparison to full stacking ensembles, dynamic ensembles yielded less complex models when they were used to detect most of the investigated Java and Python code smells, with the backward elimination strategy resulting in less complex models. Dynamic ensembles were able to perform comparably against full stacking ensembles with no significant detection loss. This article concludes that dynamic stacking ensembles were able to facilitate the effective and stable detection performance of Java and Python code smells over all base models and with less complexity than full stacking ensembles. [ABSTRACT FROM AUTHOR]

Software reliability modeling, as a non-functional characteristic of software quality to achieve high reliability, is of particular importance. To obtain software systems with high reliability, it is important to select the best scenario, from the various scenarios produced, in a short time during the software design stage. Since the scenario includes interactions between the user and use case, producing various scenarios and selecting the best among them in terms of reliability is a difficult and time-consuming task for software designers. Therefore, it is of great importance to use a modeling language that has a tool-based evaluation modeling approach and does the analysis automatically. In this paper, Alloy modeling language has been used to model and analyze software reliability. Compared to other lightweight modeling languages, Alloy has such advantages as being more concise, accurate and abstract. The primary objective of this paper aims to present a modeling framework based on the Alloy modeling language with which reliability of target systems can be efficiently examined. The results indicate that the use of Alloy analyzer facilitates the immediate production of various scenarios and allows for the selection of the best one in terms of reliability. [ABSTRACT FROM AUTHOR]

Mass spectral libraries have proven to be essential for mass spectrum annotation, both for library matching and training new machine learning algorithms. A key step in training machine learning models is the availability of high-quality training data. Public libraries of mass spectrometry data that are open to user submission often suffer from limited metadata curation and harmonization. The resulting variability in data quality makes training of machine learning models challenging. Here we present a library cleaning pipeline designed for cleaning tandem mass spectrometry library data. The pipeline is designed with ease of use, flexibility, and reproducibility as leading principles. Scientific contribution This pipeline will result in cleaner public mass spectral libraries that will improve library searching and the quality of machine-learning training datasets in mass spectrometry. This pipeline builds on previous work by adding new functionality for curating and correcting annotated libraries, by validating structure annotations. Due to the high quality of our software, the reproducibility, and improved logging, we think our new pipeline has the potential to become the standard in the field for cleaning tandem mass spectrometry libraries. [ABSTRACT FROM AUTHOR]

Blood flow restriction training (BFRT) is an effective, scientific and safe training method, but its effect on the overall quality of athletes remains unclear. The aim of this systematic review with meta-analysis was to clarify the effects of BFRT on the physical fitness among athletes. Based on the PRISMA guidelines, searches were performed in PubMed, Web of Science, SPORTDiscus, and SCOUPS, the Cochrane bias risk assessment tool was used to assess methodological quality, and RevMan 5.4 and STATA 15.0 software were used to analyze the data. A meta-analysis of 28 studies with a total sample size of 542 athletes aged 14–26 years and assessed as low risk for quality was performed. Our results revealed that the BFRT intervention had small to large improvements in the athletes' strength (ES = 0.74–1.03), power (ES = 0.46), speed (ES = 0.54), endurance (ES = 1.39–1.40), body composition (ES = 0.28–1.23), while there was no significant effect on body mass (p > 0.05). Subgroup analyses revealed that moderator variables (training duration, frequency, load, cuff pressure, and pressurization time) also had varying degrees of effect on athletes' physical fitness parameters. In conclusion, BFRT had a positive effect on the physical fitness parameters of the athletes, with significantly improved strength, power, speed, endurance and body composition, but not body mass parameters. When the training frequency ≥ 3 times/week, cuff pressure ≥ 160 mmHg, and pressurization time ≥ 10 min, the BFRT group was more favorable for the improvement of physical fitness parameters. [ABSTRACT FROM AUTHOR]

To systematically evaluate the intervention effect of music therapy on anxiety and depression in breast cancer patients. Randomised controlled trial (RCT) on music therapy for anxiety and depression in breast cancer patients was searched from 7 major databases, PubMed, Embase, the Cochrane Library, WOS, CNIC, Wanfang, and Wipro, spanning the period of library construction to 23 October 2023, and the literature screening of music therapy for anxiety or depression in breast cancer patients was carried out by 2 experimentalists, each of whom conducted a literature screening RCT independently of the other anxiety or depression in a RCT. Methodological quality was evaluated using the PEDro scale; GRADE profiler software for quality of evidence; and RevMan 5.4 was used for effect size merging and forest plots; publication bias tests and sensitivity analyses were performed using Stata 17.0; and standardized mean difference (SMD) and 95% CI were used as the effect statistics. A total of 13 RCTs with 1326 subjects (aged 18–70 years) were included in the literature, with a mean PEDro score of 6.8, and the literature was overall of good methodological quality. Meta-analysis showed that music therapy improved anxiety in breast cancer patients (841 cases), with a combined effect size (SMD = − 0.82, 95% CI [− 1.03, − 0.61] and P < 0.001); and improved depression in breast cancer patients (387 cases) with a combined effect size (SMD = − 0.76, 95% CI [− 1.15, − 0.38], P < 0.001). Subgroup analyses showed that music intervention with off-site music (757 cases) and music choice of non-self-selected music (537 cases) had the best effect on anxiety improvement, with corresponding combined effect sizes (SMD = − 0.88, P < 0.001; SMD = − 0.83, P < 0.001), respectively; followed by an intervention length of < 30 min (589 cases), a frequency of 2 times/day (382 cases), and intervention period of 2–3 weeks (101 cases) had the best effect on anxiety improvement, and the corresponding combined effect sizes were (SMD = − 0.80, P < 0.001; SMD = − 0.91, P < 0.001; SMD = − 1.02, P < 0.001), respectively; and the music selection was the choice of one's own favourite music among the expert recommendations (219 cases) (270 cases) had the best effect on the improvement of depressed mood, with combined effect sizes of (SMD = − 1.15, P < 0.001; SMD = − 0.71, P < 0.001) and music with an intervention duration of 30 min (287 cases), an intervention frequency of 1 time/day (348 cases), and an intervention period of 2–4 weeks (120 cases), respectively, with corresponding combined effect sizes of (SMD = − 0.75, P < 0.001; SMD = − 0.86, P < 0.001; SMD = − 1.06, P < 0.001), respectively. Music therapy can improve anxiety and depression in breast cancer patients, and the level of evidence is moderate. Although the heterogeneity between studies is high, which may lead to bias in the results, we explored the source of heterogeneity through subgroup and sensitivity analyses, providing a good evidence-based basis for clinical practice. The heterogeneity of anxiety and depression was explored by subgroup analysis, with anxiety due to music duration and music cycle; and depression due to intervention cycles and music duration. Sensitivity analyses also identified music duration and music cycle as contributing to the heterogeneity. Also, this study has some limitations since the included literature did not take into account the duration of the disease, education, and family economic status and did not categorize the age stages. This study found that music therapy improves anxiety and depression in breast cancer patients and the results can be used as a basis for clinical practice and researcher enquiry. This research has been registered on the INPLASY platform (https://inplasy.com/contact/) under the number: INPLASY2023100057. [ABSTRACT FROM AUTHOR]

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. [ABSTRACT FROM AUTHOR]

Maintaining quality in software development projects is becoming very difficult because the complexity of modules in the software is growing exponentially. Software defects are the primary concern, and software defect prediction (SDP) plays a crucial role in detecting faulty modules early and planning effective testing to reduce maintenance costs. However, SDP faces challenges like imbalanced data, high-dimensional features, model overfitting, and outliers. Moreover, traditional SDP models lack transparency and interpretability, which impacts stakeholder confidence in the Software Development Life Cycle (SDLC). We propose SPAM-XAI, a hybrid model integrating novel sampling, feature selection, and eXplainable-AI (XAI) algorithms to address these challenges. The SPAM-XAI model reduces features, optimizes the model, and reduces time and space complexity, enhancing its robustness. The SPAM-XAI model exhibited improved performance after experimenting with the NASA PROMISE repository's datasets. It achieved an accuracy of 98.13% on CM1, 96.00% on PC1, and 98.65% on PC2, surpassing previous state-of-the-art and baseline models with other evaluation matrices enhancement compared to existing methods. The SPAM-XAI model increases transparency and facilitates understanding of the interaction between features and error status, enabling coherent and comprehensible predictions. This enhancement optimizes the decision-making process and enhances the model's trustworthiness in the SDLC. [ABSTRACT FROM AUTHOR]

Software is a part of most complex systems used for different purposes in today's world. The reliability of these systems must be verified before putting them to use, because their malfunction may lead to catastrophic failure, the loss of human lives, or huge costs. Software reliability can be verified by performing black‐box testing, without knowledge of the complex internal structure of these systems. In this work, an embedded IoT alarm system for detection of intruders and potential robbery is proposed. It is composed of three subsystems: embedded IoT, web‐server, and mobile phone subsystems. Cause‐effect graphing technique was applied for generating three types of black‐box test suites, by using the forward‐propagation and two different minimization algorithms. These test suites were used for black‐box testing the system, which was performed after injecting a maximum of 12 faults into the system in 100 iterations. The resulting software quality and reliability metrics showed that the forward‐propagation algorithm always achieves maximum fault detection rate (FDR), and this algorithm should be used when the highest demand for reliability must be met. The optimized minimization should only be used in cases where testing is very expensive, because it did not find faults in all testing iterations. The basic optimization retained high FDR, while reducing the impact of the minimized test suite and achieved a significant increase of test effect coverage values. [ABSTRACT FROM AUTHOR]

The software is applied in various areas so the quality of the software is very important. The software defect prediction (SDP) is used to solve the software issues and enhance the quality. The robustness and reliability are the major concerns in the existing SDP approaches. Hence, in this paper, the hybrid optimization-based neural network (Optimized NN) is developed for the effective detection of the defects in the software. The two main steps involved in the Optimized NN-based SDP are feature selection and SDP utilizing Optimized NN. The data is fed forwarded to the feature selection module, where relief algorithm selects the significant features relating to the defect and no-defects. The features are fed to the SDP module, and the optimal tuning of NN classifier is obtained by the hybrid optimization developed by the integration of the social spider algorithm (SSA) and gray wolf optimizer (GWO). The comparative analysis of the developed prediction model reveals the effectiveness of the proposed method that attained the maximum accuracy of 93.64%, maximum sensitivity of 95.14%, maximum specificity of 99%, maximum F 1 -score of 93.53%, and maximum precision of 99% by considering the K-fold. [ABSTRACT FROM AUTHOR]

Objective: To improve breast radiographers' individual performance by using automated software to assess the correctness of breast positioning and compression in tomosynthesis screening. Materials and methods: In this retrospective longitudinal analysis of prospective cohorts, six breast radiographers with varying experience in the field were asked to use automated software to improve their performance in breast compression and positioning. The software tool automatically analyzes craniocaudal (CC) and mediolateral oblique (MLO) views for their positioning quality by scoring them according to PGMI classifications (perfect, good, moderate, inadequate) and checking whether the compression pressure is within the target range. The positioning and compression data from the studies acquired before the start of the project were used as individual baselines, while the data obtained after the training were used to test whether conscious use of the software could help the radiographers improve their performance. The percentage of views rated perfect or good and the percentage of views in target compression were used as overall metrics to assess changes in performance. Results: Following the use of the software, all radiographers significantly increased the percentage of images rated as perfect or good in both CCs and MLOs. Individual improvements ranged from 7 to 14% for CC and 10 to 16% for MLO views. Moreover, most radiographers exhibited improved compression performance in CCs, with improvements up to 16%. Conclusion: Active use of a software tool to automatically assess the correctness of breast compression and positioning in breast cancer screening can improve the performance of radiographers. Clinical relevance statement: This study suggests that the use of a software tool for automatically evaluating correctness of breast compression and positioning in breast cancer screening can improve the performance of radiographers on these metrics, which may ultimately lead to improved screening outcomes. Key Points: • Proper breast positioning and compression are critical in breast cancer screening to ensure accurate diagnosis. • Active use of the software increased the quality of craniocaudal and mediolateral oblique views acquired by all radiographers. • Improved performance of radiographers is expected to improve screening outcomes. [ABSTRACT FROM AUTHOR]

Graphical user interface (GUI) testing plays a pivotal role in ensuring the quality and functionality of mobile apps. In this context, exploratory testing (ET), a distinctive methodology in which individual testers pursue a creative, and experience‐based approach to test design, is often used as an alternative or in addition to traditional scripted testing. Managing the exploratory testing process is a challenging task that can easily result either in wasteful spending or in inadequate software quality, due to the relative unpredictability of exploratory testing activities, which depend on the skills and abilities of individual testers. A number of works have investigated the diversity of testers' performance when using ET strategies, often in a crowdtesting setting. These works, however, investigated ET effectiveness in detecting bugs, and not in scenarios in which the goal is to generate a re‐executable test suite, as well. Moreover, less work has been conducted on evaluating the impact of adopting different exploratory testing strategies. As a first step toward filling this gap in the literature, in this work, we conduct an empirical evaluation involving four open‐source Android apps and 20 masters students that we believe can be representative of practitioners partaking in exploratory testing activities. The students were asked to generate test suites for the apps using a capture and replay tool and different exploratory testing strategies. We then compare the effectiveness, in terms of aggregate code coverage that different‐sized groups of students using different exploratory testing strategies may achieve. Results provide deeper insights into code coverage dynamics to project managers interested in using exploratory approaches to test simple Android apps, on which they can make more informed decisions. [ABSTRACT FROM AUTHOR]

Design patterns represent a means of communicating reusable solutions to common problems, provided they are implemented and maintained correctly. However, many design pattern instances erode as they age, sacrificing qualities they once provided. Identifying such instances of pattern decay is valuable because it allows for proactive attempts to extend the longevity and quality attributes of pattern components. Apart from structural decay, design patterns can exhibit symptoms of behavioral decay. We utilized a taxonomy that characterizes these negative behaviors and designed a case study wherein we measured structural and behavioral decay, hereafter referred to as pattern grime, as well as pattern quality and size, across pattern evolutions. We evaluated the relationships between structural and behavioral grime and found statistically significant cases of strong correlations between specific types of structural and behavioral grime. Furthermore, we extended the QATCH operational software quality model to incorporate design pattern evolution metrics and measured and correlated software quality to the presence of behavioral grime in software systems. Our results suggest a strong inverse relationship between software quality and behavioral grime. [ABSTRACT FROM AUTHOR]

Software reliability is a critical aspect of ensuring the quality and dependability of software systems. However, existing software reliability models often make assumptions that do not align with real-world scenarios, such as perfect fault removal and independent faults. In this paper, we address this gap by developing a software reliability model that considers fault-dependent detection, imperfect fault removal, and the maximum number of faults that may present in the system. By accounting for these factors, our proposed model aims to provide a more accurate representation of software reliability. We evaluate the effectiveness of our model by comparing it to existing models using three commonly used goodness-of-fit criteria. The results demonstrate the importance of incorporating these considerations in software reliability modeling and highlight the superiority of our approach in capturing the complexities associated with software faults. Additionally, this paper conducts an analysis of optimal release planning, which yields highly encouraging results for software managers and engineers. This analysis adds significant value to the existing literature, further emphasizing the practical relevance of our proposed model. [ABSTRACT FROM AUTHOR]

Software systems incorporating artificial intelligence (AI) technology are called software 2.0, and their development is spreading in various fields. The purpose of this study is to enable quality engineers to easily evaluate the quality of software 2.0. For this purpose, this paper proposes a quality model that can be used by quality engineers. In order to propose a new quality model for quality engineers, this paper selects and reorganizes quality elements from general-purpose quality models and guidelines, and reconstructs quality characteristics and their evaluation methods. The quality model is considered useful for quality engineers. The paper also identifies important quality characteristics in 24 different application areas and confirms the applicability of the proposed model. The result shows that the model is useful for quality engineers to evaluate the quality of software 2.0. [ABSTRACT FROM AUTHOR]

Software effort estimation presents a significant challenge in the domain of project management. The Constructive Cost Model II (COCOMO II) is frequently applied to estimate the required software project effort. Our study proposed a Constructive Cost Model II with Fuzzy Gaussian and Hunting Grey Wolf Optimization (COCOMO II-FG-HGWO), which improves the accuracy of COCOMO II. Furthermore, the proposed method applies FG to obtain more optimal values of 11 COCOMO II effort multipliers. The GWO hunting mechanism is modified by adding tournament selection to obtain optimal alpha from populations by optimizing COCOMO II coefficients A and B. It helps each alpha explore their search abilities, thereby reducing the risk of being trapped in local optima. The experimental results show that the proposed method reduces MMRE by 0.01% on the NASA 60 dataset and achieves lower values by more than 16% compared to COCOMO II. This indicates that estimated effort is closer to actual effort, and the risk of error in calculating project costs becomes smaller and, in turn, improves the quality of software projects. [ABSTRACT FROM AUTHOR]

(Source) code search is widely concerned by software engineering researchers because it can improve the productivity and quality of software development. Given a functionality requirement usually described in a natural language sentence, a code search system can retrieve code snippets that satisfy the requirement from a large-scale code corpus, e.g., GitHub. To realize effective and efficient code search, many techniques have been proposed successively. These techniques improve code search performance mainly by optimizing three core components, including query understanding component, code understanding component, and query-code matching component. In this article, we provide a 3-dimensional perspective survey for code search. Specifically, we categorize existing code search studies into query-end optimization techniques, code-end optimization techniques, and match-end optimization techniques according to the specific components they optimize. These optimization techniques are proposed to enhance the performance of specific components, and thus the overall performance of code search. Considering that each end can be optimized independently and contributes to the code search performance, we treat each end as a dimension. Therefore, this survey is 3-dimensional in nature, and it provides a comprehensive summary of each dimension in detail. To understand the research trends of the three dimensions in existing code search studies, we systematically review 68 relevant literatures. Different from existing code search surveys that only focus on the query end or code end or introduce various aspects shallowly (including codebase, evaluation metrics, modeling technique, etc.), our survey provides a more nuanced analysis and review of the evolution and development of the underlying techniques used in the three ends. Based on a systematic review and summary of existing work, we outline several open challenges and opportunities at the three ends that remain to be addressed in future work. [ABSTRACT FROM AUTHOR]

Defect prediction is crucial for software quality assurance and has been extensively researched over recent decades. However, prior studies rarely focus on data complexity in defect prediction tasks, and even less on understanding the difficulties of these tasks from the perspective of data complexity. In this article, we conduct an empirical study to estimate the hardness of over 33,000 instances, employing a set of measures to characterize the inherent difficulty of instances and the characteristics of defect datasets. Our findings indicate that: (1) instance hardness in both classes displays a right-skewed distribution, with the defective class exhibiting a more scattered distribution; (2) class overlap is the primary factor influencing instance hardness and can be characterized through feature, structural, and instance-level overlap; (3) no universal preprocessing technique is applicable to all datasets, and it may not consistently reduce data complexity, fortunately, dataset complexity measures can help identify suitable techniques for specific datasets; (4) integrating data complexity information into the learning process can enhance an algorithm's learning capacity. In summary, this empirical study highlights the crucial role of data complexity in defect prediction tasks, and provides a novel perspective for advancing research in defect prediction techniques. [ABSTRACT FROM AUTHOR]

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. [ABSTRACT FROM AUTHOR]

In the all-optical domain, the reflective semiconductor optical amplifier (RSOA) creates due attention in the research community because the RSOA has high gain, low-power consumption, high-speed signal processing ability as well as low noise performance. In this work, we have proposed dibit-based OR and NOR gates using RSOA. Dibit-based logic is utilized in this design to get the reduced bit-error problems and high degree of parallelism. To verify the functionality of the aforementioned designs, we have used MATLAB software and also the quality factor (Q), extinction ratio (ER), contrast ratio (CR), and bit-error-rate (BER) have been calculated. [ABSTRACT FROM AUTHOR]

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. [ABSTRACT FROM AUTHOR]

Improving software quality by predicting faults during the early stages of software development is a primary goal of software fault prediction (SFP). Various machine learning models help to predict software faults. However, the imbalanced class distribution in the datasets may challenge some traditional learning approaches as they are more biased toward the majority class. The existence of class overlapping makes the prediction difficult owing to learning the minority class inaccurately. In addition to that, high data dimensionality makes the classification process complex and time-consuming. To enhance the performance of the classifier, handling these data quality issues is a big concern. This paper proposes a hybrid density-based method DBOS_US to address the class imbalance, noise, and class overlap in SFP. Initially, the density-based overlap removal (DBO) clustering algorithm is proposed to filter noisy and overlapped instances. Then, a graph-based algorithm, ShapeGraph, is adapted to handle imbalanced classes. The objective of the proposed method DBOS_US is to improve the performance of the traditional SFP classifiers. The experiments are conducted on 11 benchmark datasets from the PROMISE repository using six machine learning models (SVM, DT, KNN, NB, RF, and boosting). The experimental findings and statistical analysis revealed that the proposed method outperforms seven state-of-the-art techniques in terms of Area Under the Curve (AUC), G-mean, Recall (PD), and Probability of False alarms (PF). The proposed method improves the average values of G-mean, Recall, and AUC by at least 2.5%, 8.8%, and 1.2%, respectively. [ABSTRACT FROM AUTHOR]

Software evolution is an essential foundation in delivering technology that adapts to user needs and industry dynamics. In an era of rapid technological development, software evolution is not just a necessity, but a must to ensure long-term relevance. Developers are faced with major challenges in maintaining and improving software quality over time. This research aims to investigate the correlation between feature volatility and bug occurrence rate in software evolution, to understand the impact of dynamic feature changes on software quality and development process. The research method uses commit analysis on the dataset as a marker of bug presence, studying the complex relationship between feature volatility and bug occurrence rate to reveal the interplay in software development. Validated datasets are measured by metrics and correlations are measured by Pearson-productmoment analysis. This research found a strong relationship between feature volatility and bug occurrence rate, suggesting that an increase in feature changes correlates with an increase in bugs that impact software stability and quality. This research provides important insights into the correlation between feature volatility and bug occurrence rates, guiding developers and quality practitioners to develop more effective testing strategies in dynamic development environments. [ABSTRACT FROM AUTHOR]

Software defects are a critical issue in software development that can lead to system failures and cause significant financial losses. Predicting software defects is a vital aspect of ensuring software quality. This can significantly impact both saving time and reducing the overall cost of software testing. During the software defect prediction (SDP) process, automated tools attempt to predict defects in the source codes based on software metrics. Several SDP models have been proposed to identify and prevent defects before they occur. In recent years, recurrent neural network (RNN) techniques have gained attention for their ability to handle sequential data and learn complex patterns. Still, these techniques are not always suitable for predicting software defects due to the problem of imbalanced data. To deal with this problem, this study aims to combine a bidirectional long short-term memory (Bi-LSTM) network with oversampling techniques. To establish the effectiveness and efficiency of the proposed model, the experiments have been conducted on benchmark datasets obtained from the PROMISE repository. The experimental results have been compared and evaluated in terms of accuracy, precision, recall, f-measure, Matthew's correlation coefficient (MCC), the area under the ROC curve (AUC), the area under the precision-recall curve (AUCPR) and mean square error (MSE). The average accuracy of the proposed model on the original and balanced datasets (using random oversampling and SMOTE) was 88%, 94%, And 92%, respectively. The results showed that the proposed Bi-LSTM on the balanced datasets (using random oversampling and SMOTE) improves the average accuracy by 6 and 4% compared to the original datasets. The average F-measure of the proposed model on the original and balanced datasets (using random oversampling and SMOTE) were 51%, 94%, And 92%, respectively. The results showed that the proposed Bi-LSTM on the balanced datasets (using random oversampling and SMOTE) improves the average F-measure by 43 and 41% compared to the original datasets. The experimental results demonstrated that combining the Bi-LSTM network with oversampling techniques positively affects defect prediction performance in datasets with imbalanced class distributions. [ABSTRACT FROM AUTHOR]

Code smells are poorly designed code structures indicating that the code may need to be refactored. Recognizing code smells in practice is complex, and researchers strive to develop automatic code smell detectors. An obstacle to developing these solutions is the datasets' limitations. Manually labeled datasets were collected to investigate the developers' perceptions of code smells. They are characterized by a high label disagreement that hurts the performance of Machine Learning (ML) models trained using them. Furthermore, all large, manually labeled datasets are developed for Java. We recently created a novel dataset for C# to alleviate these issues. This paper evaluates ML code smell detection approaches on our novel dataset. We consider two feature representations to train ML models: (1) code metrics and (2) CodeT5 embeddings. This study is the first to consider the CodeT5 state-of-the-art neural source code embedding for code smell detection in C#. To prove the effectiveness of ML, we consider multiple metrics-based heuristics as alternatives. In our experiments, the best-performing approach was the ML classifier trained on code metrics (F-measure of 0.87 for Long Method and 0.91 for Large Class detection). However, the performance improvement over CodeT5 features is negligible if we consider the advantages of automatically inferring features. Finally, our ML model surpassed less experienced annotators and nearly matched the most experienced annotator, suggesting it can assist less experienced developers under tight deadlines. To the best of our knowledge, this is the first study to compare the performance of automatic smell detectors against human performance. [ABSTRACT FROM AUTHOR]

In the early 2000s, matrix-assisted laser desorption ionization–time of flight mass spectrometry (MALDI-TOF MS) emerged as a performant and relevant tool for identifying micro-organisms. Since then, it has become practically essential for identifying bacteria in microbiological diagnostic laboratories. In the last decade, it was successfully applied for arthropod identification, allowing researchers to distinguish vectors from non-vectors of infectious diseases. However, identification failures are not rare, hampering its wide use. Failure is generally attributed either to the absence of respective counter species MS spectra in the database or to the insufficient quality of query MS spectra (i.e., lower intensity and diversity of MS peaks detected). To avoid matching errors due to non-compliant spectra, the development of a strategy for detecting and excluding outlier MS profiles became compulsory. To this end, we created MSProfileR, an R package leading to a bioinformatics tool through a simple installation, integrating a control quality system of MS spectra and an analysis pipeline including peak detection and MS spectra comparisons. MSProfileR can also add metadata concerning the sample that the spectra are derived from. MSProfileR has been developed in the R environment and offers a user-friendly web interface using the R Shiny framework. It is available on Microsoft Windows as a web browser application by simple navigation using the link of the package on Github v.3.10.0. MSProfileR is therefore accessible to non-computer specialists and is freely available to the scientific community. We evaluated MSProfileR using two datasets including exclusively MS spectra from arthropods. In addition to coherent sample classification, outlier MS spectra were detected in each dataset confirming the value of MSProfileR. [ABSTRACT FROM AUTHOR]

AI-based (artificial intelligence) software utilization is increasingly widespread, including in education. On the one hand, AI-based software offers advantages for producing quality writing, such as converting voice into text, summarizing paragraphs, and improving grammar. There are pros and cons to each argument. Interestingly, permission or prohibition on using software is only for students, not lecturers. Moreover, lecturers should write quality scientific articles productively so that AI-based software can facilitate writing. Therefore, this research explores the driving and inhibiting factors that are thought to influence the use of AI-based software to assist lecturers in writing scientific articles. Following its goals, this research identified the potential factors through six hypotheses and tested them using PLS-SEM. This research recruited 110 lecturers in Indonesia as respondents to express their quantitative perceptions. It found that Product Quality (QLT) and Security (SEC) factors influence lecturers' use of AI-based software in scientific writing. However, four other variables (Motivation/MOT, Supporting Ability/SUP, Subjective Norms/NOR, and Individual Ability/ABL) had no influence. The finding exposed software quality has a vital role in engaging lecturers' intention to use AI-based software considering its characteristics to satisfy their needs: usefulness, easiness, accuracy, and efficiency. Also, lecturers are concerned with information security since AI-based software captures personal data, including user behavior during its usage. This research promotes practical implications for universities to regulate AI-based software, considering its benefits have been recognized by lecturers. However, its misuse can lead to the university's credibility in research and should be mitigated. [ABSTRACT FROM AUTHOR]