acceptodds
Under review as a conference paper at ICLR 2027

A Bit at a Time: Sparse Delta Updates for Indexing Fast-Evolving Codebases

Abstract

Modern code retrieval systems increasingly operate over codebases that evolve continuously: functions are reformatted, locally edited, refactored, or rewritten while preserving their underlying intent. Standard retrieval pipelines usually treat each version as an independent target, optimizing ranking quality but ignoring whether related versions can share stable index-facing representational structure. We study this problem as efficient continual code retrieval, where a model should retrieve a behaviorally similar version of a code object while enabling representation and index reuse across code evolution. To evaluate this setting, we construct CODECONTINUUM-R, an evolution-aware benchmark built by expanding standard code-search examples into version families that span surface-level rewrites, local structural edits, and higher-level refactorings. Surprisingly, we find that sparse representations already provide a strong foundation for this setting: their active latent supports form discrete routing signatures that remain substantially shared across evolved code variants while maintaining competitive retrieval quality. Building on this observation, we propose continuality-preserved sparse coding, which augments sparse autoencoder training with two lightweight evolution-aware regularizers: a neuron-overlap regularizer that encourages behaviorally similar variants to activate shared Top-K latents, and an activation-order regularizer that preserves the relative priority of shared active neurons. Across Jina-Code-Embedding and Qwen3-Embedding backbones, our method improves sparse-support overlap and activation-order consistency while largely preserving retrieval accuracy. These improvements enable more compact neuron-reuse storage and more reliable small-budget routing in multi-stage sparse retrieval for evolving codebases.

Primary area:
unsupervised, self-supervised, semi-supervised, and supervised representation learning
Keywords:
code search, sparsity, retrieval

Reviews

Among:
Shape:
1234this paper, Top 4%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.33 over 3 reviews, above 96% of the others.
Reviewer_Eb9EOpenReview ↗
Rating
3(+1)
Confidence
2
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

This paper investigates efficient continual code retrieval, where different versions of the same code may share reusable representations and indexing structures. The authors introduce CODECONTINUUM-R, a benchmark that simulates code changes. Building on the observation that sparse representations naturally exhibit high neuron overlap across code revisions, they introduce two regularization objectives to encourage shared active neurons and consistent activation ordering across versions. Experiments on Jina-Code and Qwen3-Embedding backbones demonstrate that the proposed method improves representation stability, reduces index memory consumption, and enhances multi-stage retrieval under limited routing budgets, while largely preserving retrieval accuracy.

Critical strengths

Using a Sparse AutoEncoder for retrieval is quite popular recently. This paper provides a good perspective on how version changes of the same code block affect SAE's activated neurons. The paper highlights the potential of exploiting sparse representation consistency to improve indexing efficiency in continuously evolving codebases.

Critical weaknesses

One critical concern for me is the application scenarios for this paper. In this paper, the author assumes that the old and new versions of the same code will exist in the codebase at the same time. But in software development, developers often overwrite the old code.

Questions for authors

During rebuttal, I expect the authors to justify the application scenarios of their studied research questions. Once convincing, I will definitely increase my score.

3 comments

We thank Reviewer Eb9E for recognizing the value of sparse representation consistency and its indexing benefits. We acknowledge the concern that developers often overwrite previous implementations. We clarify that our work targets revision-retaining retrieval, including multi-branch, multi-release, and historical code search, supported by real-world Git revisions and system-level indexing evaluations.


W1 & Q1: What are the practical application scenarios that justify the coexistence of multiple code versions in real-world software development?

W1: One critical concern for me is the application scenarios for this paper. In this paper, the author assumes that the old and new versions of the same code will exist in the codebase at the same time. But in software development, developers often overwrite the old code.

Q1: During rebuttal, I expect the authors to justify the application scenarios of their studied research questions. Once convincing, I will definitely increase my score.

