Tootfinder

Are We SOLID Yet? An Empirical Study on Prompting LLMs to Detect Design Principle Violations
Fatih Pehlivan, Ar\c{c}in \"Ulk\"u Erg\"uzen, Sahand Moslemi Yengejeh, Mayasah Lami, Anil Koyuncu
https://arxiv.org/abs/2509.03093

Are We SOLID Yet? An Empirical Study on Prompting LLMs to Detect Design Principle Violations
Traditional static analysis methods struggle to detect semantic design flaws, such as violations of the SOLID principles, which require a strong understanding of object-oriented design patterns and principles. Existing solutions typically focus on individual SOLID principles or specific programming languages, leaving a gap in the ability to detect violations across all five principles in multi-language codebases. This paper presents a new approach: a methodology that leverages tailored prompt e…

Regression Language Models for Code
Yash Akhauri, Xingyou Song, Arissa Wongpanich, Bryan Lewandowski, Mohamed S. Abdelfattah
https://arxiv.org/abs/2509.26476 https://

Regression Language Models for Code
We study code-to-metric regression: predicting numeric outcomes of code executions, a challenging task due to the open-ended nature of programming languages. While prior methods have resorted to heavy and domain-specific feature engineering, we show that a single unified Regression Language Model (RLM) can simultaneously predict directly from text, (i) the memory footprint of code across multiple high-level languages such as Python and C++, (ii) the latency of Triton GPU kernels, and (iii) the …

ChatGPT in Introductory Programming: Counterbalanced Evaluation of Code Quality, Conceptual Learning, and Student Perceptions
Shiza Andleeb, Brandon Kantorski, Jeffrey C. Carver
https://arxiv.org/abs/2510.00946

ChatGPT in Introductory Programming: Counterbalanced Evaluation of Code Quality, Conceptual Learning, and Student Perceptions
Background: Large language models (LLMs) such as ChatGPT are increasingly used in introductory programming courses to provide real-time code generation, debugging, and explanations. While these tools can boost productivity and code quality, concerns remain about over-reliance and potential impacts on conceptual learning. Objective: To investigate how ChatGPT access affects code quality, conceptual understanding, task completion times, and student perceptions in a CS1 course. Methods: We conduct…

PLSEMANTICSBENCH: Large Language Models As Programming Language Interpreters
Aditya Thimmaiah, Jiyang Zhang, Jayanth Srinivasa, Junyi Jessy Li, Milos Gligoric
https://arxiv.org/abs/2510.03415

PLSEMANTICSBENCH: Large Language Models As Programming Language Interpreters
As large language models (LLMs) excel at code reasoning, a natural question arises: can an LLM execute programs (i.e., act as an interpreter) purely based on a programming language's formal semantics? If so, it will enable rapid prototyping of new programming languages and language features. We study this question using the imperative language IMP (a subset of C), formalized via small-step operational semantics (SOS) and rewriting-based operational semantics (K-semantics). We introduce three ev…

vibe main
yeet "vibez"
slay main() {
vibez.spill("Hello, World!")
}
https://simonwillison.net/2025/Sep/9/cursed/

LLM-GUARD: Large Language Model-Based Detection and Repair of Bugs and Security Vulnerabilities in C and Python
Akshay Mhatre, Noujoud Nader, Patrick Diehl, Deepti Gupta
https://arxiv.org/abs/2508.16419

LLM-GUARD: Large Language Model-Based Detection and Repair of Bugs and Security Vulnerabilities in C++ and Python
Large Language Models (LLMs) such as ChatGPT-4, Claude 3, and LLaMA 4 are increasingly embedded in software/application development, supporting tasks from code generation to debugging. Yet, their real-world effectiveness in detecting diverse software bugs, particularly complex, security-relevant vulnerabilities, remains underexplored. This study presents a systematic, empirical evaluation of these three leading LLMs using a benchmark of foundational programming errors, classic security flaws, a…

{\L}ukasiewicz Logic with Actions for Neural Networks training
Ioana Leu\c{s}tean (University of Bucharest), Bogdan Macovei (University of Bucharest)
https://arxiv.org/abs/2509.13020

Łukasiewicz Logic with Actions for Neural Networks training
Based on the already known connection between multilayer perceptrons and Lukasiewicz logic with rational coefficients, we take a step forward in analyzing its training process using a three-sorted hybrid modal logic: a multilayer perceptron is a logical formula; the actions of the training process are modal operators; the training process is a sequence of logical deductions. Using the proof assistant and the programming language Lean 4, the algorithmic implementation of the training process is …

A Multilingual Python Programming Language
Saad Ahmed Bazaz, Mirza Omer Beg
https://arxiv.org/abs/2510.09591 https://arxiv.org/pdf/2510.09591

A Multilingual Python Programming Language
All widely used and useful programming languages have a common problem. They restrict entry on the basis of knowledge of the English language. The lack of knowledge of English poses a major hurdle to many newcomers who do not have the resources, in terms of time and money, to learn the English language. Studies show that people learn better in their own language. Therefore, we propose a language transpiler built on top of the Python programming language, called UniversalPython, which allows one…

AutoVeriFix: Automatically Correcting Errors and Enhancing Functional Correctness in LLM-Generated Verilog Code
Yan Tan, Xiangchen Meng, Zijun Jiang, Yangdi Lyu
https://arxiv.org/abs/2509.08416

