Mobile edge computing (MEC) has become a key paradigm for supporting latency-sensitive and bandwidth-intensive applications. However, existing server recommendation methods rely on static heuristics and lack adaptability to dynamic environments with incomplete quality of service (QoS) data. This study aims to address these limitations by enabling adaptive and context-aware server recommendations that effectively manage user mobility and missing QoS information in real time. We propose an intelligent MEC server recommendation framework built on a multi-agent architecture spanning mobile, edge, and cloud layers. The mobility layer predicts user movement, the edge layer performs LLM-based decision-making, and the cloud layer imputes QoS through multi-source data fusion. Lightweight gRPC and WebSocket protocols ensure scalability across multi-user environments. Experiments demonstrate that the proposed system outperforms the baseline, achieving 85% Top-1 accuracy and confirming its effectiveness and scalability for real-world MEC applications.

In mobile edge computing (MEC), frequent server handovers due to user mobility increase latency and degrade quality of service (QoS). This study enhances MEC service stability by predicting user mobility for efficient server transitions. The proposed spacio-temporal (ST)-Mamba model combines Mamba (state-space encoder) and a gated recurrent unit (GRU) in parallel to capture both long-term and short-term dependencies, while Fourier feature embedding enriches spatial-temporal representation. Experiments show that ST-Mamba achieves about 9–10% lower root mean square error (RMSE) and mean absolute error (MAE) than long short-term memory (LSTM), GRU, and Transformer baselines, with statistically significant improvements confirmed by Welch’s t-test. These results demonstrate that hybrid state space model (SSM)–RNN architectures are promising for mobility-aware QoS optimization in MEC, with future work extending to real-world and multi-user settings.

Edge-cloud systems, which bring computing, storage, and networking resources closer to end-users, offer significant advantages in reducing latency and enabling real-time data processing. These systems are increasingly deployed across diverse domains, such as smart manufacturing, autonomous vehicles, and large-scale IoT networks, to support big data-driven services that require continuous analytics and rapid response. Ensuring software reliability in these environments is critical, which has led to growing attention on just-in-time (JIT) defect prediction as an effective technique for prioritizing testing efforts by identifying code changes likely to introduce defects. However, existing techniques struggle to perform accurately on new or low-data projects due to insufficient training data. In this paper, we propose PROPER-SDP, a prompt-based approach that leverages large language models. By incorporating project evolution data directly into prompts, our approach enables LLMs to effectively capture the contextual information essential for accurate JIT defect prediction. By doing so, we effectively address the cold-start problem, allowing accurate JIT defect prediction even in the absence of project-specific training data. Evaluation results demonstrate that our method significantly improves prediction performance, surpassing baseline methods by an average of 19.7% in F1-score. Our approach enables reliable JIT defect prediction even in rapidly evolving, resource-constrained edge-cloud systems.

Ensuring the reliability of infrastructure as code (IaC) scripts, like those written in Ansible, is vital for maintaining the performance and security of edge-cloud systems. However, the scale and complexity of these scripts make exhaustive testing impractical. To address this, we propose a large language model (LLM)-based software defect prediction (SDP) approach that uses code-smell-guided prompting (CSP). In some cases, CSP enhances LLM performance in defect prediction by embedding specific code smell indicators directly into the prompts. We explore various prompting strategies, including zero-shot, one-shot, and chain of thought CSP (CoT-CSP), to evaluate how code smell information can improve defect detection. Unlike traditional prompting, CSP uniquely leverages code context to guide LLMs in identifying defect-prone code segments. Experimental results reveal that while zero-shot prompting achieves high baseline performance, CSP variants provide nuanced insights into the role of code smells in improving SDP. This study represents exploration of LLMs for defect prediction in Ansible scripts, offering a new perspective on enhancing software quality in edge-cloud deployments.

It requires historical datasets from diverse environments to build accurate and robust software reliability growth models. However, it is very difficult to collect such datasets, particularly in the industrial domain, due to confidentiality and security considerations. To solve this issue, we conducted a thorough investigation of historical datasets for software reliability growth modeling. We searched IEEE Xplore, a prominent digital library, using the keyword “Software Reliability Growth Model” for publications up to 2022 and gathered 127 non-redundant historical datasets. In this paper, we present a comprehensive analysis of these datasets, which helps advance software reliability growth modeling. We applied seven representative software reliability growth models and found that the Generalized Goel model, which has a concave curve, was the most frequently chosen optimal model for Failure-Count type datasets. However, It is notable that S-shaped curve models remained preferred for the majority of datasets. Categorizing datasets by collection phases, application types, source types, and data flow trends resulted in varied optimal model selections across classifications. These insights contribute to the advancement of software reliability growth modeling, fostering informed decision-making in software development and maintenance.

