Modern software systems are increasingly configurable, offering extensive options to meet diverse requirements. However, this flexibility results in exponentially growing configuration spaces, making exhaustive performance testing infeasible. Existing performance prediction models face significant challenges due to the curse of dimensionality, which limits their ability to generalize across high-dimensional spaces with sparse data. To address these challenges, this paper introduces a novel performance prediction framework comprising two components: Feature Transformer AutoEncoder (FTA) and Distance-Aware Greedy Sampling (DAGS). FTA leverages self-supervised learning and attention mechanisms to encode high-dimensional configuration data into compact, information-rich representations, effectively capturing long-range dependencies and mitigating data sparsity. DAGS, on the other hand, employs intelligent sampling strategies to maximize coverage within configuration spaces while minimizing measurement overhead. Extensive experimental evaluations across six real-world configurable software systems demonstrate that our approach significantly outperforms state-of-the-art methods, achieving up to a 79% reduction in Mean Relative Error (MRE). The results highlight the robustness and scalability of our framework in overcoming the traditional performance degradation associated with high-dimensional configuration spaces.

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.

From May 2019, GitHub launched sponsor mechanism indicating that GitHub is moving towards deeper integration of open source development and economic support. It will bring more comprehensive and diversified support to the open source community. However, the number of developers profiting from the sponsor mechanism follows a long tail distribution. Our study found that only 31% of developers who started the sponsor mechanism received rewards, and 39.3% of them only received a reward of one dollar. Our work focuses on identifying what factors affect the availability of sponsorship for developers in open source community. We start by defining 45 features to characterize the developers in four dimensions i.e. Personality, Advertisement, Repository and Behavior. The results of statistical analysis indicate that most of the proposed features differ significantly between the ones who received rewards (short for MTs_Yes) from those that are not. After that, we build machine learning model based on the proposed features to predict MTs_Yes. Compared with the existing work, results show that our method outperforms baselines by 30% for AUC (Area Under the Curve). In addition, we investigated the relative contribution of features in detecting MTs_Yes and analyzed the important features by using an interpretable model SHAP. Finally, based on the experimental results, we put forward corresponding and practical suggestions for developers who want to receive rewards so as to make the community of open source projects develop more harmonious.

As one of the most common code smells, feature envy reduces the cohesion of classes and increases the coupling between classes, thus leading to difficulty of software maintainability. Though many studies have made good achievements on feature envy detection, they often despise or even ignore the inherent calling relationships between methods, causing unimpressive detection efficiency. To address this problem, we propose a Graph Neural Network (GNN) based approach towards feature envy detection. We first collect code metrics and calling relationships, and then convert them to the form of a graph, where the node represents the code metrics of a method and the edge represents the calling relationship between methods. Particularly, considering the unbalance of positive and negative samples, we introduce a graph augmenter to obtain an enhanced graph. Finally, we feed the enhanced graph into a GNN model for training and predicting. We conducted extensive experiments on a dataset containing five open-source software projects. The result shows that our approach achieves 78.90% in terms of average F1-score, which is 37.98% absolutely higher than the best comparison approach. Besides, we propose a refactoring recommendation approach based on calling strength. It achieves 61.44% of accuracy, which is 5.13% absolutely higher than the best competitive. Our code and datasets are available at https://github.com/HduDBSI/Feature-Envy-Detection.

Continuous integration is a growing trend in the software engineering community and industry. Performance testing is becoming more important in this context. To support precise and fine-grained monitoring, performance unit tests are applied for small software components. However, the benchmarks for performance unit testing are still insufficient, which means that benchmark coverage is low and there is a room for improvement. Therefore, focusing on the most important parts of the software, such as methods, and ensuring that their performance is monitored closely with performance unit tests can greatly reduce the amount of work that needs to be done for testing and to prepare benchmarks. This paper aims to provide an assisting approach for detecting methods that need to be benchmarked in performance unit tests. We start by defining 30 features to characterize the methods in the projects and show that they can be used to tell the benchmarked methods (short for BDMs) from those that are not. Then, using the proposed features, we build machine learning-based models to detect BDMs. We perform an experiment with 10 open source projects from GitHub to see how well our approach works. First, we use seven binary classification techniques to evaluate the prediction performance of our machine learning models. We find that Random Forest makes the best predictions where AUC and MCC are between 0.77 and 0.89 and 0.5 and 0.75, respectively. In terms of cost effectiveness, the experiment reveals that by inspecting only 5% of the candidate methods detected by our model, 43% of the total real BDMs can be retrieved. Second, we conduct feature importance evaluations for individual features and feature categories. We find that eight features related to Scope, History, and Complexity are individually important for good predictions and that the combination of all features in the Scope category is paramount for our model, while the combination of features in the Control Flow category is less important. Third, we investigate the performance of our detection approach with different feature selection strategies and data sources. Our results show that we can make good predictions about whether a method needs to be benchmarked by using machine learning models. Practitioners can use our method and the results of the study to deal with BDMs detection effectively.

