Microbenchmark-based performance regression detection is critical for software quality assurance but faces limitations in continuous integration (CI) environments. Existing test case prioritization methods primarily rely on code coverage and historical stability, overlooking the complex relationships between code changes and performance impacts. To address this, we presents JMH-TCP, an intelligent prioritization framework that leverages predictive modeling to establish connections between code changes and performance variations. Our method introduces a multi-dimensional analysis that integrates novel features, including semantic code distance metrics and change impact assessment powered by large language models, while incorporating traditional metrics such as historical performance stability and code coverage. Experimental evaluations across 10 open-source Java projects show that JMH-TCP achieving a 10.8% improvement in the Average Position of Faults in the Defect Prioritization (APFD-P) metric and an 18.2% enhancement in ranking effectiveness (NDCG) compared to state-of-the-art methods. Furthermore, our detailed ablation and correlation study reveals the synergistic effects of different features on prioritization effectiveness, offering valuable insights for optimizing performance testing strategies.

Abstract Rice is a widely cultivated crop in Asia and is paramount in ensuring national and global food security. However, rice plants are susceptible to various diseases that negatively impact crop quality and quantity to meet the needs of the world’s growing population. Automated rice plant disease classification ensures food security and agricultural sustainability. Although traditional deep learning approaches have shown promising results in rice plant disease classification, the challenges posed by the heterogeneity of the data set and the feature imbalance persist. This research introduces a robust and novel Ensemble Attention Mechanism (EAM) that uses fine-tuning transfer learning to address these challenges and pre-trained (VGG16, VGG19, and customized ResNet called RiceNet, which comprises ResNet18 and ResNet50) as baseline models, specifically tailored to improve rice plant disease classification within heterogeneous datasets. The main contribution of this paper is to introduce a RiceNet framework that incorporates ensemble learning principles and attention mechanisms to adaptively balance data heterogeneity and feature representation by effectively integrating every representation to mitigate inherent class distribution imbalances. Comprehensive ablation studies validate the effectiveness of each component in the framework, demonstrating significant improvements in classification performance compared to traditional methods. Furthermore, the evaluation of RiceNet on two extensive publicly available datasets (close environment and field environment) shows its superior performance, achieving an impressive F1 score of 100% and a balanced precision of 100% on both large and small datasets. This research sets a new benchmark for rice disease classification and provides a versatile framework applicable to agricultural precision, contributing to food security and sustainability.

Commit classification plays a crucial role in software maintenance, as it permits developers to make informed decisions regarding resource allocation and code review. There are several approaches for automatic commit classification, yet they do not sufficiently explore the features related to commits and consider the advantages of ensemble models over individual models. Therefore, there is some room for improvement. In this paper, we propose MuheCC, a commit classification approach based on multivariate mixed features and heterogeneous classifier selection to address these challenges. It mainly consists of three phases: (1) Multivariate mixed feature extraction, which extracts features from commit messages, changed code and handcrafted features to construct comprehensive mixed features; (2) Hyperparameter tuning based on genetic algorithm, which utilizes genetic algorithm to optimize candidate traditional models and ensemble models; (3) Heterogeneous classifier selection, which selects the optimal combinations of traditional and ensemble models, respectively, to build a heterogeneous classifier for commit classification. To evaluate this approach, we extend an existing dataset with code changes for each commit and compare MuheCC with three baselines on this real-world dataset. The results show that MuheCC outperforms all baselines, especially improving the best baseline by 7.25% for accuracy, 6.88% for precision, 7.25% for recall and 7.06% for [Formula: see text]-score. Furthermore, the ablation experiments validate that the performance advantage of MuheCC is mainly attributed to the multivariate features (e.g. 12.55% contributions to accuracy) and the heterogeneous classifier (e.g. 12.26% contributions to accuracy). We further discuss the impact of hyperparameter tuning and heterogeneous classifier selection on the performance of MuheCC. These results prove the superiority and potential practical value of MuheCC.

Summary Continuous integration (CI) is a widely applied development practice to allow frequent integration of software changes, detecting early faults. However, extremely frequent builds consume amounts of time and resources in such a scenario. It is quite challenging for existing test case prioritization (TCP) to address this issue due to the time‐consuming information collection (e.g. test coverage) or inaccurately modelling code semantics to result in the unsatisfied prioritization. In this paper, we propose a semantic‐aware two‐phase TCP framework, named SatTCP, which combines the coarse‐grained filtering and fine‐grained prioritization to perform the precise TCP with low time costs for CI. It consists of three parts: (1) code representation, parsing the programme changes and test cases to obtain the code change and test case representations; (2) coarse‐grained filtering, conducting the preliminary ranking and filtering of test cases based on information retrieval; and (3) fine‐grained prioritization, training a pretrained Siamese language model based on the filtered test set to further sort the test cases via semantic similarity. We evaluate SatTCP on a large‐scale, real‐world dataset with cross‐project validation from fault detection efficiency and time costs and compare it with five baselines. The results show that SatTCP outperforms all baselines by 6.3%–45.6% for mean average percentage of fault detected per cost (APFDc), representing an obvious upward trend as the project scale increases. Meanwhile, SatTCP can reduce the real CI testing by 71.4%, outperforming the best baseline by 17.2% for time costs on average. Furthermore, we discuss the impact of different configurations, flaky tests and hybrid techniques on the performance of SatTCP, respectively.

