Continuous Integration (CI) is a fundamental practice in modern software development. It enables early fault detection through regression testing, where Test Case Prioritization (TCP) plays a crucial role in improving detection efficiency. Reinforcement Learning-based TCP (RL-TCP) has shown promise in CI scenarios, but its performance often fluctuates due to CI's dynamic nature. Existing solutions address this by assigning additional rewards or periodically retraining agents. However, these methods either risk over-adjusting strategies due to excessive reliance on additional rewards or fail to respond promptly to changes due to fixed retraining intervals. We propose a novel Environment Adaptation Agent-based RL-TCP method (EAA) that addresses these challenges through a dual mechanism. EAA detects significant environmental changes by analyzing fluctuations in prioritization effectiveness. When a change is detected, it assigns targeted rewards to test cases. EAA also refines the agent's gradient update so that environmental dynamics are better incorporated into retraining. This enables agents to swiftly adapt while retaining learned prioritization knowledge. Evaluations on 12 real-world industrial datasets show that EAA improves the NAPFD metric by 4.7-24.79% and reduces the average TTF by 35.85-50.37 positions compared to state-of-the-art RL-TCP methods. Additionally, EAA significantly reduces occurrences of NAPFD equal to zero, effectively mitigating prioritization instability.

We study the problem of selecting covariates for unbiased estimation of the total causal effect.Existing approaches typically rely on global causal structure learning over all variables, or on strong assumptions such as causal sufficiency - where observed variables share no latent confounders - or the pretreatment assumption, which limits covariates to those unaffected by the treatment or outcome. These requirements are often unrealistic in practice, and global learning becomes computationally prohibitive in high-dimensional settings.To address these challenges, we propose a novel local learning method for covariate selection in nonparametric causal effect estimation that avoids both the pretreatment and causal sufficiency assumptions. We first characterize a local boundary that contains at least one valid adjustment set whenever one exists for identifying the causal effect, and then develop local identification procedures to efficiently search within this boundary.We prove that the proposed method is sound and complete. Experiments on multiple synthetic datasets and two real-world datasets show that our approach achieves accurate causal effect estimation while substantially improving computational efficiency.

Discovering the direct causes and effects of a target variable from observational data is a fundamental problem in causal discovery, with broad applications in domains such as gene regulatory analysis and biomedical research. Existing causal discovery methods either learn a global causal structure, which incurs substantial computational cost, or assume the absence of latent variables and selection bias, assumptions that are often violated in real-world settings. Motivated by these challenges, we study local causal structure learning in the presence of latent variables and selection bias. Specifically, we first characterize a local region that enables target-specific causal discovery without recovering the entire global structure. We then establish a theoretical bridge between causal information learned from the observed distribution induced on this local region and the corresponding information in the global causal structure. Building on these foundations, we propose LoCaLS, a local causal structure learning algorithm that is sound and complete under standard assumptions and identifies the same direct causes and effects of a target variable as those identifiable by global causal discovery methods, while allowing for latent variables and selection bias. Extensive experiments on random and real-world structures demonstrate that the proposed method consistently achieves higher structural accuracy than existing local methods while requiring substantially less computational effort than state-of-the-art global methods. Furthermore, applications to two real-world gene expression datasets reveal biologically plausible target-specific causal structures, demonstrating its practical applicability in large-scale biological data analysis.

