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.

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.

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.

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.

We present MoVNect, a lightweight deep neural network to capture 3D human pose using a single RGB camera. To improve the overall performance of the model, we apply the teacher-student learning method based knowledge distillation to 3D human pose estimation. Real-time post-processing makes the CNN output yield temporally stable 3D skeletal information, which can be used in applications directly. We implement a 3D avatar application running on mobile in real-time to demonstrate that our network achieves both high accuracy and fast inference time. Extensive evaluations show the advantages of our lightweight model with the proposed training method over previous 3D pose estimation methods on the Human3.6M dataset and mobile devices.

Summary A log statement is one of the key tactics for a developer to record and monitor important run‐time behaviors of our system in a development phase and a maintenance phase. It composes of a message for stating log contents, and a log level (eg,debugorwarn) to denote the severity of a message and controlling its visibility at run time. In spite of its usefulness, a developer does not tend to deeply consider which log level is appropriate in writing source code, which causes the system to be unmaintainable. To address this issue, this paper proposes an automatic approach to validating the appropriateness of the log level in consideration of the semantic and syntactic features and recommending a proper alternative log level. We first build the semantic feature vector to quantify the semantic similarity among application log messages using the word vector space, and the syntactic feature vector to capture the application context that surrounds the log statement. Based on the feature vectors and machine learning techniques, the log level is automatically validated, and an alternative log level is recommended if the log level is invalid. For the evaluation, we collected 22 open‐source projects from three application domains, and obtained the 77% of precision and 75% of recall in validating the log levels. Also, our approach showed 6% higher accuracy than that of the developer group who has 7 to 8 years of work experience, and 72% of the developers accepted our recommendation.

To ensure code readability and facilitate software maintenance, program methods must be named properly. In particular, method names must be consistent with the corresponding method implementations. Debugging method names remains an important topic in the literature, where various approaches analyze commonalities among method names in a large dataset to detect inconsistent method names and suggest better ones. We note that the state-of-the-art does not analyze the implemented code itself to assess consistency. We thus propose a novel automated approach to debugging method names based on the analysis of consistency between method names and method code. The approach leverages deep feature representation techniques adapted to the nature of each artifact. Experimental results on over 2.1 million Java methods show that we can achieve up to 15 percentage points improvement over the state-of-the-art, establishing a record performance of 67.9% F1- measure in identifying inconsistent method names. We further demonstrate that our approach yields up to 25% accuracy in suggesting full names, while the state-of-the-art lags far behind at 1.1% accuracy. Finally, we report on our success in fixing 66 inconsistent method names in a live study on projects in the wild.

A log statement is used to record important runtime behavior of software systems for diverse reasons, which is inevitable to develop most of the software systems. However, developers do not tend to deeply consider an appropriate log level in their source code. In order to address the issues, this paper proposes an automatic approach to validating log levels in Java in consideration of the syntactic as well as semantic features. We first build up the Word2Vec model and generate semantic and syntactic log feature vectors, then train the machine learning classifiers to automatically validate the log levels. For the evaluation, we collected six open source projects of the message-oriented middleware domain, and obtained the 88% precision and the 87% recall respectively.

Completeness in software requirements specification is one of the key factors for successful software development. For specifying software requirements, scenario-based approach is broadly used, comprising a basic flow regarding the successful use of the system, and alternative flows describing abnormal or less frequent interactions of the system. However, alternative flows tend to be frequently missed in many cases, because of the relative lower significance rather than the basic flow, which eventually have an influence on achieving the completeness of software requirements. In order to address the issue, we propose an approach for automatically recommending alternative flows from a basic flow by extracting the essential use case patterns based on the occurrence patterns of the agents and measuring the verb similarity between the main verbs of each scenario. In order to validate our approach, we apply it to three industrial case studies, and show comprehensiveness of the suggested alternative flows and synergic effectiveness for inexperienced developers.

High-Throughput Computing (HTC) and Many-Task Computing (MTC) paradigms employ loosely coupled applications which consist of a large number, from tens of thousands to even billions, of independent tasks. To support such large-scale applications, a heterogeneous computing system composed of multiple computing platforms with different types such as supercomputers, grids, and clouds can be used. On allocating heterogeneous resources of the system to multiple users, there are three important aspects to consider: fairness among users, efficiency for maximizing the system throughput, and user satisfaction for reducing the average user response time. In this paper, we present three resource allocation policies for multi-user and multi-application workloads in a heterogeneous computing system. These three policies are a fairness policy, a greedy efficiency policy, and a fair efficiency policy. We evaluate and compare the performance of the three resource allocation policies over various settings of a heterogeneous computing system and loosely coupled applications, using simulation based on the trace from real experiments. Our simulation results show that the fair efficiency policy can provide competitive efficiency, with a balanced level of fairness and user satisfaction, compared to the other two resource allocation policies.

Sustainability of software architectures has gained increasing attention to cope with factors causing architectural changes such as requirements changes, technological changes, and changes in business strategies and goals. However, there has not been much work on architectural sustainability. In this paper, we present a novel approach for addressing architectural sustainability with respect to non-functional requirements changes through preemptive architectural designs built upon the combined use of architectural patterns and architectural tactics. The approach presented in this paper provides a strategic solution for practitioners to building a quality attribute into a chosen architectural pattern to proactively deal with the requirements changes of quality attribute, which may arise after the construction phase.

