// Systems software engineer working at the boundary of low-level performance and formal safety. C++ by trade, Rust by conviction.
I am an M.Sc. Computer Science student at the University of Illinois Urbana-Champaign, with nearly a decade of industry experience building high-performance systems in C++ and C — trading platforms, network data planes, deep-packet inspection engines, and multithreaded storage engines.
My current research sits at the intersection of programming languages and large language models: building automated pipelines that translate unsafe C repositories into idiomatic, memory-safe Rust, and studying how agentic LLMs plan and execute engineering tasks.
Existing C to Rust translation techniques fail to balance quality and scalability: transpilation-based approaches scale to large projects but produce code with poor safety, idiomaticity, and readability. In contrast, LLM-based techniques are prohibitively expensive due to their reliance on frontier models, limiting scalability. This paper proposes Rustine, a fully automated pipeline for effective and efficient repository-level C to idiomatic safe Rust translation. Evaluating on a diverse set of 23 C programs (27–13,200 LOC), Rustine generates fully compilable Rust code for all and achieves 87% functional equivalence (1,063,099 of 1,221,192 assertions), with average function and line coverage of 74.7% and 72.2%. Compared to six prior repository-level techniques, Rustine's translations are safer (fewer raw pointers, pointer arithmetic, and unsafe constructs), more idiomatic (fewer linter violations), and more readable. When translations cannot fully pass tests, developers complete the remaining work in 4.5 hours on average using Rustine as debugging support.
Agents aspire to eliminate task-specific prompt crafting through autonomous reason-act-observe loops, yet they are commonly instructed to follow a task-specific plan — e.g., navigation, reproduction, patch, and validation for software issues. It is unknown to what extent agents actually follow such plans, and without that analysis it is impossible to assess whether a solution came from correct strategic reasoning or from data contamination and benchmark overfitting. This paper presents the first extensive, systematic analysis of plan compliance in programming agents, examining 16,991 trajectories from SWE-agent across four LLMs on SWE-bench Verified and SWE-bench Pro under eight plan variations. Without an explicit plan, agents fall back on workflows internalized during training, which are often incomplete, overfit, or inconsistently applied. Providing the standard plan improves issue resolution, and periodic reminders mitigate violations. A subpar plan hurts performance more than no plan at all. Surprisingly, augmenting a plan with additional task-relevant phases early can degrade performance when those phases do not align with the model's internal strategy. These findings highlight a research gap: fine-tuning paradigms that teach models to follow instructed plans rather than encoding task-specific plans within them.
io_uring, designed for minimal overhead and predictable latency.hwy/simd.const-correctness across the codebase.go generate errors tied to undefined packages.