Outlier detection has been widely used as a key task in machine learning. Neighborhood-based outlier detec tion methods use neighborhoods and neighborhood relations to uncover latent outlier information embedded within datasets. However, most of these methods take single-granularity samples as the basic processing unit, making them inefficient and susceptible to noise. In addition, this processing method ignores the different lev els of granularity of information potentially available in the raw data, making these methods less complete in their perception of the data. Motivated by the efficiency and robustness of granular-ball representation, we try to utilize granular-balls to construct neighborhoods with multi-granularity property to capture the poten tial multi-granularity information in data. We leverage the granular-ball neighborhood information to propose Granular-Ball Neighborhood Outlier Detection (GBNOD). Granular-ball representation accelerates the detection process and makes GBNOD robust. Multi-granularity granular-ball neighborhoods provide GBNOD with rich out lier information. Specifically, we first measure the outlier degrees of granular-ball neighborhoods under different attribute subsets. These outlier degrees are weighted fused in GBNOD to calculate the outlier scores of granular-balls. We assign the outlier scores of granular-balls to internal samples to measure the outlier degree of the samples. The experimental results demonstrate the superior performance and robustness of our method. The code of GBNOD is publicly available at https://github.com/Mxeron/GBNOD.

Anomaly segmentation seeks to detect and localize unknown or out-of-distribution (OoD) objects that fall outside predefined semantic classes—a capability essential for safe autonomous driving. However, the scarcity and limited diversity of anomaly data severely constrain model generalization in open-world environments. Existing approaches mitigate this issue through synthetic data generation, either by copy-pasting external objects into driving scenes or by leveraging text-to-image diffusion models to inpaint anomalous regions. While these methods improve anomaly diversity, they often lack contextual coherence and physical realism, resulting in domain gaps between synthetic and real data. In this paper, we present ClimaDrive, a semantics-guided image-to-image framework for synthesizing semantically coherent, weather-diverse, and physically plausible OoD driving data. ClimaDrive unifies structure-guided multi-weather generation with prompt-driven anomaly inpainting, enabling the creation of visually realistic training data. Based on this framework, we construct ClimaOoD, a large-scale benchmark spanning six representative driving scenarios under both clear and adverse weather conditions.Extensive experiments on four state-of-the-art methods show that training with ClimaOoD leads to robust improvements in anomaly segmentation. Across all methods, AUROC, AP, and FPR95 show notable gains, with FPR95 dropping from 3.97 to 3.52 for RbA on Fishyscapes LAF. These results demonstrate that ClimaOoD enhances model robustness, offering valuable training data for better generalization in open-world anomaly detection.

Fault localization is a critical phase in software testing and debugging which significantly impacts the efficiency of software fault repair. Existing fault localization research predominantly focuses on the method or statement level, while variable level localization remains less explored. Although variable level techniques offer finer-grained clues closer to root causes, current approaches typically rely on isolated statistical analysis. They fail to capture the complex structural dependencies among program entities, which limits their effectiveness in tracing error propagation. To address this, we propose GVFL, a variable level fault localization method that utilizes graph representation learning to capture complex structural dependencies. It first employs decision trees to select critical variables strongly associated with failures. Then, it constructs a variable relationship graph to capture the dependencies among these variables. Finally, it utilizes graph representation learning to compute suspiciousness scores for fault localization. To evaluate the performance of GVFL, we conduct an empirical study on 835 real faults from the widely used Defects4J v2.0.0 dataset. The results show that GVFL locates a total of 210, 566, and 844 faulty variable positions on Top-1, Top-5, and Top-10 metrics, respectively. It outperforms state-of-the-art FL techniques, including IsoVar, SmartFL, and VarDT. We further analyze the impact of different graph neural network models and variable attributes on GVFL performance. Experimental results indicate that GGAT achieves the best performance for GVFL. Furthermore, all three variable attributes significantly influence the effectiveness of GVFL, with variable value features being the most important.

Application programming interface (API) is an important form and is widely used in software projects in the software reuse field. However, it is not easy for developers to find out the appropriate APIs for their programming tasks, especially for unfamiliar tasks. Technologies that recommend suitable APIs for developers can help a lot. Although those technologies make the process of API reuse more convenient than searching directly on the Web, the recommendation performance still needs to be further improved, especially when a new project starts. How to get as much information as possible is very important. In this paper, we focus on this problem and incorporate multi-source information to improve API recommendation effectively. Here, we propose a new approach, named graph link-based prediction for API recommendation (GLBPAPI), which uses graph neural networks to learn fine-grained representations between APIs and predict potential links inductively based on the API similarity. In addition, we combine the graph link prediction and probability model together as the recommendation engine in GLBPAPI to improve the effectiveness of the API recommendation. We evaluate our approach on 2210 open-source Java projects extracted from GitHub and Maven Central. The experimental results show that it outperforms existing approaches in terms of mean average precision (MAP).