A1: We thank the reviewer for raising this important concern. We agree that developers often overwrite old code in the working tree. However, our work targets retrieval settings where multiple revisions need to remain accessible, particularly:

  1. Multi-branch and multi-release code search: Different branches and releases retain distinct implementations.
  2. Historical code retrieval and repository analysis: Earlier implementations support regression debugging, code evolution analysis, and change tracing.

Our experiments support this setting::

  • Real-world code evolution: As shown in Table I (Appendix D.3), across seven real Git repositories, naturally occurring revisions exhibit high sparse-support overlap (94.56%–98.88%) and stable routing structure, demonstrating opportunities for representation reuse beyond synthetic revisions.
  • Practical indexing benefits: As shown in Table II (Appendix E), integrating revision-aware grouping with Seismic reduces total index storage by 44.2% at 10K anchors and 33.9% at 50K anchors, while maintaining nearly identical retrieval quality.

Table I: Sparse Representation Reuse Across Real-World Git Revisions.

RepositoryPair Num.Lexical Sim.Overlap@32Route@4 PreservedMemory Saving
Mixed50000.98990.98090.999273.57%
Django50000.98490.97200.999672.90%
FastAPI17790.97720.94560.997070.92%
pandas50000.98920.97870.999673.40%
pytest26210.98160.96430.997872.32%
PyTorch50000.99110.98390.999873.79%
scikit-learn50000.99190.98220.999473.67%
Transformers50000.99360.98880.999874.16%

Table II: Storage Efficiency and Retrieval Performance of Revision-Aware Indexing with Seismic.

AnchorsMethodnDCG@10Recall@100Engine BytesResidual BytesTotal Bytesp50 Latency
10KExhaustive0.96180.99205489844–548984416.2859 ms
10KSeismic-Full-NL0.96180.992021521009–215210093.8077 ms
10KSeismic-Group-NL0.96190.992285536093457643120112522.3968 ms
50KExhaustive0.92240.982127409844–2740984477.6055 ms
50KSeismic-Full-NL0.92240.982170141614–701416146.4656 ms
50KSeismic-Group-NL0.92220.98242906015117281664463418156.5308 ms

We have clarified these application scenarios and the scope of our assumptions in Sections 1 and 2.1 of the revised paper. We further highlight the practical indexing benefits in Section 5.3, supported by real-world Git revision analysis (Appendix D.3, Table 16) and Seismic-based system evaluation (Appendix E.3, Table 19).


We sincerely thank Reviewer Eb9E for the valuable feedback. We have provided additional clarifications that directly address the points raised, and have incorporated these improvements into the revised submission. If the reviewer finds the revisions helpful, we would greatly appreciate a reconsideration of the rating. We are truly grateful for your time and thoughtful evaluation.

I thank the authors for their responses, and I am sorry for the late reply. My concern for the application scenario is well addressed. Thus, I will raise my score.

Dear Reviewer Eb9E:

We sincerely thank you for your thoughtful feedback and for taking the time to reconsider our work. We are glad that our clarification has addressed your concern regarding the practical application scenarios. We greatly appreciate your constructive comments and support.

Authors

Reviewer_CbhDOpenReview ↗
Rating
4
Confidence
3
Informativeness
3
Presentation
2
Soundness
2
Read review
Paper summary

This paper addresses the challenge of efficient continual code retrieval, where codebase contents continuously evolve through formatting, local edits, and structural refactorings while their underlying semantic intent remains largely stable. The authors introduce a new benchmark that organizes code changes into three progressive levels of transformation: surface edits (Level I), local AST-level mutations (Level II), and language-model-driven refactorings (Level III). The paper demonstrates that vanilla Sparse Autoencoders trained on top of dense code embeddings already exhibit a high degree of natural revision consistency.

The authors propose continuality-preserved sparse coding, which substantially improves support overlap and activation-order consistency across Jina and Qwen backbones, while largely preserving standard retrieval performance on multiple downstream out-of-domain datasets.

Critical strengths

The paper identifies and formalizes an important, underexplored problem in modern code search. Addressing index reuse and stability across code evolution is highly practical and consequential.

