While Large Language Models (LLMs) excel at code generation, their inherent tendency toward verbatim memorization of training data introduces critical risks like copyright infringement, insecurity emission, and deprecated API utilization, etc. A straightforward yet promising defense is unlearning, i.e., erasing or down-weighting the offending snippets through post-training. However, we find its application to source code often tends to spill over, damaging the basic knowledge of programming languages learned by the LLM and degrading the overall capability. To ease this challenge, we propose PROD for precise source code unlearning. PROD surgically zeroes out the prediction probability of the prohibited tokens, and renormalizes the remaining distribution so that the generated code stays correct. By excising only the targeted snippets, PROD achieves precise forgetting without much degradation of the LLM's overall capability. To facilitate in-depth evaluation against PROD, we establish an unlearning benchmark consisting of three downstream tasks (i.e., unlearning of copyrighted code, insecure code, and deprecated APIs), and introduce Pareto Dominance Ratio (PDR) metric, which indicates both the forget quality and the LLM utility. Our comprehensive evaluation demonstrates that PROD achieves superior overall performance between forget quality and model utility compared to existing unlearning approaches across three downstream tasks, while consistently exhibiting improvements when applied to LLMs of varying series. PROD also exhibits superior robustness against adversarial attacks without generating or exposing the data to be forgotten. These results underscore that our approach not only successfully extends the application boundary of unlearning techniques to source code, but also holds significant implications for advancing reliable code generation.

Chung-ju Huang, Huiqiang Zhao, Yuanpeng He, Lijian Li, Wenpin Jiao, Zhi Jin, Peixuan Chen, Leye Wang. Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers). 2026.

Xue Jiang, Yihong Dong, Mengyang Liu, Deng Hongyi, Tian Wang, Yongding Tao, Zhi Jin, Wenpin Jiao, Ge Li. Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers). 2026.

Xue Jiang, Ge Li, Jiaru Qian, Xianjie Shi, Chenjie Li, Hao Zhu, Ziyu Wang, Jielun Zhang, Zeyu Zhao, Kechi Zhang, Jia Li, Wenpin Jiao, Zhi Jin, Yihong Dong. Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers). 2026.

In self-adaptive software systems, the role of context is paramount, especially for proactive self-adaptation. Current research, however, does not fully explore context's impact, for example on priorities of the requirements. To address this gap, we introduce a novel contextual goal model to capture these factors and their influence on the system. Using this, we propose a two-layer control mechanism with a context-aware model predictive control to achieve proactive adaptation for the software system and adaptation for the controller itself. By contextual prediction and a more accurate system model, our approach utilizes model predictive control to facilitate timely and efficient system adaptations, improving both performance and adaptability. Meanwhile, we perform requirement adaptation to update the contextual goal model, which in turn updates the objective function and constraints of the controller. Our experimental evaluations across two scenarios demonstrate the significant benefits of our approach in enhancing system performance.

Although current semi-supervised medical segmentation methods can achieve decent performance, they are still affected by the uncertainty in unlabeled data and model predictions, and there is currently a lack of effective strategies that can explore the uncertain aspects of both simultaneously. To address the aforementioned issues, we propose Evidential Prototype Learning (EPL), which utilizes an extended probabilistic framework to effectively fuse voxel-level evidential predictions from different classifiers and achieves prototype fusion utilization of labeled and unlabeled data under a generalized evidential framework, leveraging voxel-level dual uncertainty masking. The uncertainty measure not only enables the model to self-correct predictions but also improves the guided learning process with pseudo-labels and is able to feed back into the construction of hidden features. The method proposed in this paper has been experimented on LA, Pancreas-CT and TBAD datasets, achieving the state-of-the-art performance in three different labeled ratios, which strongly demonstrates the effectiveness of our strategy. The source code will be made publicly available.

