Rethinking Code Refinement: Learning to Judge Code Efficiency (2024.findings-emnlp)
Copied to clipboard
| Challenge: | Large Language Models (LLMs) have shown impressive capabilities in understanding and generating codes. |
| Approach: | They propose a method that is trained to judge the efficiency between two different versions of code by either classifying the superior one or predicting the relative improvement. |
| Outcome: | The proposed method can distinguish between more and less efficient versions of code on multiple programming languages with multiple refinement steps. |
Similar Papers
ECCO: Can We Improve Model-Generated Code Efficiency Without Sacrificing Functional Correctness? (2024.emnlp-main)
Copied to clipboard
| Challenge: | Current methods for optimizing program efficiency improve performance measured by execution time, but they often come at the cost of severely decreasing the functional correctness. |
| Approach: | They propose a reproducible benchmark for evaluating program efficiency via two paradigms: natural language (NL) based code generation and history-based code editing. |
| Outcome: | The proposed approach improves performance while maintaining correctness while adding execution information. |
Measuring What Matters: Evaluating Ensemble LLMs with Label Refinement in Inductive Coding (2025.findings-acl)
Copied to clipboard
| Challenge: | Large language models (LLMs) are prone to inconsistencies and individual biases, limiting their reliability. |
| Approach: | They propose a framework that combines ensemble methods with code refinement methodology to address these challenges. |
| Outcome: | The proposed framework outperforms large language models and LLMs with a low-rank averaging and a moderator-based mechanism to simulate human consensus. |
TRACE: Evaluating Execution Efficiency of LLM-Based Code Translation (2026.acl-long)
Copied to clipboard
| Challenge: | Large Language Models (LLMs) have improved the functional correctness of code translation, but execution efficiency remains overlooked. |
| Approach: | They propose a benchmark to explicitly assess execution efficiency in LLM-translated code. |
| Outcome: | The proposed benchmark identifies that execution efficiency is an essential dimension of code translation . the results highlight that correctness and efficiency are often misaligned . |
The ART of LLM Refinement: Ask, Refine, and Trust (2024.naacl-long)
Copied to clipboard
Kumar Shridhar, Koustuv Sinha, Andrew Cohen, Tianlu Wang, Ping Yu, Ramakanth Pasunuru, Mrinmaya Sachan, Jason Weston, Asli Celikyilmaz
| Challenge: | Large Language Models (LLMs) have demonstrated remarkable generative abilities, but can they judge the quality of their own generations and self-improve? |
| Approach: | They propose a reasoning with a refinement strategy called *ART: Ask, Refine, and Trust* that asks necessary questions to decide when an LLM should refine its output and uses it to affirm or deny trust. |
| Outcome: | The proposed reasoning with a refinement strategy achieves a performance gain of +5 points over baselines on two multistep reasoning tasks. |
Current Advances in LLM Reasoning (2026.acl-tutorials)
Copied to clipboard
| Challenge: | This tutorial examines comprehensive evaluation strategies to assess the reasoning abilities of large language models (LLMs) advanced inference time methods and post-training methods that aim to make LLMs think more like humans are discussed in this tutorial. |
| Approach: | This tutorial explores comprehensive evaluation strategies to assess the reasoning abilities of large language models (LLMs) and discusses two types of methods to improve models’ reasoning: advanced inference time methods, structured and self-improvement inference methods, and post-training methods, such as RLHF, DPO, and GRPO. |
| Outcome: | This tutorial examines evaluation strategies to assess the reasoning abilities of large language models and discusses two types of methods to improve models’ reasoning. |
CodeReviewQA: The Code Review Comprehension Assessment for Large Language Models (2025.findings-acl)
Copied to clipboard
| Challenge: | State-of-the-art large language models (LLMs) have demonstrated impressive code generation capabilities but struggle with real-world software engineering tasks such as revising source code to address code reviews. |
| Approach: | They propose a benchmark to evaluate large language models' ability to bridge both technical and conversational contexts by decomposing the generation task of code refinement into three essential reasoning steps. |
| Outcome: | The proposed benchmark exposes specific model weaknesses in code review comprehension disentangled from their generative automated code refinement results. |
CoDet-M4: Detecting Machine-Generated Code in Multi-Lingual, Multi-Generator and Multi-Domain Settings (2025.findings-acl)
Copied to clipboard
| Challenge: | Large Language Models (LLMs) have revolutionized code generation but have significant consequences for programming skills, ethics, and assessment integrity. |
| Approach: | They propose a framework capable of distinguishing between human-written and LLM-generated program code across multiple programming languages, code generators, and domains. |
| Outcome: | The proposed framework distinguishes between human-written and LLM-generated program code across multiple programming languages, code generators, and domains. |
What can Large Language Models Capture about Code Functional Equivalence? (2025.findings-naacl)
Copied to clipboard
| Challenge: | SeqCoBench is a benchmark to assess how Code-LLMs can capture code semantics. |
| Approach: | They propose a benchmark to assess how Code-LLMs capture code semantics . they use seqCoBench to evaluate whether they can discern semantically equivalent or different pairs of programs . |
| Outcome: | The proposed benchmarks show that they can capture code semantics better than classical match-based retrieval scores. |
Turning the Tide: Repository-based Code Reflection (2025.findings-emnlp)
Copied to clipboard
| Challenge: | Code large language models (LLMs) enhance programming by understanding and generating code across languages. |
| Approach: | a new benchmark evaluates code understanding and generation in repositories using code large language models. |
| Outcome: | The proposed model improves code understanding and generation in repositories by evaluating 1,888 test cases across 6 programming languages. |
Cross-Refine: Improving Natural Language Explanation Generation by Learning in Tandem (2025.coling-main)
Copied to clipboard
| Challenge: | Natural language explanations (NLEs) are vital for elucidating the reasoning behind large language model (LLM) decisions. |
| Approach: | They propose a role-modeling approach that employs two LLMs as generator and critic to generate and refine NLEs. |
| Outcome: | The proposed model outperforms self-refine and can perform with less powerful LLMs. |