The design of the proposed benchmark is highly systematic. By categorizing evolution into three distinct tiers, the authors isolate and test retrieval stability under increasingly complex and realistic edit types.

The authors demonstrate practical system-level utility of their proposed approach, with notable index storage savings from integration with a state-of-the-art sparse ANN engine.

Critical weaknesses

Although the motivation is general to software engineering, the benchmark and the evaluation are entirely restricted to Python code, with Python-specific tools central to the data generation. The paper lacks validation on statically typed compiled languages (like C++, Go, or Rust).

Questions for authors

How easily can the data generation and evaluation framework be extended to other widely used programming languages?

1 comment

We sincerely thank Reviewer CbhD for the encouraging and constructive feedback, and for recognizing the importance of continual code retrieval, the systematic design of our evolution-aware benchmark, and the practical storage benefits demonstrated through integration with a sparse ANN engine. We particularly appreciate the reviewer's insightful observation regarding the generalizability of our framework beyond Python and its applicability to statically typed programming languages. We agree that broader language coverage is important for establishing the practical scope of our approach. In the following, we clarify how the framework can be extended to other languages and present additional evaluations on 70000 real Git revision pairs from 14 C++ and Go repositories.


W1 & Q1: How generalizable is the proposed data generation and evaluation framework beyond Python to other programming languages?

W1: Although the motivation is general to software engineering, the benchmark and the evaluation are entirely restricted to Python code, with Python-specific tools central to the data generation. The paper lacks validation on statically typed compiled languages (like C++, Go, or Rust).

Q1: How easily can the data generation and evaluation framework be extended to other widely used programming languages?

A1: Thank you for highlighting this important direction. While our current benchmark focuses on Python, the proposed framework is largely language-agnostic.

To further validate cross-language applicability, we conducted additional experiments on 14 widely used C++ and Go repositories, collecting 35,000 real Git revision pairs per language. Unlike the Python benchmark, these revisions are extracted directly from commit histories without relying on language-specific generation tools. As shown in Table I, we evaluate our Qwen3-Embedding-4B model with two regularizations using Overlap@32 and AOC@32. The consistently high overlap and activation-order consistency across both languages demonstrate that our approach extends beyond Python to statically typed, compiled languages.

Table I: Cross-Language Validation on Natural Git Revisions.

LanguageRepositoryOverlap@32AOC@32
C++gRPC0.95720.9568
LLVM0.95170.9504
MongoDB0.94940.9473
OpenCV0.95460.9531
PyTorch0.95230.9517
QtBase0.96360.9645
TensorFlow0.97250.9716
Goetcd0.96040.9613
Hugo0.95200.9568
Go0.95790.9603
Terraform0.95510.9578
Kubernetes0.95510.9586
Moby0.95690.9598
Prometheus0.96240.9619

For the full benchmark generation pipeline, only the language-specific components (LibCST/Cosmic Ray transformations and refactoring prompts) need to be adapted. The sparse-coding framework, regularization objectives, and evaluation metrics remain unchanged. We have included the cross-language evaluation in Section 5.3, with detailed repository-level results in Appendix D.6 (Table 18). Appendix D.6 also discusses the language-specific adaptations required to extend the full benchmark generation pipeline.


We sincerely thank Reviewer CbhD for the valuable feedback. We have provided additional clarifications and new experiments that directly address the points raised, and have incorporated these improvements into the revised submission. We hope that these revisions and responses fully address your comments. We are truly grateful for your time, careful reading, and constructive insights.

Reviewer_XNmMOpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper focuses on the efficient retrieval problem in continuously evolving code libraries. Different versions of the code have redundant storage, resulting in high costs for index storage and maintenance. The paper proposes an evolutionary consistent sparse coding method to enhance the stability of sparse features between different versions and achieve index reuse and efficient retrieval. The paper constructs the dataset by using surface modifications, local AST mutations, and LLM reconstruction. Through experiments, it is found that the sparse representation naturally has a high cross-version feature overlap rate, but there are problems of activation support set drift and priority drift. Thus, neuron overlap regularization and activation order consistency regularization are proposed to improve the degree of feature sharing and sorting stability. Through experiments and real code version generalization experiments, it is verified that the method can improve the stability of sparse representation, reduce index storage, and improve the retrieval effect with a small budget, while basically maintaining the retrieval accuracy.