Fault Localization (FL) aims to reduce the cost of manual debugging by highlighting the statements which are more likely responsible for observed failures. However, existing techniques have limited effectiveness in practice due to inflexible suspiciousness evaluations and oversimplified representation of execution information. In this paper, we propose GraMuS, a novel Graph representation learning and Multimodal information based technique for Statement-level FL. GraMuS comprises two key components: a fine-grained fault diagnosis graph and a multilevel collaborative suspiciousness evaluation. The former integrally records enriched multimodal information from various levels of granularity (including methods, statements, and mutants) by a graph structure. The latter utilizes the interactions between FL tasks at various levels of granularity to extract existing/latent useful features from multimodal information for improving FL precision. Empirical studies on the widely used Defects4J(V2.0.0) dataset show that GraMuS can outperform state-of-the-art baselines in both single-fault programs and multiple fault programs, including one large language models, four learning-based FL techniques, three variable-based FL techniques, 36 spectrum-based FL techniques, and 36 mutation-based FL techniques. In particular, GraMuS can localize 26/29/31 more faulty statements than the state-of-the-art baseline ChatGPT-4/DepGraph/VarDT, in terms of TOP-1 metric. Further investigation shows that the method-level FL task can help GraMuS localize 27 more faulty statements, resulting in a 50.94% improvement. Finally, we further evaluate GraMuS in 374 Python programs from ConDefects, and find that GraMuS consistently outperforms state-of-the-art FL techniques, showing its generality.

Context: Mutation-Based Fault Localization (MBFL) using Higher-Order Mutants (HOM) has achieved promising performance in multiple-fault programs by simulating more realistic faults. Despite its effectiveness, it can be extremely costly due to the execution of numerous HOMs. However, existing cost-optimization strategies mainly focus on first-order mutants (FOMs), without considering the dependency relationships between HOMs and multiple program entities. Objective: In this article, we propose a novel strategy called Smart Cost-Optimization through dynamic Prediction and sampling Execution (SCOPE). It aims to reduce costs while providing rich mutation analysis information. Methods: SCOPE contains two key components: a Smart HOM Sampler and a Mutant-Testing Predictor. The former pre-selects the most promising HOMs for each program entity to execute, based on their association with suspicious program entities. The latter employs machine learning to infer the impact of the remaining HOMs on tests using test execution data from selected HOMs, without the need for actual execution. Results: (1) SCOPE outperforms state-of-the-art optimization strategies, including SELECTIVE, SAMPLING, and PMT, regardless of sampling rate or MBFL formulas adopted. (2) SCOPE can reduce the number of involved HOMs by up to 90% without any loss in the performance of MBFL. (3) SCOPE outperforms baseline methods including SBFL, three optimized MBFL techniques (WSOME, SGS, HMBFL) and two deep learning-based fault localization techniques (CNNFL and RNNFL). (4) Ablation Experiment validates that the Smart HOM Sampler and the Mutant-Testing Predictor contribute positively to the effectiveness of SCOPE, with average improvements of 23.60% and 15.14% in TOP-1 and A-EXAM. Additionally, machine learning model comparison for the Mutant-Testing Predictor reveals that compared to the Logistic Regression and Naive Bayes, Random Forest has better prediction performance. Conclusions: Evaluation on 135 real-world multiple-fault programs from the widely used benchmark De-fects4J have shown the effectiveness of our proposed hybrid optimization strategy SCOPE for higher-order mutation-based fault localization.