Background. Issues are prevalent, and identifying the correct priority of the reported issues is crucial to reduce the maintenance effort and ensure higher software quality. There are several approaches for the automatic priority prediction, yet they do not fully utilize the related information that might influence the priority assignment. Our observation reveals that there are noticeable correlations between an issue’s priority and its category, e.g., an issue of bug category tends to be assigned with higher priority than an issue of document category. This correlation motivates us to employ multi-task learning to share the knowledge about issue’s category prediction and facilitating priority prediction.

In Continuous Integration (CI) development environment, integration testing (i.e., CI testing) is an important practice to verify the quality of submitted code. With the growth of integration system, running all tests leads to high test cost with slow feedback. Many test case selection techniques have been proposed to tackle this problem. We analyze existing static test selection approaches on method-level, and find there are two main drawbacks, i.e., omission of dependencies and imprecise dependencies, which influence the effectiveness of test selection. Both of them are due to the fact that some dependencies are dynamically determined at runtime, which could not be resolved solely by current static analysis techniques. We propose a Method-level tEst SelecTion approach (i.e., MEST), which utilizes static dependencies and dynamic execution rules (i.e., dynamic invocation in reflection and dynamic binding in inheritance). Evaluation is conducted on 18 open source projects with 261 continuous integration versions from Eclipse and Apache communities. We assess the effectiveness of MEST from reduced test size, fault detection efficiency and test cost, and compare it with the state-of-the-art approach ClassSRTS (as baseline); and further analyze the contribution of dynamic execution rules. Results show that (1) on average, MEST can reduce test size by 92% and 43% compared with actual CI testing and baseline respectively; (2) MEST can fully cover all faults detected by actual CI testing (in 97% versions) and baseline (in 98% versions), and find new faults in 26% and 27% versions respectively; (3) on average, the endto-end time of MEST is 24% and 48% of actual CI testing and baseline respectively; (4) both dynamic execution rules contribute to fault detection through capturing necessary dependencies. This approach can further speed up the feedback of CI testing and improve the fault detection efficiency of CI testing.

Continuous Integration (CI) is an important practice in agile development.With the growth of integration system, running all tests to verify the quality of submitted code, is clearly uneconomical.This paper aims at selecting a proper test subset towards full coverage of all changed and affected code so as to reduce the cost of CI testing.We proposes FEST, a novel approach, which searches for the full dependencies of changed code at the class level and then selects test classes related to the changed and affected classes.We assess FEST from fault detection efficiency and cost effectiveness based on 18 open source projects with 261 continuous integration versions from Eclipse and Apache communities, and compare it with the stateof-the-art approach ClassSRTS (as baseline).Results show that FEST (1) can not only cover all faults detected by actual CI testing and baseline, but also find new faults in 25% and 18% versions respectively.(2) shows better or equal test scale benefits than actual CI testing (in 98% versions) and baseline (in 99% versions); and can compensate risk of omitting necessary tests for actual CI testing (in 62% versions) and baseline (in 73% versions).

The development of High-level programming languages(HLPL) is a long process of evolution, which has gone through procedure-oriented languages, object-oriented languages, script languages and visual & database languages. Throughout the process of evolution, coding in an efficient and convenient way is the primary impetus. Hence, the productivity should vary across different languages. When evaluating the productivity of developers coding in different programming languages, such variations are usually ignored, which may not reflect their actual coding efficiencies and make the developers feel unfair. Especially, ignoring the variations will lead to inappropriate baselines of process performance, thus may potentially reduce the effectiveness of quantitative management. In this paper, we conducted an empirical study to revisit the productivity variations across different programming languages based on the data of International Software Benchmarking Standards Group (ISBSG) and a software organization. We found that, in most language categories, the productivity is all significantly different in ISBSG and the organization respectively. In the software industry represented by ISBSG, the relative productivity levels are gradually increasing with the evolution of HLPL. However, for the organization, it does not always keep the same increasing trend, but the average productivity within the four categories is almost stable. The finding could guide the software organization to establish an appropriate productivity baseline.