Critical strengths
  1. This paper addresses an important but relatively less explored issue: how to efficiently search for code within an evolving codebase. The proposed CODECONTINUUM-R benchmark test covers three levels of code evolution, providing a useful framework for evaluating representation stability and index reuse.

  2. The proposed regularization method effectively improves the sparse support overlap and activation sequence consistency between code revisions. Extensive experiments, including ablation studies, memory analysis, and real-world code revision evaluation, demonstrate that this method enhances index reuse and retrieval performance with a small budget while maintaining retrieval quality.

Critical weaknesses

1: The author believes that all the codes within the same version of the family are related documents, but certain code conversions may alter the original meaning. Although the author has conducted semantic verification, the average test pass rates for the second and third levels are 88.96% and 93.43% respectively. This still cannot guarantee that all the evolved versions conform to the original query. This may affect the reliability of the relevance labels in the retrieval process, thereby influencing the experimental conclusion. 2. The two regularization terms proposed by the author mainly introduce cross-version consistency constraints based on the existing sparse coding technology. The innovation at the method level is relatively limited. Although the experiments show that this method can improve representation stability, reduce index storage overhead, and improve the performance of multi-stage retrieval with a small budget, Table 3 shows that most of the storage savings mainly come from the version reuse mechanism, while the additional storage benefits brought by the two regularization terms are relatively limited.

Questions for authors

1.The paper regards all the codes within the same version family as the relevant results of the original query. However, the author also acknowledges that the code variations in Level II may alter the program behavior. Although Table 5 verified the consistency of behavior, the paper still failed to fully explain how to ensure the correlation between these evolved codes and the original query. The author should clarify the basis for determining the correlation labels and explain whether potential label deviations may affect the main retrieval results. 2. Although the paper evaluated the index memory usage and query delay through Seismic in Appendix E and discussed the index update cost of traditional methods in Section 3.1, it has not directly assessed the incremental index update delay and computational cost in the continuous code evolution scenario. Can the author further explain whether the proposed method has advantages over traditional index methods in terms of index update delay and computational cost when the code versions continue to be added or modified?

2 comments

We thank Reviewer XNmM for the constructive feedback and for recognizing the importance of retrieval in evolving codebases, the systematic design of CODECONTINUUM-R, and the effectiveness of our approach. We acknowledge the concerns regarding relevance-label reliability, regularizer contributions, and incremental indexing costs. Below, we clarify our design choices and provide additional experiments on label robustness and indexing efficiency.


W1 & Q1: How can the reliability of relevance labels be ensured despite potential semantic changes in evolved code variants?

 W1: The author believes that all the codes within the same version of the family are related documents, but certain code conversions may alter the original meaning. Although the author has conducted semantic verification, the average test pass rates for the second and third levels are 88.96% and 93.43% respectively. This still cannot guarantee that all the evolved versions conform to the original query. This may affect the reliability of the relevance labels in the retrieval process, thereby influencing the experimental conclusion.

Q1: The paper regards all the codes within the same version family as the relevant results of the original query. However, the author also acknowledges that the code variations in Level II may alter the program behavior. Although Table 5 verified the consistency of behavior, the paper still failed to fully explain how to ensure the correlation between these evolved codes and the original query. The author should clarify the basis for determining the correlation labels and explain whether potential label deviations may affect the main retrieval results.

A1: Thank you for raising this point. We agree that execution tests cannot guarantee semantic equivalence and that some variants may deviate from the original query. We clarify our relevance-label definition and provide additional robustness experiments.