Traditional Software Reliability Growth Models (SRGMs) depend on unrealistic assumptions, which makes it difficult to capture the complexities of modern software development. Recent advancements in artificial intelligence have introduced new modeling techniques, but these methods are complex and require careful algorithm selection and hyperparameter tuning. Automated Machine Learning (AutoML) has emerged as a promising solution to streamline this process. However, its application in the field of software reliability growth modeling remains unexplored. In this study, we explore the effectiveness of AutoML in enhancing software reliability growth modeling and compare its performance with traditional SRGMs. We employ two prominent AutoML packages, Auto-sklearn and H2O AutoML, and leverage twelve project datasets to answer three research questions: (1) the impact of various AutoML package options on software reliability growth modeling, (2) the identification of the optimal AutoML approach for modeling software reliability growth, and (3) the overall effectiveness of AutoML in software reliability growth modeling. We found that using ensemble options enhanced predictive performance across multiple projects. Auto-sklearn with the ensemble option emerged as the most effective approach when evaluated based on End-point Prediction values, while H2O AutoML with the ensemble option demonstrated superior performance based on Mean Squared Error values. Additionally, AutoML packages with ensemble options demonstrated more accurate predictive performance compared to traditional SRGMs across the majority of datasets. Our study highlights the potential of AutoML to enhance software reliability growth modeling and provides insights for future research and practical applications in software engineering.

With the rapid growth of cloud services driven by advancements in web service technology, selecting a high-quality service from a wide range of options has become a complex task. This study aims to address the challenges of data sparsity and the cold-start problem in web service recommendation using Quality of Service (QoS). We propose a novel approach called QoS-aware graph contrastive learning (QAGCL) for web service recommendation. Our model harnesses the power of graph contrastive learning to handle cold-start problems and improve recommendation accuracy effectively. By constructing contextually augmented graphs with geolocation information and randomness, our model provides diverse views. Through the use of graph convolutional networks and graph contrastive learning techniques, we learn user and service embeddings from these augmented graphs. The learned embeddings are then utilized to seamlessly integrate QoS considerations into the recommendation process. Experimental results demonstrate the superiority of our QAGCL model over several existing models, highlighting its effectiveness in addressing data sparsity and the cold-start problem in QoS-aware service recommendations. Our research contributes to the potential for more accurate recommendations in real-world scenarios, even with limited user-service interaction data.

Recently, Python is the most-widely used language in artificial intelligence (AI) projects requiring huge amount of CPU and memory resources, and long execution time for training. For saving the project duration and making AI software systems more reliable, it is inevitable to handle exceptions appropriately at the code level. However, handling exceptions highly relies on developer’s experience. This is because, as an interpreter-based programming language, it does not force a developer to catch exceptions during development. In order to resolve this issue, we propose an approach to suggesting appropriate exceptions for the AI code segments during development after training exceptions from the existing handling statements in the AI projects. This approach learns the appropriate token units for the exception code and pretrains the embedding model to capture the semantic features of the code. Additionally, the attention mechanism learns to catch the salient features of the exception code. For evaluating our approach, we collected 32,771 AI projects using two popular AI frameworks (i.e. Pytorch and Tensorflow) and we obtained the 0.94 of Area under the Precision-Recall Curve (AUPRC) on average. Experimental results show that the proposed method can support the developer’s exception handling with better exception proposal performance than the compared models.