AutoVeriFix: Automatically Correcting Errors and Enhancing Functional Correctness in LLM-Generated Verilog Code
Large language models (LLMs) have demonstrated impressive capabilities in generating software code for high-level programming languages such as Python and C++. However, their application to hardware description languages, such as Verilog, is challenging due to the scarcity of high-quality training data. Current approaches to Verilog code generation using LLMs often focus on syntactic correctness, resulting in code with functional errors. To address these challenges, we present AutoVeriFix, a no…

Evaluating Large Language Models for Code Translation: Effects of Prompt Language and Prompt Design
Aamer Aljagthami, Mohammed Banabila, Musab Alshehri, Mohammed Kabini, Mohammad D. Alahmadi
https://arxiv.org/abs/2509.12973

Evaluating Large Language Models for Code Translation: Effects of Prompt Language and Prompt Design
Large language models (LLMs) have shown promise for automated source-code translation, a capability critical to software migration, maintenance, and interoperability. Yet comparative evidence on how model choice, prompt design, and prompt language shape translation quality across multiple programming languages remains limited. This study conducts a systematic empirical assessment of state-of-the-art LLMs for code translation among C++, Java, Python, and C#, alongside a traditional baseline (Tra…

Initial Algebras of Domains via Quotient Inductive-Inductive Types
Simcha van Collem, Niels van der Weide, Herman Geuvers
https://arxiv.org/abs/2509.10187 https://

Initial Algebras of Domains via Quotient Inductive-Inductive Types
Domain theory has been developed as a mathematical theory of computation and to give a denotational semantics to programming languages. It helps us to fix the meaning of language concepts, to understand how programs behave and to reason about programs. At the same time it serves as a great theory to model various algebraic effects such as non-determinism, partial functions, side effects and numerous other forms of computation. In the present paper, we present a general framework to construct …

LLMs are All You Need? Improving Fuzz Testing for MOJO with Large Language Models
Linghan Huang, Peizhou Zhao, Huaming Chen
https://arxiv.org/abs/2510.10179 https://

LLMs are All You Need? Improving Fuzz Testing for MOJO with Large Language Models
The rapid development of large language models (LLMs) has revolutionized software testing, particularly fuzz testing, by automating the generation of diverse and effective test inputs. This advancement holds great promise for improving software reliability. Meanwhile, the introduction of MOJO, a high-performance AI programming language blending Python's usability with the efficiency of C and C++, presents new opportunities to enhance AI model scalability and programmability. However, as a new l…

RepoTransAgent: Multi-Agent LLM Framework for Repository-Aware Code Translation
Ziqi Guan, Xin Yin, Zhiyuan Peng, Chao Ni
https://arxiv.org/abs/2508.17720 https://

RepoTransAgent: Multi-Agent LLM Framework for Repository-Aware Code Translation
Repository-aware code translation is critical for modernizing legacy systems, enhancing maintainability, and enabling interoperability across diverse programming languages. While recent advances in large language models (LLMs) have improved code translation quality, existing approaches face significant challenges in practical scenarios: insufficient contextual understanding, inflexible prompt designs, and inadequate error correction mechanisms. These limitations severely hinder accurate and eff…

On the Evaluation of Large Language Models in Multilingual Vulnerability Repair
Dong wang, Junji Yu, Honglin Shu, Michael Fu, Chakkrit Tantithamthavorn, Yasutaka Kamei, Junjie Chen
https://arxiv.org/abs/2508.03470

On the Evaluation of Large Language Models in Multilingual Vulnerability Repair
Various Deep Learning-based approaches with pre-trained language models have been proposed for automatically repairing software vulnerabilities. However, these approaches are limited to a specific programming language (C/C++). Recent advances in large language models (LLMs) offer language-agnostic capabilities and strong semantic understanding, exhibiting potential to overcome multilingual vulnerability limitations. Although some work has begun to explore LLMs' repair performance, their effecti…

RustAssure: Differential Symbolic Testing for LLM-Transpiled C-to-Rust Code
Yubo Bai, Tapti Palit
https://arxiv.org/abs/2510.07604 https://arxiv.org/pdf/25…

RustAssure: Differential Symbolic Testing for LLM-Transpiled C-to-Rust Code
Rust is a memory-safe programming language that significantly improves software security. Existing codebases written in unsafe memory languages, such as C, must first be transpiled to Rust to take advantage of Rust's improved safety guarantees. RustAssure presents a system that uses Large Language Models (LLMs) to automatically transpile existing C codebases to Rust. RustAssure uses prompt engineering techniques to maximize the chances of the LLM generating idiomatic and safe Rust code. Moreove…

PyVeritas: On Verifying Python via LLM-Based Transpilation and Bounded Model Checking for C
Pedro Orvalho, Marta Kwiatkowska
https://arxiv.org/abs/2508.08171 https://

PyVeritas: On Verifying Python via LLM-Based Transpilation and Bounded Model Checking for C
Python has become the dominant language for general-purpose programming, yet it lacks robust tools for formal verification. In contrast, programmers working in languages such as C benefit from mature model checkers, for example CBMC, which enable exhaustive symbolic reasoning and fault localisation. The inherent complexity of Python, coupled with the verbosity and low-level nature of existing transpilers (e.g., Cython), have historically limited the applicability of formal verification to Pytho…