Our benchmark evaluates retrieval over evolving codebases, where changes such as refactoring and bug fixes may alter program behavior. Thus, relevance is defined by version-family membership rather than strict semantic equivalence. We clarify this definition in Sections 2.2–2.3 and report a robustness analysis in Section 5.1 and Appendix B (Table 7).

To directly assess whether behavior-changing variants affect our conclusions, we conduct additional evaluations using the execution tests reported in Table 6 of the revised paper. We compare three relevance-label settings:

  • Original: All versions within the same family are considered relevant, as in the original paper.
  • Test-filtered: Only the original code and evolved variants passing all available execution tests are considered relevant, while other variants are removed
  • Random-filtered: The same number of evolved variants as in Test-filtered are randomly retained, controlling for the effect of reducing the positive set.

We evaluate the same trained models on identical evaluation samples under all three settings, covering both embedding backbones and four sparse-coding configurations (Vanilla, R1, R2, and R1+R2) at K=32. Retrieval quality is measured using nDCG@10.

Table I: Retrieval performance in three relevance-label settings.

BackboneMethodOriginalTest-filteredRandom-filtered
Jina-Code-1.5BVanilla0.912690.890650.89505
R10.909870.904670.89019
R20.911530.902380.89746
R1+R20.914770.905780.89757
Qwen3-4BVanilla0.921320.907300.90934
R10.918490.913430.90282
R20.927560.906280.90197
R1+R20.932840.911720.90865

As shown in Table I, retrieval performance remains largely stable across relevance-label settings. Test-filtered outperforms Random-filtered in six of eight configurations, suggesting that execution-based filtering differs from randomly reducing the positive set. These results support the robustness of our main conclusions to potential relevance-label deviations. We have discussed these results in Table 7 (Appendix B) of the revised paper.

(continue below)

W2: How do the proposed regularization terms contribute to methodological novelty and storage efficiency beyond the existing sparse coding and version reuse mechanisms?

The two regularization terms proposed by the author mainly introduce cross-version consistency constraints based on the existing sparse coding technology. The innovation at the method level is relatively limited. Although the experiments show that this method can improve representation stability, reduce index storage overhead, and improve the performance of multi-stage retrieval with a small budget, Table 3 shows that most of the storage savings mainly come from the version reuse mechanism, while the additional storage benefits brought by the two regularization terms are relatively limited.

A2: Thank you for raising this point. We agree that most storage savings come from revision-level index reuse rather than regularization. The regularizers complement our broader contributions.

Our key contribution is identifying naturally emerging revision-consistent latent structures in sparse code representations, enabling index reuse overlooked by conventional version-independent indexing. CODECONTINUUM-R provides a controlled setting for studying this property, while real Git revisions and cross-framework code pairs support its generality. The regularizers further improve sparse-support overlap and activation-order consistency, with a modest trade-off in full-budget retrieval accuracy.

We have clarified this distinction in Sections 3.2 and 5.2 of the revised paper. In particular, Section 3.2 emphasizes the naturally emerging sparse reuse property, while Section 5.2 distinguishes the dominant storage savings from index reuse (Table 3) from the additional benefits of regularization for multi-stage retrieval (Table 4).


Q2: How does the proposed method compare with traditional indexing approaches in terms of incremental update latency and computational cost under continuous code evolution?

Although the paper evaluated the index memory usage and query delay through Seismic in Appendix E and discussed the index update cost of traditional methods in Section 3.1, it has not directly assessed the incremental index update delay and computational cost in the continuous code evolution scenario. Can the author further explain whether the proposed method has advantages over traditional index methods in terms of index update delay and computational cost when the code versions continue to be added or modified?

A3:Thank you for the suggestion. We conducted an additional experiment to measure index update latency and computational cost under continuous code evolution, extending the Seismic evaluation in Appendix E.