In Version Control System (VCS), a developer frequently uploads multiple tasks such as adding features, code refactoring, and fixing bugs, into a single commit and crumbles each task’s summary when writing a commit message. It causes code readers to feel challenged in understanding the developer’s past tasks within the commit history. To resolve this issue, we propose an automatic approach to generating a task summary to help comprehend multiple mixed tasks in a commit and developed tool support named Task summary Generator (TsGen). In our approach, we use the commit with a single task as input and identify the task to sort its elements sequentially. Then we generate feature vectors from each sorted element to train the Neural Machine Translation (NMT) model. Based on the trained NMT model, we generate the feature vector from each task of a commit with multiple tasks and put each of them into the model to provide the task summary. In evaluation, we compared the performance of TsGen with two existing methods for nine open-source projects. As a result, TsGen outperformed CoDiSum and Jiang’s NMT by 52.08% and 28.07% in BiLingual Evaluation Understudy (BLEU) scores. In addition, the human evaluation was carried out to demonstrate that TsGen helps understand mixed tasks in a commit and gained a 0.27 higher preference than the actual commit message.

Edge computing is applied to various applications and is typically applied to autonomous driving software. As the self-driving system becomes complicated and the proportion of software increases, accidents caused by software defects increase. Just-in-time (JIT) defect prediction is a technique that identifies defects during the software development phase, which helps developers prioritize code inspection. Many researchers have proposed various JIT models, but it is difficult to find a case in which JIT defect prediction was performed on edge computing applications. In particular, due to the characteristic of self-driving software, which is frequently updated, there is a high risk of inducing defects into the update process. In this work, we propose a JIT defect prediction model via deep learning for edge computing applications called JIT4EA. Our research goal is to develop an effective model to predict defects in edge computing applications. To do this, we perform defect prediction on self-driving software, a representative edge computing application. We use pre-trained unified cross-modal pre-training for code representation (UniXCoder) to embed commit messages and code changes. We use bidirectional-LSTM(Bi-LSTM) for context and semantic learning. As a result of the experiment, it was confirmed that the proposed JIT4EA performed better than state-of-the-art methods and could reduce the code inspection effort.

Edge-Cloud system requires massive infrastructures located in closer to the user to minimize latencies in handling Big data. Ansible is one of the most popular Infrastructure as Code (IaC) tools crucial for deploying these infrastructures of the Edge-cloud system. However, Ansible also consists of code, and its code quality is critical in ensuring the delivery of high-quality services within the Edge-Cloud system. On the other hand, the Large Langue Model (LLM) has performed remarkably on various Software Engineering (SE) tasks in recent years. One such task is Automated Program Repairing (APR), where LLMs assist developers in proposing code fixes for identified bugs. Nevertheless, prior studies in LLM-based APR have predominantly concentrated on widely used programming languages (PL), such as Java and C, and there has yet to be an attempt to apply it to Ansible. Hence, we explore the applicability of LLM-based APR on Ansible. We assess LLMs’ performance (ChatGPT and Bard) on 58 Ansible script revision cases from Open Source Software (OSS). Our findings reveal promising prospects, with LLMs generating helpful responses in 70% of the sampled cases. Nonetheless, further research is necessary to harness this approach’s potential fully.

Edge-cloud computing is a distributed computing infrastructure that brings computation and data storage with low latency closer to clients. As interest in edge-cloud systems grows, research on testing the systems has also been actively studied. However, as with traditional systems, the amount of resources for testing is always limited. Thus, we suggest a function-level just-in-time (JIT) software defect prediction (SDP) model based on a pre-trained model to address the limitation by prioritizing the limited testing resources for the defect-prone functions. The pre-trained model is a transformer-based deep learning model trained on a large corpus of code snippets, and the fine-tuned pre-trained model can provide the defect proneness for the changed functions at a commit level. We evaluate the performance of the three popular pre-trained models (i.e., CodeBERT, GraphCodeBERT, UniXCoder) on edge-cloud systems in within-project and cross-project environments. To the best of our knowledge, it is the first attempt to analyse the performance of the three pre-trained model-based SDP models for edge-cloud systems. As a result, we can confirm that UniXCoder showed the best performance among the three in the WPDP environment. However, we also confirm that additional research is necessary to apply the SDP models to the CPDP environment.