Although existing semi-supervised image segmentation methods have achieved good performance, they cannot effectively utilize multiple sources of voxel-level uncertainty for targeted learning. Therefore, we propose two main improvements. First, we introduce a novel pignistic co-evidential fusion strategy using generalized evidential deep learning , extended by traditional D–S evidence theory, to obtain a more precise uncertainty measure for each voxel in medical samples. This assists the model in learning mixed labeled information and establishing semantic associations between labeled and unlabeled data. Second, we introduce the concept of information volume of mass function (IVUM) to evaluate the constructed evidence, implementing two evidential learning schemes. One optimizes evidential deep learning by combining the information volume of the mass function with original uncertainty measures. The other integrates the learning pattern based on the co-evidential fusion strategy, using IVUM to design a new optimization objective. Experiments on four datasets demonstrate the competitive performance of our method.

Cross-hospital collaboration has the potential to mitigate disparities in medical resources across different regions. However, strict privacy regulations prohibit the direct sharing of sensitive patient information between hospitals. Vertical Federated Learning (VFL) provides a novel privacy-preserving machine learning paradigm designed to maximizes data utility across multiple hospitals. Nevertheless, traditional VFL methods primarily benefit patients with overlapping data, leaving non-overlapping patients without guaranteed improvements in distributed healthcare prediction services. While some existing knowledge transfer techniques attempt to improve prediction performance for non-overlapping patients, they fail to adequately address scenarios where overlapping and non-overlapping patients originate from different domains, resulting in challenges such as feature and label heterogeneity. To address these issues, we propose UniTrans, a unified vertical federated knowledge transfer framework for edge healthcare collaboration. Our framework consists of three key steps. First, we extract the federated representation of overlapping patients by employing an effective vertical federated representation learning method to model multi-party joint features online. Next, each hospital learns a local knowledge transfer module offline, enabling the domain-adaptive transfer of knowledge from the federated representation of overlapping patients to the enriched representation of local non-overlapping patients. Finally, hospitals utilize these enriched local representations to enhance performance across various downstream medical prediction tasks. Extensive experiments on real-world medical datasets demonstrate the effectiveness and scalability of UniTrans in both intra-domain and cross-domain knowledge transfer. The code of UniTrans is available athttps://github.com/Chung-ju/Unitrans.

Existing semi-supervised medical segmentation co-learning frameworks have realized that model performance can be diminished by the biases in model recognition caused by low-quality pseudo-labels. Due to the averaging nature of their pseudo-label integration strategy, they fail to explore the reliability of pseudo-labels from different sources. In this paper, we propose a mutual evidential deep learning (MEDL) framework that offers a potentially viable solution for pseudo-label generation in semi-supervised learning from two perspectives. First, we introduce networks with different architectures to generate complementary evidence for unlabeled samples and adopt an improved class-aware evidential fusion to guide the confident synthesis of evidential predictions sourced from diverse architectural networks. Second, utilizing the uncertainty in the fused evidence, we design an asymptotic Fisher information-based evidential learning strategy. This strategy enables the model to initially focus on unlabeled samples with more reliable pseudo-labels, gradually shifting attention to samples with lower-quality pseudo-labels while avoiding over-penalization of mislabeled classes in high data uncertainty samples. Additionally, for labeled data, we continue to adopt an uncertainty-driven asymptotic learning strategy, gradually guiding the model to focus on challenging voxels. Extensive experiments on five mainstream datasets have demonstrated that MEDL achieves state-of-the-art performance.

Weakly supervised temporal action localization (WS-TAL) is a task of targeting at localizing complete action instances and categorizing them with video-level labels. Action-background ambiguity, primarily caused by background noise resulting from aggregation and intra-action variation, is a significant challenge for existing WS-TAL methods. In this paper, we introduce a hybrid multi-head attention (HMHA) module and generalized uncertainty-based evidential fusion (GUEF) module to address the problem. The proposed HMHA effectively enhances RGB and optical flow features by filtering redundant information and adjusting their feature distribution to better align with the WS-TAL task. Additionally, the proposed GUEF adaptively eliminates the interference of background noise by fusing snippet-level evidences to refine uncertainty measurement and select superior foreground feature information, which enables the model to concentrate on integral action instances to achieve better action localization and classification performance. Experimental results conducted on the THUMOS14 dataset demonstrate that our method outperforms state-of-the-art methods. Our code is available in https://github.com/heyuanpengpku/GUEF/tree/main.