We sample 10,000 code families from CODECONTINUUM-R Level III, each with one original and three revisions. Starting from 10,000 originals, we add 10,000 revisions per step, reaching 40,000 snapshots. We compare Seismic-Full-NL (independent revision indexing) with Seismic-Group-NL (ours, reusing family representatives and updating sparse residuals/metadata). Both use Qwen3-Embedding-4B, Top-K = 32, and identical update streams. Timing covers query-visible updates, including residual computation, writes, and synchronization, but excludes embedding and sparse-code inference.

Table II. Incremental Index Update Efficiency under Continuous Code Evolution.

MethodUpdate latency (ms/revision)CPU time (ms/revision)Write volume (bytes/revision)Final index size (MB)
Seismic-Full-NL0.35210.3949859.6134.331
Seismic-Group-NL (Ours)0.04040.0393111.9613.177

As shown in Table II, our method reduces update latency by 88.5%, CPU time by 90.0%, write volume by 87.0%, and final index size by 61.6%. These results demonstrate lower index maintenance costs under continuous code evolution. We added the results to Section 5.3 (Table 5).


We sincerely thank Reviewer XNmM for the valuable feedback. We have provided additional clarifications and new experiments that directly address the points raised, and have incorporated these improvements into the revised submission. We hope that these revisions and responses fully address your comments. We are truly grateful for your time, careful reading, and constructive insights.

Comments on the paper

2 comments
AuthorsOpenReview ↗

Paper Update

We sincerely thank all reviewers for their careful reading, constructive feedback, and valuable suggestions. We have carefully addressed the concerns raised in the reviews and incorporated corresponding clarifications and additional evaluations into the revised manuscript, expanding the main text from 9 to 10 pages. All revisions and additions are highlighted in blue for ease of reference. The main updates are summarized below:

Abstract: Refined the description of continual code retrieval to clarify the retrieval objective over evolving code revisions.

Section 1 (Introduction) [Reviewer Eb9E: W1, Q1]: Clarified the practical motivation for retaining multiple code versions, particularly in multi-branch, multi-release, and historical code retrieval scenarios.

Section 2 (Setup and Benchmark) [Reviewer Eb9E: W1, Q1; Reviewer XNmM: W1, Q1]: Clarified the scope of revision-retaining retrieval and the rationale for version-family relevance, distinguishing evolutionary relationships from strict semantic equivalence.

Section 3.2 (Revision-Consistent Sparse Coding) [Reviewer XNmM: W2]: Further emphasized that sparse representations naturally exhibit reusable structures across code revisions, and that the proposed regularizers strengthen this existing property rather than create index reuse from scratch.

Section 5.1 (Benchmark Performance) [Reviewer XNmM: W1, Q1]: (new) Added a robustness analysis under three relevance-label settings (Original, Test-filtered, and Random-filtered) to assess the impact of potential behavioral deviations on retrieval conclusions.

Section 5.2 (Empirical Analysis) [Reviewer XNmM: Q2]: Clarified the respective contributions of neuron-reuse storage and evolution-aware regularization, distinguishing the primary storage savings from the additional benefits for limited-budget multi-stage retrieval.

Section 5.3 (Practical Evaluation of Revision-Aware Indexing and Cross-Language Generalization) [Reviewer CbhD: W1, Q1]: (new) Expanded the practical evaluation with:

  • System-level index reuse: Highlighted the Seismic-based evaluation, demonstrating 33.9%–44.2% reductions in total index storage while maintaining comparable retrieval quality.
  • Incremental index maintenance: Added a continuous code evolution experiment (Table 5), showing 88.5% lower update latency, 90.0% lower CPU time, 87.0% lower write volume, and 61.6% smaller final index size compared with independent revision indexing.
  • Cross-language generalization: Added evaluations on 70000 real Git revision pairs from 14 C++ and Go repositories, demonstrating consistently high sparse-support overlap and activation-order consistency beyond Python.

Appendix B [Reviewer XNmM: W1, Q1]: (new) Added detailed evaluation protocols and results for relevance-label robustness (Table 7), complementing the existing execution-test-based semantic validation (Table 6).