Gradle is one of the widely used tools to automatically build a software project. While developers execute the Gradle build for projects, they face various build errors in practice. However, fixing build errors is not easy because developers should manually find out the cause of the build error and its resolution on their project. For this reason, developers spend much time fixing them, and especially it can be worse if a developer lacks the experience of handling build errors. To address this issue, we propose a novel approach named Gradle-AutoFix to automatically fix build errors along with providing their causes and resolutions. In this approach, we collect build errors to group their causes and resolutions and then generate feature vectors from build error messages by applying Bag-of-Word (BoW), Term Frequency-Inverse Document Frequency (TF-IDF), Bigram, and an embedding layer. The feature vectors are utilized for training two classification models on cause and resolution. Next, we analyze fixing patterns and define seven resolution rules to fix the build error automatically. Based on our trained models and defined resolution rules, we built Gradle-AutoFix. For the evaluation, we measured how appropriately Gradle-AutoFix provides causes of build errors and resolutions. As a result, we obtained 96% and 91% accuracy, respectively. Also, we assessed how properly Gradle-AutoFix fixes the project’s build error based on the seven resolution rules. The outcome showed a 64.5% build error resolution rate for 231 projects.

With recent increases in the number of network-connected devices, the number of edge computing services that provide similar functions has increased. Therefore, it is important to recommend an optimal edge computing service, based on quality-of-service (QoS). However, in the real world, there is a cold-start problem in QoS data: highly sparse invocation. Therefore, it is difficult to recommend a suitable service to the user. Deep learning techniques were applied to address this problem, or context information was used to extract deep features between users and services. However, edge computing environment has not been considered in previous studies. Our goal is to predict the QoS values in real edge computing environments with improved accuracy. To this end, we propose a GAIN-QoS technique. It clusters services based on their location information, calculates the distance between services and users in each cluster, and brings the QoS values of users within a certain distance. We apply a Generative Adversarial Imputation Nets (GAIN) model and perform QoS prediction based on this reconstructed user service invocation matrix. When the density is low, GAIN-QoS shows superior performance to other techniques. In addition, the distance between the service and user slightly affects performance. Thus, compared to other methods, the proposed method can significantly improve the accuracy of QoS prediction for edge computing, which suffers from cold-start problem.

Abstract Fault localization techniques are used to deduce the exact source of a failure from a set of failure indications while debugging software and play a crucial role in improving software quality. Mutation‐based fault localization (MBFL) techniques are proposed to localize faults at a finer granularity and with higher accuracy than traditional fault localization techniques. Despite the technique's effectiveness, the immense cost of mutation analysis hinders MBFL's practical application in the industry. Various mutation alternative strategies are utilized to lower the cost of MBFL, but they sacrifice the accuracy of localization results. Higher‐order mutation testing was proposed to search for valuable mutants that drive testing harder and reduce the overall test effort. However, higher‐order mutants (HOMs) never have been used to address the cost problem of MBFL to the extent of our knowledge. This paper proposes a novel, cost‐effective MBFL technique called HOTFUZ, Higher‐Order muTation‐based FaUlt localiZation, that employs HOMs to reduce the cost while minimizing the accuracy degradation. HOTFUZ combines mutants of a program under test into HOMs to decrease the number of mutants by more than half, depending on the order of HOMs. An experimental study is conducted using 65 real‐world faults of CoREBench to assess the proposed approach's cost‐effectiveness. The experimental results show that HOTFUZ outperforms the extant mutation alternative strategies by localizing faults more accurately using the same number of mutants executed. HOTFUZ has three main benefits over existing mutant reduction techniques for MBFL: (a) It keeps the advantage of using the whole set of mutation operators; (b) it does not discard generated mutants randomly for the sake of efficiency; and, finally, (c) it significantly decreases the proportion of equivalent mutants.

Heterogeneous defect prediction (HDP) predicts defect-prone modules when the source and target data have heterogeneous metric sets. Although several researchers have tried to improve the performance of HDP, many of them did not suggest selection guidelines of source projects nor handle the class imbalance problem. In this paper, we propose a novel approach to improve the performance further by selecting proper source projects for the given target project and considering imbalanced data, called CorrelAtion-based selection of Multiple source projects and Ensemble Learning (CAMEL) for HDP. Specifically, CAMEL first matches metrics through the Kolmogorov-Smirnov test. Second, it calculates fitness scores based on correlation analysis and selects multiple projects. Third, it predicts target labels using each selected source project and integrates the results with ensemble learning. The experiments show that CAMEL produces better results against existing methods. Consequently, CAMEL enhances reliability in the early development phase by providing proper source selection guidelines.