Software debugging is a critical and time-consuming aspect of software development, with fault localization being a fundamental step that significantly impacts debugging efficiency. Mutation-Based Fault Localization (MBFL) has gained prominence due to its robust theoretical foundations and fine-grained analysis capabilities. However, recent studies have identified a critical challenge: noise phenomena, specifically the false kill relationships between mutants and tests, which significantly degrade localization effectiveness. While several approaches have been proposed to rectify the final localization results, they do not directly address the underlying noise. In this paper, we propose a novel approach to refine the kill matrix, a core data structure capturing mutant-test relationships in MBFL, by treating it as a signal that contains both meaningful fault-related patterns and high-frequency noise. Inspired by signal processing theory, we introduce DKMR (Denoising-based Kill Matrix Refinement), which employs two key stages: (1) signal enhancement through hybrid matrix construction to improve the signal-to-noise ratio for better denoising, and (2) signal denoising via frequency domain filtering to suppress noise while preserving fault-related patterns. Building on this foundation, we develop MBFL-DKMR, a fault localization framework that utilizes the refined matrix with fuzzy values for suspiciousness calculation. Our evaluation on Defects4J v2.0.0 demonstrates that MBFL-DKMR effectively mitigates the noise and outperforms the state-of-the-art MBFL techniques. Specifically, MBFL-DKMR achieves 129 faults localized at Top-1 compared to 85 for BLMu and 103 for Delta4Ms, with negligible additional computational overhead (0.11 seconds, 0.001% of total time). This work highlights the potential of signal processing techniques to enhance the effectiveness of MBFL by refining the kill matrix.

The rapid proliferation of highly realistic AI-generated images poses serious security threats such as misinformation and identity fraud. Detecting generated images in open-world settings is particularly challenging when they originate from unknown generators, as existing methods typically rely on model-specific artifacts and require retraining on new fake data, limiting their generalization and scalability. In this work, we propose Post-hoc Distribution Alignment (PDA), a generalized and model-agnostic framework for detecting AI-generated images under unknown generative threats. Specifically, PDA reformulates detection as a distribution alignment task by regenerating test images through a known generative model. When real images are regenerated, they inherit model-specific artifacts and align with the known fake distribution. In contrast, regenerated unknown fakes contain incompatible or mixed artifacts and remain misaligned. This difference allows an existing detector, trained on the known generative model, to accurately distinguish real images from unknown fakes without requiring access to unseen data or retraining. Extensive experiments across 16 state-of-the-art generative models, including GANs, diffusion models, and commercial text-to-image APIs (e.g., Midjourney), demonstrate that PDA achieves average detection accuracy of 96.69

Mutation-based Fault Localization (MBFL) has been widely explored for automated software debugging, leveraging artificial mutants to identify faulty code entities. However, MBFL faces significant challenges due to interference mutants generated from non-faulty code entities but can be killed by failing tests. These mutants mimic the test sensitivity behaviors of real faulty code entities and weaken the effectiveness of fault localization. To address this challenge, we introduce the concept of Fault Localization Interference Mutants (FLIMs) and conduct a theoretical analysis based on the Reachability, Infection, Propagation, and Revealability (RIPR) model, identifying four distinct interference causes. Building on this, we propose a novel approach to semantically recognize and mitigate FLIMs using LLM-based semantic analysis, enhanced by fine-tuning techniques and confidence estimation strategies to address LLM output instability. The recognized FLIMs are then mitigated by refining the suspiciousness scores calculated from MBFL techniques. We integrate FLIM recognition and mitigation into the MBFL workflow, developing MBFL-FLIM, a fault localization framework that enhances MBFL's effectiveness by reducing misleading interference while preserving real fault-revealing information. Our empirical experiments on the Defects4J benchmark with 395 program versions using eight LLMs demonstrate MBFL-FLIM's superiority over traditional SBFL and MBFL methods, advanced dynamic feature-based approaches, and recent LLM-based fault localization techniques. Specifically, MBFL-FLIM achieves an average improvement of 44 faults in the Top-1 metric, representing a significant enhancement over baseline methods. Further evaluation confirms MBFL-FLIM's robust performance in multi-fault scenarios, with ablation experiments validating the contributions of the fine-tuning and confidence estimation components.

