Leveraging the code comprehension capabilities of Large Language Models (LLMs), we propose an automated approach to enhance Requirement-to-Code (R2C) traceability through Chain-of-Thought (CoT) prompting. Traditional Information Retrieval (IR) techniques (e.g., VSM, LSI) exhibit limited accuracy due to the semantic gap between natural language requirements and syntactic code structures. Our framework addresses this gap via two key innovations: (1) CoT-guided generation of functional code summaries through iterative reasoning steps (language identification, comment analysis, naming pattern interpretation), and (2) a similarity-based reordering strategy utilizing SimCSE embeddings to refine candidate links. Evaluations on four industrial datasets (iTrust, eTour, eANCI, SMOS) show $\mathbf{1 2 5. 4 7 \%,} \mathbf{6 3. 2 \%}$ and $\mathbf{6 2. 1 3 \%}$ average MAP improvements over LSI, FTLR+ and FQETLR+ baselines respectively. The approach demonstrates particular strength in low-coverage scenarios (106.19% average MAP improvement on eANCI). This study establishes novel approaches for LLM-driven traceability link recovery and provides actionable insights for integrating prompt engineering into software lifecycle tools.

Self-Admitted Technical Debt (SATD) is commonly used to refer to suboptimal implementations in software development. Due to constraints such as limited development resources, many developers are unable to repair SATD promptly after introducing it. This challenge has led to research on SATD prioritization, aiming to help developers identify which kind of SATD should be repaired first. However, existing studies lack a standardized definition of prioritization and a systematic study on these SATD. In this paper, we consider a newly-introduced SATD that are repaired before the the next release version to have the highest repair priority, referring to it as short-term SATD. From over 6,500 historical release versions of Open-Source software (OSS), we identified 5,234 instances of short-term SATD and, for the first time, described the distribution of SATD across surviving versions. For all extracted SATD, we characterize them from three dimensions and highlight the differences between short-term SATD and other SATD in these features. Finally, we trained six popular machine learning and deep learning models to explore their performance in identifying short-term SATD and revealed the driving effects of key features on prediction results. These comprehensive research findings provide developers with a transparent basis for SATD repairing.

ABSTRACT As software development grows increasingly complex, application programming interface (API) plays a significant role in enhancing development efficiency and code quality. However, the explosive growth in the number of APIs makes it impossible for developers to become familiar with all of them. In actual development scenarios, developers may spend a significant amount of time searching for suitable APIs, which could severely impact the development process. Recently, the OpenAI's large language model (LLM) based application—ChatGPT has shown exceptional performance across various software development tasks, responding swiftly to instructions and generating high‐quality textual responses, suggesting its potential in API recommendation tasks. Thus, this paper presents an empirical study to investigate the performance of ChatGPT in query‐based API recommendation tasks. Specifically, we utilized the existing benchmark APIBENCH‐Q and the newly constructed dataset as evaluation datasets, selecting the state‐of‐the‐art models BIKER and MULAREC for comparison with ChatGPT. Our research findings demonstrate that ChatGPT outperforms existing approaches in terms of success rate, mean reciprocal rank (MRR), and mean average precision (MAP). Through a manual examination of samples in which ChatGPT exceeds baseline performance and those where it provides incorrect answers, we further substantiate ChatGPT's advantages over the baselines and identify several issues contributing to its suboptimal performance. To address these issues and enhance ChatGPT's recommendation capabilities, we employed two strategies: (1) utilizing a more advanced LLM (GPT‐4) and (2) exploring a new approach—MACAR, which is based on the Chain of Thought methodology. The results indicate that both strategies are effective.

Review comment generation is a crucial task in code review, and significant progress has been made in automating. Previous research has generated review comments by fine-tuning pre-trained models or Large Language Models (LLMs). However, these studies have overlooked the necessity of conducting code reviews from multiple perspectives, resulting in the omission of potential issues in code changes. Additionally, the complexity of review comments often hinders the accurate quantitative evaluation of automated tools’ effectiveness.In this paper, we first conduct an empirical study to propose a comprehensive taxonomy of code review dimensions. We also identify three major limitations of existing automated code review (ACR) methods: lack of comprehensiveness, incorrectness, and vagueness. Building on the insights from our empirical study, we introduce Hydra-Reviewer, a collaborative multi-agent framework powered by large language models, designed to automatically generate high-quality code reviews. We utilize the CodeReview and CodeReviewNew benchmark datasets, along with a newly constructed review comment generation dataset. We compare Hydra-Reviewerwith several baselines, including CodeReviewer, LLaMA-Reviewer, ChatGPT, Comprehensive-ChatGPT, and DeepSeek-V3.The experimental results show that Hydra-Reviewerachieves a BLEU score of 8.20, outperforming the state-of-the-art baseline, DeepSeek-V3, which scores 7.85. In qualitative evaluation, Hydra-Reviewer’s generated comments span an average of 7.8 review dimensions, addressing the limitations of existing ACR methods effectively. Additionally, Hydra-Reviewerdemonstrates strong generalization capabilities on unseen dataset. We further validate the contributions of each component of Hydra-Reviewerthrough an ablation study and confirm the helpfulness and readability of the generated comments via a User Study. Finally, a cost analysis reveals that Hydra-Reviewergenerates review comments at an average cost of 0.018 dollars and 62.63 seconds per code change.