Although large language models (LLMs) have demonstrated impressive ability in code generation, they are still struggling to address the complicated intent provided by humans. It is widely acknowledged that humans typically employ planning to decompose complex problems and schedule solution steps prior to implementation. To this end, we introduce planning into code generation to help the model understand complex intent and reduce the difficulty of problem-solving. This paper proposes a self-planning code generation approach with large language models, which consists of two phases, namely planning phase and implementation phase. Specifically, in the planning phase, LLM plans out concise solution steps from the intent combined with few-shot prompting. Subsequently, in the implementation phase, the model generates code step by step, guided by the preceding solution steps. We conduct extensive experiments on various code-generation benchmarks across multiple programming languages. Experimental results show that self-planning code generation achieves a relative improvement of up to 25.4% in Pass@1 compared to direct code generation, and up to 11.9% compared to Chain-of-Thought of code generation. Moreover, our self-planning approach also enhances the quality of the generated code with respect to correctness, readability, and robustness, as assessed by humans.

Graph database engines stand out in the era of big data for their efficiency of modeling and processing linked data. To assure high quality of graph database engines, it is highly critical to conduct automatic test generation for graph database engines, e.g., random test generation, the most commonly adopted approach in practice. However, random test generation faces the challenge of generating complex inputs (i.e., property graphs and queries) for producing non-empty query results; generating such type of inputs is important especially for detecting wrong-result bugs. To address this challenge, in this paper, we propose GDsmith, the first approach for testing Cypher graph database engines. GDsmith ensures that each randomly generated query satisfies the semantic requirements. To increase the probability of producing complex queries that return non-empty results, GDsmith includes two new techniques: graph-guided generation of complex pattern combinations and data-guided generation of complex conditions. Our evaluation results demonstrate that GDsmith is effective and efficient for producing complex queries that return non-empty results for bug detection, and substantially outperforms the baselines. GDsmith successfully detects 28 bugs on the released versions of three highly popular open-source graph database engines and receives positive feedback from their developers.

Modern software systems need to maintain their goals in a highly dynamic environment, which requires self-adaptation. Many existing self-adaptive approaches are reactive, they execute the adaptation behavior after the goal violation. However, proactive adaptation can adapt before the goal violation to avoid adverse consequence so it has attracted more and more attention. Model predictive control is a widely used method to implement proactive adaptation. However, these works often ignore uncertainty of environment, which makes the prediction of the system inaccurate and affect the control effectiveness. Therefore, we propose an environment-aware model predictive control method. Its main idea is to add the environment state to the system model, predict the future state of the system according to the predicted environment state and the current state of the system, and solve the optimal control strategy. We use a web application simulation platform to evaluate our method. The results show that our method can achieve better adaptation results and reduce the occurrence of goal violation.

In order to help users get the source code in SO directly, this paper proposes a question-driven source code recommendation service based on the source code in Stack Overflow(SO). The service utilizes a question-code matching model to recommend users source code snippets which can solve the development problems users encounter. We evaluate the recommendation accuracy of the recommendation service and verify its feasibility. This service outperforms other approaches on recommendation accuracy, and the effectiveness of the service is also discussed.

Modern software runs in a dynamic, uncertain environment, and should satisfy multiple goals simultaneously. In order to allow software to respond to changes in the environment or user requirements and meet user goals continuously, an effective solution is to make the software self-adaptive. The adaptation capacity of software is provided by rules. As the complexity of self-adaptive software grows, designing and managing adaptation rules becomes increasingly challenging. To tackle this problem, some methods have been proposed to obtain adaptation rules automatically at runtime. However, these methods don't take the changes of user requirements into account sufficiently. When the user's preference of goals changes at runtime, adaptation rules usually need to be generated from scratch. It may produce huge computation cost. To overcome this limitation, we propose a multi-goal oriented approach for adaptation rules generation. This approach ensures that we can efficiently generate adaptation rules. We apply the approach to an unmanned underwater vehicles system. The experimental results show that our method is practical and highly-efficient in software reconfiguration under changing user's preference of goals.