Fault localization is one of the most challenging and time-consuming tasks in software debugging. Traditional methods, such as Spectrum-Based Fault Localization (SBFL) and Mutation-Based Fault Localization (MBFL), rely on coverage or mutation outcomes to rank suspicious program elements. However, these methods are limited by their reliance on a single type of information, which often fails to capture the full complexity of fault propagation. In particular, they fail to fully utilize structural semantics, especially contextual relationships among functions, which are key to understanding fault propagation. To address these limitations, we propose EMS-HFL (Execution-Mutation-Structural Hybrid Fault Localization), a method that systematically synergy three categories of information: execution behavior (i.e., coverage data), mutation behavior (i.e., mutant outcomes), and structural semantics (i.e., function call chains). Coverage data and mutant outcomes contribute basic fault information, while function call chains capture the broader execution context that helps better measure the suspiciousness of methods. Empirical evaluations on 262 faulty versions from the Defects4J benchmark show that EMS-HFL successfully localizes 90 faults at the Top-1 position, outperforming SBFL, MBFL, and other advanced hybrid approaches. Ablation studies confirm that each information source (coverage, mutation, and structural semantics) is crucial, with their combination significantly boosting performance.

Recent years have witnessed growing interest in adopting large language models (LLMs) for Register Transfer Level (RTL) code optimization. While powerful cloud-based LLMs offer superior optimization capabilities, they pose unacceptable intellectual property (IP) leakage risks when processing proprietary hardware designs. In this paper, we propose a new scenario where Verilog code must be optimized for specific attributes without leaking sensitive IP information. We introduce the first IP-preserving edge-cloud collaborative framework that leverages the benefits of both paradigms. Our approach employs local small LLMs (e.g., Qwen-2.5-Coder-7B) to perform secure comparative analysis between paired high-quality target designs and novice draft codes, yielding general design principles that summarize key insights for improvements. These principles are then used to query stronger cloud LLMs (e.g., Deepseek-V3) for targeted code improvement, ensuring that only abstracted and IP-safe guidance reaches external services. Our experimental results demonstrate that the framework achieves significantly higher optimization success rates compared to baseline methods. For example, combining Qwen-2.5-Coder-7B and Deepseek-V3 achieves a 66.67% optimization success rate for power utilization, outperforming Deepseek-V3 alone (49.81%) and even commercial models like GPT-4o (55.81%). Further investigation of local and cloud LLM combinations reveals that different model pairings exhibit varying strengths for specific optimization objectives, with interesting trends emerging when varying the number of comparative code pairs. Our work establishes a new paradigm for secure hardware design optimization that balances performance gains with IP protection.

This paper evaluates the secure level of authenticated encryption Ascon against cube-like method. Ascon submitted by Dobraunig et al. is one of 16 survivors of the 3rd round CAESAR competition. The cube-like method is first used by Dinur et al. to analyze Keccak keyed modes. At CT-RSA 2015, Dobraunig et al. applied this method to 5/6-round reduced Ascon, whose structure is similar to Keccak keyed modes. However, for Ascon the non-linear layer is more complex and state is much smaller, which make it hard for the attackers to select enough cube variables that do not multiply with each other after the first round. This seems to be the reason why the best previous key-recovery attack is on 6-round Ascon, while for Keccak keyed modes (Keccak-MAC and Keyak) the attacked round is no less than 7-round. In this paper, we generalize the conditional cube attack proposed by Huang et al., and find new cubes depending on some key bit conditions for 5/6-round reduced Ascon, and translate the previous theoretic 6-round attack with 2^66 time complexity to a practical one with 2^40 time complexity. Moreover, we propose the first 7-round key-recovery attack on Ascon. By introducing the cube-like key-subset technique, we divide the full key space into many subsets according to different key conditions. For each key subset, we launch the cube tester to determine if the key falls into it. Finally, we recover the full key space by testing all the key subsets. The total time complexity is about 2^103.9. In addition, for a weak-key subset, whose size is 2^117, the attack is more efficient and costs only 2^77 time complexity. Those attacks do not threaten the full round (12 rounds) Ascon.