Cross-project Defect Prediction (CPDP) aims to build a defect prediction model to recognize target project's defective modules by utilizing other source project's historical data. In addition, Transfer Learning (TL) has been widely applied at CPDP to improve prediction performance by alleviating the data distribution discrepancy between the source and the target project. However, existing TL-based CPDP techniques are not applicable at the unit testing phase since they require the entire historical target project data for TL. As a result, they lose a chance of increasing the product's reliability in the unit testing phase by applying the prediction results to identify defects. Thus, the objective of this paper is to apply prediction results at the unit testing phase. To this end, we propose an early CPDP model (eCPDP) which is TL-based CPDP technique using Singular Value Decomposition applicable at the unit testing phase. We compare the performance of eCPDP with state-of-the-art TL-based CPDP techniques on effort-unaware and effort-aware performance metrics over 17 project datasets. Experimental result demonstrates that eCPDP executed during the unit testing stage is one of the best techniques compared to baselines executed after the unit testing stage on both types of metrics. Thus, we show that eCPDP is an applicable CPDP model at the unit testing phase, and it can help practitioners find and fix defects in an earlier phase than other TL-based CPDP techniques.

In a software development project, a developer tends to use the ‘diff’ view of the version control system (VCS) to understand development tasks such as fixing bugs, adding new features, and refactoring. However, the view only shows the difference of resources between the recent and previous versions in a commit, without providing any information about associated updates for completing a specific task. This causes a developer to spend a lot of time understanding development tasks, especially in the project where source code should be shared throughout team members. In order to handle this issue, we propose a novel tool Coding Time-Machine, in short Coding™, that automatically identifies and visualizes development tasks and their associated task elements (e.g., class and method). Coding™ extracts development tasks composed of task elements and causal relationships between them in a commit and facilitates one to compare the recent version of a code to the previous for each task. In addition, it allows one to navigate tasks of all commits in the code repository so that a developer feels like carrying out the time-travel of the coding activities in the software development project. For the evaluation, we measured the performance of tasks extracted from Coding™ for eight open-source Java projects, and obtained 0.87 of precision and 0.88 of recall. Also, we surveyed the usefulness of our tool for 20 participants, 80% of participants thought that showing tasks and their associated elements in a commit helps one to comprehend source code, and all participants responded that showing tasks in a chronicle way facilitates one to understand coding activities.

Abstract Background The importance of software in maritime transportation is rapidly increasing as the industry seeks to develop and utilize innovative future ships, which can be realized using software technology. Due to the safety‐critical nature of ships, software quality assurance (SQA) has become an essential prerequisite for such development. Objective Based on the unique characteristics of the maritime domain, the purpose of this study was to achieve effective SQA resource allocation to reduce post‐release quality costs. Method Software defect prediction (SDP) is employed to predict defects in newly developed software based on models trained with past software defects and to update information using machine learning. This study demonstrated that just‐in‐time SDP is applicable to maritime domain practice and can reduce post‐release quality costs via combination with an estimation model, qCOPLIMO. Results Using real‐world datasets collected from the maritime industry, performance and cost‐benefit analyses of SDP were performed. A successful model was obtained that meets the performance criterion of 0.75 in within‐project defect prediction (WPDP) but not cross‐project defect prediction (CPDP). In addition, the cost‐benefit analysis results showed that 20% effort enables the detection of 56% of defects on average and that the post‐release quality cost can be reduced by 37.3% in the maritime domain. Conclusion SDP can be successfully applied to the maritime domain. Further, it is desirable to utilize WPDP instead of CPDP once minimum high‐quality commits are available that can be identified as defective or not. Finally, SDP can help reduce review effort and post‐release quality costs.

Many web-based software systems have been developed in the form of composite services. It is important to accurately predict the Quality of Service (QoS) value of atomic web services because the performance of such composite services depends greatly on the performance of the atomic web service adopted. In recent years, collaborative filtering based methods for predicting the web service QoS values have been proposed. However, they are mainly faced with a cold start problem that is difficult to make reliable prediction due to highly sparse historical data, newly introduced users and web services, and the existing work only deals with the case of newly introduced users. In this article, we propose a Location-based Matrix Factorization using a Preference Propagation method (LMF-PP) to address the cold start problem. LMF-PP fuses invocation and neighborhood similarity, and then the fused similarity is utilized by preference propagation. LMF-PP is compared with existing approaches on the real world dataset. Based on the experimental results, LMF-PP shows better performance than existing approaches in cold start environments as well as in warm start environments.