The development of self-adaptive software has attracted a lot of attention. Decentralization is an effective way to manage the complexity of modern self-adaptive software systems. However, there are still tremendous challenges remained in decentralized self-adaptive systems. One major challenge is to guarantee the achievements of both local goals and global goals. Another challenge is to ensure the performance of the systems operating in highly dynamic environments with existence of internal changes. To solve these problems, we introduce an integrated system framework combining self-adaptive mechanisms with decentralization features, with a formal modeling method based on stochastic timed automata to allow the system to be analyzed and verified. Timed computational tree logic is used to specify the system properties and then stochastic simulations in a dynamic environment are conducted to study system performance. The whole approach is illustrated and evaluated with a motivation example from practical applications in UAV emergency mission scenarios.

Abstract In distributed and open environments, MASs (multiagent systems) generally have no mechanisms for prior coordination and self‐organization has been believed to be the necessary selection to achieve the coordination of agents. This paper first presents a values‐driven model for self‐organization in which the expected emergent properties of a system are specified as the social values while the social values are realized via implicitly inducing members to regulate their individual values and adjust their behaviors to fit the expectations of the system. Based on the values‐driven self‐organization, this paper proposes an automated coordination mechanism for decentralized MASs. In this mechanism, by indirectly changing the difficulties in acquiring resources (which may be delegated to some special agents since MASs generally do not have substantial bodies), MASs can lead agents to regulate their values to be consistent with the social values of MASs so that the coordination of MASs can spontaneously emerge from the local behaviors of agents. Finally, this paper implements a simulation traffic system using the coordination mechanism based on values‐driven self‐organization to validate the emergence of coordination among multiple agents.

Software systems need constantly maintaining or adapting to continuously meet the changing business requirements. The process of maintenance or adaptation is software evolution. In general, people hope to evaluate software evolution for guiding software maintenances. By evaluating how well software maintenances follow the positive evolutionary trends, developers can assert whether it is necessary to redevelop or even refactor newly released or maintained versions of software to enforce the software evolution back on track. In this paper, we propose an approach to evaluating software evolution based on API usage patterns, which are the accumulations and summarizations of people's software design and development experience. In the approach, better software evolution is considered as the process of reusing more usage patterns, and software evolution is evaluated based on how well software reuses usage patterns in the process of evolution. Our work consists of three parts. First, we use a graph-based algorithm to mine usage patterns from different open-source software. Second, we use the patterns to evaluate the evolutions of software systems and accordingly analyze the important changes during software evolution. Third, we compare different approaches and analyze which approach can reflect the process of software evolution accurately. Our experiments on several open source programs show that our approach is more effective than other approaches on identifying the great change events during software evolution.

MOOCs are popular for online education because of its convenience and excellent educational resources. At present, MOOCs just provide very limited online practical environments such as online tests, quizzes and online judge etc., but they have not provided students with some dynamic and operable online practical environments, such as interactive education tools etc. Online education tools can satisfy the needs of online practicing, mainly because of its abundance, interactivity and convenience, but MOOCs have not made full use of these online tools yet. The paper proposes an approach to using existing online education tools to support practical education on MOOCs by two enhancements: educational resources development and real-time collaborative learning. The key to the approach is operation reuse, which involves recording, optimizing and replaying user operations on existing online educations tools. Based on the approach, we develop an education platform called Smart Web Tutor. Case study is performed to analyze user experience, and the results show that our approach contributes to students' learning, especially for real-time collaborative learning. Also, some suggestions from students are inspiring to further increase the utility and user experience of our approach and education platform.

The Internetware system is a complex and distributed self-adaptive system, which executes in an open, uncertain and dynamic environment, and adapts itself to changes in the environment. We hope that Internetware systems have the ability to automatically evolve in respond to changes. An important problem related to the development of Internetware systems is how to formulate proper adaptation rules. Because of the uncertainty of environment, the adaptation rules may not be suitable to the current system. Adaptation rules always need to be evolved to obtain better results. Some traditional methods can decide adaptation actions in different environmental conditions and evolve adaptation rules. But most of these methods bring about huge computation cost, which are not highly-efficient. To resolve these problems, we propose a method for evolving adaptation rules automatically, based on genetic algorithm and linear regression. We apply this method to evolve adaptation rules for a web application based on a widely used prototype --- RUBiS, which is an auction site similar to eBay. Experiments show that our method can evolve adaptation rules and improve the web application's performance in dynamic environment.