Inconsistent specification are an inevitable intermediate product of a service requirements engineering process. In order to reduce requirements inconsistencies, we propose PASER, a Pattern-based Approach to Service Requirements analysis. The PASER approach first extracts the process information from service documents via natural language processing (NLP) techniques, then uses a requirements modeling language – Workflow-Patterns-based Process Language (WPPL) — to build the process model. Finally, through matching with workflow patterns, the inconsistencies in service requirements are identified and resolved by checking against a set of checking rules. We have conducted a preliminary experiment to evaluate it. An ATM service case study is presented as a running example to illustrate our approach.

Abstract While Problem Frames have become a useful approach for requirements analysis, little research has been made to explore how to derive them from a complex problem context. The purpose of this paper is to propose such an approach. The proposed approach consists of three steps to drive the development of Problem Frames. In the first step, business process models are developed to capture the behavioural view of the problem context. In the second step, object analysis models are used to capture the structural view of the problem context. Together, these two views collectively and adequately capture the early context knowledge. These two types of model will then be used in the third step to construct context diagrams and derive Problem Frames. A complex real‐world problem – equity trading problem – is used to illustrate this approach.

Satisfying quality requirements for service systems is quite crucial and challenging. However, there is a gap between quality requirements analysis and quality requirements design in service systems. In order to bridge this gap, we provide a systematic approach — ProQRASS — to model and analyze quality requirements of services based on business processes, which are frequently used to model services. ProQRASS consists of five steps: (1) constructing business process models; (2) associating quality requirements with functional requirements of services in business process models; (3) identifying potential conflicts and cooperation among quality requirements; (4) filtering out false conflicts and cooperation; (5) resolving conflicts among quality requirements. We illustrate ProQRASS through an equity trading service system. We also evaluate its capability through the comparison with other approaches and conduct a usability investigation involving industrial experts. The result shows that ProQRASS is effective and useful.

QoS-aware service composition intends to integrate services from different providers and maximize the global QoS in order to increase the user's satisfaction degree while subjecting to dynamic context constraints. Current composition approaches only focus on optimizing a single process to maximize the satisfaction degree for one party. When multiple processes are performed concurrently by their selfish users in a dynamic resource-constrained environment, new issues will arise, i.e., undesirable competition for service resources, extra waiting and frequent change of contexts. To address these issues, this paper aims to optimize QoS-aware services composition for multiple selfish users if the communication among users is allowed. Firstly, we propose an extensional QoS-aware service selection model for each process. Then based on this model, we present fault handling mechanisms before and during the execution of concurrent composite services for concurrent processes based on a multi-issue negotiation protocol among agents, and an adaptive context-aware service re-selection mechanism for adjusting the service execution plan for each running composite service in the dynamic resource-constrained environment. Comparative experiments reveal our approach facilitates to increase the average satisfaction degree, reduce the average waiting time of multiple users, and make the satisfaction degrees among multiple users more evenly distributed in the dynamic resource-constrained environment.

SUMMARY Although quality requirements (QRs) have become a major drive in today's software development, there have been very few real‐world examples in the literature that demonstrate how to meet these requirements. This paper presents such an example. Specifically, the paper describes the design of a partition‐based distributed stock trading service system that satisfies a set of QRs related to resource utilization, performance, scalability and availability. The paper evaluates this design through detailed experiments and discusses some design alternatives and the lessons learned. Central to this design are a static load distribution strategy and a dynamic load balancing strategy. The first strategy is to achieve an initial balanced workload on the system's server cluster during the system initialization time, whereas the second strategy is to maintain this balanced workload throughout the system execution time. Together, these two strategies work in unison to ensure that the server resources are efficiently utilized; the user requests are processed with the required speed; the application is partitioned with sufficient room to scale; and the system is highly available. Copyright © 2011 John Wiley & Sons, Ltd.