Appendix D.6 [Reviewer CbhD: W1, Q1]: (new) Added cross-language validation on natural C++ and Go Git revisions, including repository-level results (Table 18) and discussion of generalizability beyond Python-specific code transformations.

Section 6 (Conclusion) [Reviewer Eb9E: W1, Q1; Reviewer CbhD: W1, Q1; Reviewer XNmM: W2, Q2]: Updated the concluding discussion to reflect the additional evidence from real-world Git revisions, cross-language evaluations, and practical system-level experiments.

We hope these revisions and additional results address the reviewers' concerns and provide a clearer understanding of the motivation, methodological contributions, robustness, and practical applicability of our work.

AuthorsOpenReview ↗

Rebuttal Summary

Dear Program Chairs, Senior Area Chairs, Area Chairs, and Reviewers,

We sincerely thank the Program Chairs, Senior Area Chairs, and Area Chairs for their dedicated efforts in coordinating the review process, and all Reviewers for their careful evaluations and constructive feedback. We greatly appreciate their recognition of the importance of continual code retrieval, the systematic design of CODECONTINUUM-R, and the practical benefits of our approach.

During the rebuttal and discussion period, we conducted additional experiments and strengthened our manuscript to address the reviewers' concerns. We summarize the key revisions and discussion outcomes below.

Additional Experiments. Following the reviewers' suggestions, we conducted several new experiments and incorporated the results into the revised submission:

  1. Relevance-label robustness analysis under different relevance-label settings, now presented in Section 5.1 and Appendix B (Table 7). (Raised by Reviewer XNmM)
  2. Incremental index update efficiency evaluation under continuous code evolution, covering update latency, computational cost, and storage overhead, now presented in Section 5.3 (Table 5). (Raised by Reviewer XNmM)
  3. Cross-language validation on real Git revisions from C++ and Go repositories, now presented in Section 5.3 and Appendix D.6 (Table 18). (Raised by Reviewer CbhD)
  4. Real-world code revision analysis and system-level indexing evaluation with Seismic, now presented in Appendix D.3 (Table 16) and Appendix E.3 (Table 19). (Raised by Reviewer Eb9E)

Additional Clarifications. Beyond experimental extensions, we further clarified the methodological contributions and practical applicability of our work:

  1. Clarification of the relevance-label definition and the potential impact of behavior-changing revisions, now included in Sections 2.2–2.3. (Raised by Reviewer XNmM)
  2. Clarification of the distinct contributions of naturally emerging sparse consistency, revision-level index reuse, and the proposed regularizers, now highlighted in Sections 3.2 and 5.2. (Raised by Reviewer XNmM)
  3. Discussion of the language-specific adaptations required to extend the benchmark generation framework beyond Python, now included in Appendix D.6. (Raised by Reviewer CbhD)
  4. Clarification of practical application scenarios involving multiple code revisions, including multi-branch code search and historical code retrieval, now included in Sections 1 and 2.1. (Raised by Reviewer Eb9E)

Discussion Outcome. We appreciate the constructive feedback and positive evaluations from all three reviewers:

  • Reviewer CbhD (4, Clear Acceptance) recognized the importance of our problem and benchmark design. We addressed the concern regarding cross-language generalizability through additional experiments and clarifications.
  • Reviewer XNmM (3, Weak Acceptance) raised concerns about relevance-label reliability, methodological novelty, and incremental indexing efficiency, which we addressed through additional experiments and methodological clarifications.
  • Reviewer Eb9E (2 to 3, Weak Reject to Weak Accept) explicitly confirmed that "My concern for the application scenario is well addressed. Thus, I will raise my score." We sincerely appreciate this positive reassessment.

The current ratings are 4/3/3, with all three reviewers providing positive recommendations. We believe the additional experiments and clarifications have substantially strengthened our work and addressed the key concerns raised during the review process.

We sincerely thank the Program Chairs, Senior Area Chairs, Area Chairs, and all Reviewers once again for their time, dedication, and valuable contributions.

Best regards,

Authors

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.