Web-based IDEs are more and more popular because developers can create or modify software artifacts in the browser without need to install any local development tool and spend valuable development time on system setup and maintenance. For those development tasks using a Web-based IDE, such as configuring programming context and batch test etc., some are frequent and repetitive because they are similar from project to project. Automating the repetitive tasks on Web-based IDEs, regardless of their complexity, would reduce the amount of work that developers must perform to complete the tasks, which would improve the development efficiency of Web applications. In this paper, we put forward a user-friendly approach to automating repetitive tasks on existing Web-based IDEs. The key to the approach is to extend the basic Web-based capture-replay technique with editable and reusable features, which are necessary for automation because some operations are redundant, as well as developers should recognize and define repetitive tasks. Moreover, we develop a supporting tool for the approach. In the case study, we introduce how the approach is used to support automating repetitive tasks on Web-based IDEs. Case studies verify that the approach can improve the development efficiency very well.

Online education plays a more and more important role in the era of Internet and cloud computing, but two problems remain unsolved including MOOCs. First, most of existing online education platforms only provide teaching materials in format of ppt, pdf, video, and they seldom support education based on graphical Web applications. Second, some online education platforms may provide self-governed chatting tools or whiteboards, but they are not combined with teaching materials closely. As a result, they cannot satisfy the need for the real-time interactions based on complex teaching materials. To solve the problems above, we put forward an online education approach using Web operation record and replay techniques, and implement online synchronized education and real-time interactions between teachers and students. Moreover, we develop a supporting tool OSEP for the approach. In the case study, we describe three education scenarios, which verify that the approach supports not only personal learning by tutorials and wizards, but also online in-class real-time collaborative learning.

In the field of Internet of Things (IoT), with the emergence of intelligent sensors (also called mote) which are programmable and have certain capabilities of computation and communication, there are more and more researches focusing on how to develop IoT applications on motes. How to develop high quality mote applications efficiently and provide supporting tools has become a great challenge. Because the quality of an mote application is strongly relevant to the behavior patterns of the mote (a behavior pattern in this work is referenced to a commonly occurring way of performing actions of the mode, which resides in the program framework, i.e., the code structure of the program, of the mote application), this paper studies how to design behavior patterns for mote applications, which will act as guidelines for implementing programs, to improve the QoS of applications. This paper first summarizes a collection of fundamental behavior patterns which can be often found in mote applications and then analyzes the relationships between quality properties and behavior patterns of mote applications based on a series of experiments. It also demonstrates how to design code structures to realize the expected behavior patterns in mote applications for improving the QoS of mote applications.

It is a great challenge to evaluate self-adaptive software rigorously. This paper first discusses the key aspects of adaptation of software and points out that the adaptation level of a software system is determined by how well the system satisfies the user's expectations through adjusting its behavior or configuration to tackle the changes in the environment. Accordingly, the paper puts forward a mathematical measurement for adaptation levels of software systems. Secondly, the paper presents a formal method for evaluating the efficiencies of adaptation mechanisms. The method also takes into consideration the aspects of satisfactions with the users' expectations, the environment, and the time that the system takes adaptation actions to stabilize its performance. Finally, this paper implements a simulation traffic system for validating the measurements.

Nowadays the concept of IoT is blooming, and the front-end of IoT applications, which is made up by intelligent sensors (here we call them mote), can be seen as a kind of Internetware (here we call this kind of Internetware "mote applications"). Therefore, how to develop high-quality mote applications efficiently and provide supporting tools has become a great challenge. Because the quality of an mote application is strongly relevant to the behavior patterns of the mote (a behavior pattern in this work is referenced to a commonly occurring way of performing actions of the mode, which resides in the programming framework, i.e., the code structure of the program, of the mote application), this paper studies how to design behavior patterns for mote applications, which will act as guidelines for implementing programs, to improve the QoS of applications. This paper first summarizes a collection of fundamental behavior patterns which can be often found in mote applications and then analyzes the relationships between quality properties and behavior patterns of mote applications based on a series of experiments. It also demonstrates how to design code structures to realize the expected behavior patterns in mote applications for improving the QoS of mote applications.