Using deprecated APIs often results in security vulnerability or performance degradation. Thus, invocations to deprecated APIs should be immediately replaced by alternative APIs. To resolve deprecated APIs, most developers rely on API documents provided by service API libraries. However, the documents often do not have sufficient information. This makes many deprecated API usages remain unresolved, which leads programs to vulnerable states. This paper reports a result of studying document quality for deprecated APIs. We first collected 260 deprecated APIs of eight Java libraries as well as the corresponding API documents. These documents were manually investigated to figure out whether it provides alternative APIs, rationales, or examples. Then, we examined 2,126 API usages in 249 client applications and figured out whether those were resolved in the subsequent versions. This study revealed that 1) 3.6 APIs was deprecated and 3.6 deprecated APIs are removed from the library a month on average, 2) only 61% of API documents provided alternative APIs while rationale and examples were rarely documented, and 3) 62% of deprecate API usages in client applications were resolved if the corresponding API documents provided alternative APIs while 49% were resolved when the documents provided no alternative APIs. Based on these results, we draw future directions to encourage resolving deprecated APIs.

In this paper, we present a prototype tool that supports the systematic development of software architectures driven by quality requirements using architectural tactics. The tool allows one to configure architectural tactics based on quality requirements and compose the configured tactics to produce an initial architecture for the system. We demonstrate the tool for developing an architecture for a resource profiling system in the web environment and validate the results using a set of metrics.

Recently, industries need more effective software engineering education for undergraduate students as software plays an increasingly important role in consumer products. Specifically, the manufacturing industry emphasizes overall experience with software development processes from requirements to implementation in embedded software development. This paper proposes an educational toolkit focusing on architecture design methodology for embedded software and reports experience with teaching software engineering by using the toolkit. The toolkit has several tools that support methodology education. The toolkit consists of three perspectives: people, process, and technology. Each perspective represents a set of tools which can support educational activities. Particularly, the toolkit introduces LEGO MindStorms NXT as a robotic system to provide experiences with embedded software development, and visible and tangible course materials. We have conducted a case study based on the toolkit in undergraduate-level classes. The case study shows the toolkit can be successfully applied in undergraduate-level software engineering education.

Recently, organizations face various business challenges because of rapidly changing user needs and expectations. SOA (Service-Oriented Architecture) is a promising technique for adequately handling them in organizations. In developing SOA based systems, service identification is one of the core activities, having a broad influence on the systems. To identify proper services, business goals and business change factors should be analyzed because the ultimate aim of SOA is to achieve business goals and business agility in turbulent business environment. To tackle this, we propose a service identification method based on goal-scenario modeling and a conceptual framework to elicit possible business changes. Traceability among business goals, business changes and identified services are also constructed in this approach. We applied our approach into the HRS (Hotel Reservation System) domain to demonstrate its feasibility.

Service-Oriented Architecture (SOA) is emerging as an effective solution to deal with rapid changes in the business environment. To handle fast-paced changes, organizations need to be able to assess the quality of its products prior to implementation. However, literature and industry has yet to explore the techniques for evaluating design quality of SOA artifacts. To address this need, this paper presents a hierarchical quality assessment model for early assessment of SOA system quality. By defining desirable quality attributes and tracing necessary metrics required to measure them, the approach establishes an assessment model for identification of metrics at different abstraction levels. Using the model, design problems can be detected and resolved before they work into the implemented system where they are more difficult to resolve. The model is validated against an empirical study on an existing SOA system to evaluate the quality impact from explicit and implicit changes to its requirements.

This paper presents an approach for embodying nonfunctional requirements (NFRs) into software architecture using architectural tactics. Architectural tactics are reusable architectural building blocks, providing general architectural solutions for commonly occurring issues related to quality attributes. In this approach, architectural tactics are represented as feature models, and their semantics is defined using the role-based metamodeling language (RBML) which is a UML-based pattern specification notation. Given a set of NFRs, architectural tactics are elected and composed. The composed tactic is then used to instantiate an initial architecture for the application where the NFRs are embodied. A stock trading system is used to demonstrate the approach.

The research field of Intelligent Service Robots, which has become more and more popular over the last years, covers a wide range of applications from climbing machines for cleaning large storefronts to robotic assistance for disabled or elderly people. When developing service robot software, it is a challenging problem to design the robot architecture by carefully considering user needs and requirements, implement robot application components based on the architecture, and integrate these components in a systematic and comprehensive way for maintainability and reusability. Furthermore, it becomes more difficult to communicate among development teams and with others when many engineers from different teams participate in developing the service robot. To solve these problems, we applied the COMET design method, which uses the industry-standard UML notation, to developing the software of an intelligent service robot for the elderly, called T-Rot, under development at Center for Intelligent Robotics (CIR). In this paper, we discuss our experiences with the project in which we successfully addressed these problems and developed the autonomous navigation system of the robot with the COMET/UML method.