In software development, due to the demands from users or the limitations of time and resources, developers tend to adopt suboptimal solutions to achieve quick software development. In such a way, the released software usually involves not-quite-right code that is called technical debt, which will significantly decrease the quality of software and increase the maintenance cost. Recently, the concept of self-admitted technical debt (SATD) is proposed and refers to technical debt that is self-admitted by developers in code comments. Existing studies mainly focus on detecting technical debt by classifying code comments into either “SATD” or “non-SATD.” However, different types of SATD has different impacts on software maintenance and needs to be handled by different developers. Therefore, the detected SATD should be further classified so that developers can understand and remove technical debt better. In this article, we propose a new method based on eXtreme Gradient Boosting (XGBoost) to classify SATD into multiple classes. In our approach, we first preprocess the original code comments and adopt the easy data augmentation strategy to overcome the class unbalance problem. Then, chi-square is leveraged to select representative features from the textual feature set. Finally, we apply XGBoost to train a classifier and use the trained classifier to partition each comment into the corresponding class. We experimentally investigate the effectiveness of our approach on a public dataset, including 62 566 code comments from 10 open-source projects. Experimental results show that our approach achieves 56.66% in terms of macroaveraged precision, 59.07% in terms of macroaveraged recall, and 55.77% in terms of macroaveraged F-measure on average, and outperforms the natural language processing based method by 4.98%, 5.32%, and 3.17%, respectively. In addition, the experimental results also demonstrate that the data augmentation strategy is effective in improving the effectiveness of our approach.

Cyber–physical system (CPS) is a complex system that contains multiple components working cooperatively. According to its characteristics, we propose an object-oriented generalized stochastic Petri net (OGSPN), in which the CPS is abstracted into several types of objects and its logical structure and working process is visually described. Moreover, we model and measure the time consumed by each activity in CPS for quantitative analysis. To simplify the process of performance analysis on this model, in this article we propose a compression algorithm to convert OGSPN into a generalized stochastic Petri net (GSPN). Considering the uncertainty in CPS, we use a fuzzy mathematics based method to process the compressed model of GSPN for improving the accuracy of the performance analysis. We apply our method to a real-world thick metal plate production line in a manufacturing company, and the availability of our method is verified by extensive experiments.

With the continuous expansion of the software market and the updating of the maturity of the software development process, the performance requirements of software users are becoming increasingly prominent. Performance issues are essentially related to the source code. For solving the same problem, different programmers may write completely different "correct" code with the same functionality but have different performance. Most online judge system on programming make use of automated grading systems, usually rely on test results to quantify the correctness and performance for the submitted source code. However, traditional dynamic testing takes a lot of time, and the discovery of performance problems is usually after the fact even for those small scale programs. Therefore, we proposed DeepTLE which is used to effectively predict the performance of submitted source code before it runs. DeepTLE can automatically learn the semantic and structural features of the source code. In order to verify the effect of our approach, we applied it to the source code collected from the program competition website to predict if the source code would be time limit exceed or not without running its test cases. Experiment results show that our method can save 96% of the time cost compared to the dynamic testing, and the accuracy of the prediction reaches 82%.

With the continuous expansion of software market and the updating of the maturity of the software development process, the performance requirements of software users have gradually become prominent. Performance issues are closely related to the source code. Thus, with the increasing complex of the software product, its performance changed during the evolution of the software product. Performance optimization related work has always been an important goal for developers who usually coding at a low-level. However, performance problems are well studied on architecture level. All too often, some developers are ignorant of the way their code modifications affect performance and simply to wait until performance drops to a point that is unacceptable to the business side. As software developers did a lot of daily work at code level, we think code level performance awareness can help developers in sight of the performance of the code that they are working with. To deal with this, we firstly build performance-aware code change model to identify the performance changes and its related code changes at the granularity of function between each two reversions of a program. Then, we analyzed the evolution history of the code performance and mined the frequent code change patterns that used to improve performance. We have build related tool to implement the proposed approach and applied it to 8 open source projects.

Cloud computing has become a revolutionary paradigm by provisioning on-demand and low cost computing resources for customers. As a result, scientific workflow, which is the big data application, is increasingly prone to adopt cloud computing resources. However, internal failure (host fault) is inevitable in such large distributed computing environment. It is also well studied that cloud data center will experience malicious attacks frequently. Hence, external failure (failure by malicious attack) should also be considered when executing scientific workflows in cloud. In this paper, a fault-tolerant scheduling (FTS) algorithm is proposed for scientific workflow in cloud computing environment, the aim of which is to minimize the workflow cost with the deadline constraint even in the presence of internal and external failures. The FTS algorithm, based on tasks replication method, is one of the widely used fault tolerant mechanisms. The experimental results in terms of real-world scientific workflow applications demonstrate the effectiveness and practicality of our proposed algorithm.