In multi‐agent cooperation, the agents will cooperate efficiently if they can accurately anticipate the behavior of their partners. In this work, we put forward a framework (called as transpositional thinking principle) for reasoning about and predicting the behavior of others and propose an approach to planning the cooperation among agents based on the principle. By using the principle, agents can richen their understanding about the behavior patterns of their partners and then infer their partners' actions more and more accurately. The experiments show that the cooperation among agents will be performed more efficiently and at a low cost when agents can anticipate the behavior of others with a high enough accuracy.

In decentralized computing environments, systems are built mainly from components that are developed and maintained independently by different third-party providers. The executions and evolutions of components located on distributed sites are beyond the control of the system developers, and the availabilities of those components are, to some extent, unpredictable because of their own tendencies and the unstable network. As a result, it is still a great challenge to construct high-available decentralized systems. In this paper, a self-adaptive component model is proposed to model those components distributed on the Internet and a running framework is described for constructing systems composed of self-adaptive components. Self-adaptive components can adjust their knowledge about the availabilities of the required services via learning from the feedback of historical invocations. Based on the knowledge, components can find the most appropriate service providers effectively and automatically. Experiments show that systems can always gain high availabilities under dynamic decentralized environments by using the approach.

In cooperative software systems, the interconnection relationships between components are often dynamic and unpredictable and therefore connectors have to be created dynamically. In this paper, we bring forward the concept of dynamic architectural connector to provide dynamic interconnectivities for components. This paper proposes an automated approach based on software agents to generate dynamic connectors. In the approach, dynamic interaction relationships are established via negotiations and dynamic connectors are generated automatically as high-order entities via taking the behavior specifications and the ontologies of components as arguments. Based on the formal study on the interconnectivities of components, the approach is proved competent for generating dynamic connectors that can satisfy the requirements for providing correct dynamic interconnectivities for components.

Due to the widespread trust threat under the open and dynamic Internet environment, the computer community has endeavored to engage in the studies of technologies for protecting and evaluating trustworthiness. This paper firstly defines trust from three aspects: trust relationship, trust property and trust entity, and build a uniform view for multiple trust properties. Secondly, according to abstract the common characteristics over varied trust properties, a model of trust management is elaborated, in which the trust entities, measurement model and trust policy are described. Thirdly, the trust management is implemented as a kind of public service on a J2EE-compliant middleware platform, i.e., the PKUAS.

The continuous requirements of evolving a delivered software system and the rising cost of shutting down a running software system are forcing researchers and practitioners to find ways of updating software as it runs. Dynamic update is a kind of software evolution that updates a running program without interruption. This paper covers the fundamental issues of the mechanisms of dynamic update theoretically. Based on a similarity analysis of many typical approaches to dynamic update during the past decades, we propose a unified formal model (namely, Dynamic Update Connector) to specify mechanisms of updating an architectural component, and reason about its properties. The model borrows the concept of connectors from software architecture community and is specified using process algebra CSP. We also demonstrate the applications of our DUC model.

During component composition, mismatches may occur on different aspects, such as interaction behaviors between components and features imposed by architectural styles. In this paper, we studied architectural mismatches related to connecting components using a specified architectural style, which implies that the connections supported by components may be incompatible with the connection supposed by the architectural style. First, we formalized components involved in different architectural styles in the pi-calculus. Next, we studied the formal foundation of the interconnectivity between components to exploit under what situation two heterogeneous components are possible to interconnect together properly. Then, we described an adaptor-based solution for composing components supporting different architectural styles by introducing the notation of negative component. In the end of this paper, we presented an agent-based implementation for the solution, in which agents are used to wrap components and can automatically transform messages specific to one architectural style into messages specific to another style by using architectural style-specific knowledge that agents possess.

Mutual-belief is one important premise to ensure that cooperation among multiple agents goes smoothly. However, mutual-belief among agents is also always taken for granted. In this paper, we adapt a method based on the position-exchange principle (PEP) to reason about mutual-belief among agents. By reasoning about mutual-belief among agents, we can judge whether cooperation among agents can go on rationally or not. However, if there are malicious agents involved in cooperation, the profit of honesty agents will be injured. To make cooperation useful, agents should be able to reason about cheating behaviors of malicious agents during cooperation. We extend the standard pi-calculus to specify the expectations of agents and define a group of criteria for anti-cheating that agents can use to establish true mutual-belief.