Large Language Models (LLMs) have demonstrated remarkable performance in code completion. However, the training data used to develop these models often contain a significant amount of buggy code. Yet, it remains unclear to what extent these buggy instances influence LLMs' performance when tackling bug-prone code completion tasks. To fill this gap, this paper presents the first empirical study evaluating the performance of LLMs in completing bug-prone code. Through extensive experiments on 7 LLMs and the Defects4J dataset, we analyze LLMs' accuracy, robustness, and limitations in this challenging context. Our experimental results show that completing bug-prone code is significantly more challenging for LLMs than completing normal code. Notably, in bug-prone tasks, the likelihood of LLMs generating correct code is nearly the same as generating buggy code, and it is substantially lower than in normal code completion tasks (e.g., 12.27 surprise, 44.44 version, indicating that LLMs have been seriously biased by historical bugs when completing code. Additionally, we investigate the effectiveness of existing post-processing techniques and find that while they can improve consistency, they do not significantly reduce error rates in bug-prone code scenarios. Our research highlights the limitations of current LLMs in handling bug-prone code and underscores the need for improved models and post-processing strategies to enhance code completion accuracy in real-world development environments.

Code generation has gained increasing attention as a task to automate software development by transforming high-level descriptions into executable code. While large language models (LLMs) are effective in generating code, their performance heavily relies on the quality of input prompts. Current prompt engineering methods involve manual effort in designing prompts, which can be time-consuming and yield inconsistent results, potentially constraining the efficacy of LLMs in practical applications. This paper introduces Prochemy, a novel approach for automatically refining prompts iteratively to enhance code generation. Prochemy addresses the limitations of manual prompt engineering by automating the optimization process, ensuring prompt consistency during inference, and aligning with multi-agent systems. It iteratively refines prompts based on model performance, using an optimized final prompt to improve consistency and reliability across tasks. We evaluate Prochemy on both natural language-based code generation and code translation tasks using three series of LLMs. Results show that when combining Prochemy with existing approaches, it outperforms baseline prompting methods. It achieves improvements of 5.0% (GPT-3.5-Turbo) and 1.9% (GPT-4o) over zero-shot baselines on HumanEval. For the state-of-the-art LDB, Prochemy + LDB outperforms standalone methods by 1.2-1.8%. For code translation, Prochemy elevates GPT-4o's performance on Java-to-Python (AVATAR) from 74.5 to 84.1 (+12.9%) and Python-to-Java from 66.8 to 78.2 (+17.1%). Furthermore, considering that the o1-mini model integrates prompt engineering techniques, Prochemy can continue to show good performance among it, further validating its effectiveness in code generation and translation tasks. Additionally, Prochemy is designed to be plug-and-play, optimizing prompts with minimal human intervention and seamlessly bridging the gap between simple prompts and complex frameworks.

Context: Fault Localization (FL) is an important and tedious phase of software debugging. Among various FL techniques, Mutation-Based Fault Localization (MBFL) demonstrates promising FL accuracy utilizing impact information of statements provided by First-Order-Mutants (FOMs). Despite its success in Single-Fault Scenarios (SFSs), it fails to achieve satisfactory performance in Multiple-Fault Scenarios (MFSs). Higher-Order-Mutants (HOMs) provide a solution for MFSs. However, existing work on HOM generation is inadequate and ignores the correlation among faults in MFSs. Objective: In this article, we systematically analyze three relationships among single-faults in MFSs, and further propose three HOM generation methods (i.e., SFClu, SFDis, and SFDen) to simulate different multiple-faults and improve the effectiveness of MBFL in MFSs. Method: We investigate the multiple-fault composition on real-world 393 faulty programs from Defects4J, and then apply our methods to generate HOMs for FL. Specifically, SFClu focuses on generating appropriate HOMs for Multi-Single-Source Fault (MSSF) scenarios, where each single-fault is responsible for different observed failures. SFDis is well-suited for Multi-Coupled-Source Fault (MCSF) scenarios where at least two single-faults can interact with each other, leading to certain failures either being observable or masked. SFDen aims to generate suitable HOMs for Single-Coupled-Source Fault (SCSF) scenarios with multiple single-faults that occur within a statement. Results: (1) The proportion of MFSs is as high as 63.10% in real-world programs, with MSSF, MCSF , and SCSF scenarios accounting for 35.08%, 53.23%, and 11.69%, respectively. (2) Compared to the best-performing mutant generation method Neural-MBFL, SFClu, SFDis, and SFDen can improve the FL performance for MBFL by 36.78%, 49.80%, and 16.36% in Top-1, respectively, outperforming eight established SBFL and MBFL techniques. (3) SFClu, SFDis, and SFDen are more suitable for MSSF, MCSF, and SCSF scenarios, respectively, which aligns with their design intend. (4) Their combination further enhances FL accuracy, achieving up to 85 faults successfully localized and an average improvement of 29.54% in Top-1. Finally, extensive evaluations on SIR with artificial faults and Codeflaws containing student programs demonstrate the generalization of SFClu, the applicability of SFDis on real faults, and the suitability of SFDen for student programs. Conclusion: Empirical studies have confirmed the prevalence of MFSs, highlighting the significance of multi-fault localization. Moreover, our proposed three HOM generation methods can further enhance the performance of MBFL with HOMs in MFSs, showing their effectiveness and applicability.

Recent advancements in code large language models (LLMs) have demonstrated remarkable capabilities in code generation and understanding. It is still challenging to build a code LLM with comprehensive performance yet ultimate efficiency. Many attempts have been released in the open source community to break the trade-off between performance and efficiency, such as the Qwen Coder series and the DeepSeek Coder series. This paper introduces yet another attempt in this area, namely Ling-Coder-Lite. We leverage the efficient Mixture-of-Experts (MoE) architecture along with a set of high-quality data curation methods (especially those based on program analytics) to build an efficient yet powerful code LLM. Ling-Coder-Lite exhibits on-par performance on 12 representative coding benchmarks compared to state-of-the-art models of similar size, such as Qwen2.5-Coder-7B and DeepSeek-Coder-V2-Lite, while offering competitive latency and throughput. In practice, we achieve a 50% reduction in deployment resources compared to the similar-sized dense model without performance loss. To facilitate further research and development in this area, we open-source our models as well as a substantial portion of high-quality data for the annealing and post-training stages. The models and data can be accessed at .

Event-based vision sensors efficiently capture changes in motion in a scene in real time. Unlike traditional camera principles, event cameras only report pixel-level brightness changes with low latency, low redundancy, and high dynamic range. Therefore, cameras have been widely used in image processing, computer vision, state estimation and other research directions. This paper explains the basic principles and structure of event cameras, compares three typical event cameras, and analyzes their respective advantages and application scenarios. Secondly, this paper reviews the application of event cameras in the research directions of event stream noise reduction, feature extraction, object detection, depth estimation, visual SLAM, optical flow estimation and multi-sensor fusion, summarizes the advantages and disadvantages of event cameras, and evaluates and prospects its development prospects in different application scenarios. Finally, its future development trend is discussed.