Tootfinder

from my link log —
Making a compiler to prove tmux Is Turing complete.
https://willhbr.net/2024/03/15/making-a-compiler-to-prove-tmux-is-turing-complete/
saved 2025-08-01

LLM coding is the opposite of DRY
An important principle in software engineering is DRY: Don't Repeat Yourself. We recognize that having the same code copied in more than one place is bad for several reasons:
1. It makes the entire codebase harder to read.
2. It increases maintenance burden, since any problems in the duplicated code need to be solved in more than one place.
3. Because it becomes possible for the copies to drift apart if changes to one aren't transferred to the other (maybe the person making the change has forgotten there was a copy) it makes the code more error-prone and harder to debug.
All modern programming languages make it almost entirely unnecessary to repeat code: we can move the repeated code into a "function" or "module" and then reference it from all the different places it's needed. At a larger scale, someone might write an open-source "library" of such functions or modules and instead of re-implementing that functionality ourselves, we can use their code, with an acknowledgement. Using another person's library this way is complicated, because now you're dependent on them: if they stop maintaining it or introduce bugs, you've inherited a problem, but still, you could always copy their project and maintain your own version, and it would be not much more work than if you had implemented stuff yourself from the start. It's a little more complicated than this, but the basic principle holds, and it's a foundational one for software development in general and the open-source movement in particular. The network of "citations" as open-source software builds on other open-source software and people contribute patches to each others' projects is a lot of what makes the movement into a community, and it can lead to collaborations that drive further development. So the DRY principle is important at both small and large scales.
Unfortunately, the current crop of hyped-up LLM coding systems from the big players are antithetical to DRY at all scales:
- At the library scale, they train on open source software but then (with some unknown frequency) replicate parts of it line-for-line *without* any citation [1]. The person who was using the LLM has no way of knowing that this happened, or even any way to check for it. In theory the LLM company could build a system for this, but it's not likely to be profitable unless the courts actually start punishing these license violations, which doesn't seem likely based on results so far and the difficulty of finding out that the violations are happening. By creating these copies (and also mash-ups, along with lots of less-problematic stuff), the LLM users (enabled and encouraged by the LLM-peddlers) are directly undermining the DRY principle. If we see what the big AI companies claim to want, which is a massive shift towards machine-authored code, DRY at the library scale will effectively be dead, with each new project simply re-implementing the functionality it needs instead of every using a library. This might seem to have some upside, since dependency hell is a thing, but the downside in terms of comprehensibility and therefore maintainability, correctness, and security will be massive. The eventual lack of new high-quality DRY-respecting code to train the models on will only make this problem worse.
- At the module & function level, AI is probably prone to re-writing rather than re-using the functions or needs, especially with a workflow where a human prompts it for many independent completions. This part I don't have direct evidence for, since I don't use LLM coding models myself except in very specific circumstances because it's not generally ethical to do so. I do know that when it tries to call existing functions, it often guesses incorrectly about the parameters they need, which I'm sure is a headache and source of bugs for the vibe coders out there. An AI could be designed to take more context into account and use existing lookup tools to get accurate function signatures and use them when generating function calls, but even though that would probably significantly improve output quality, I suspect it's the kind of thing that would be seen as too-baroque and thus not a priority. Would love to hear I'm wrong about any of this, but I suspect the consequences are that any medium-or-larger sized codebase written with LLM tools will have significant bloat from duplicate functionality, and will have places where better use of existing libraries would have made the code simpler. At a fundamental level, a principle like DRY is not something that current LLM training techniques are able to learn, and while they can imitate it from their training sets to some degree when asked for large amounts of code, when prompted for many smaller chunks, they're asymptotically likely to violate it.
I think this is an important critique in part because it cuts against the argument that "LLMs are the modern compliers, if you reject them you're just like the people who wanted to keep hand-writing assembly code, and you'll be just as obsolete." Compilers actually represented a great win for abstraction, encapsulation, and DRY in general, and they supported and are integral to open source development, whereas LLMs are set to do the opposite.
[1] to see what this looks like in action in prose, see the example on page 30 of the NYTimes copyright complaint against OpenAI (#AI #GenAI #LLMs #VibeCoding

“I destroyed months of your work in seconds.” AI agents can also panic and cause mayhem—not because they're sentient, but because they've read plenty of online posts about us panicking when we do stupid stuff.
https://www.linkedin.com/posts/jonippoli…

How Does LLM Reasoning Work for Code? A Survey and a Call to Action
Ira Ceka, Saurabh Pujar, Irene Manotas, Gail Kaiser, Baishakhi Ray, Shyam Ramji
https://arxiv.org/abs/2506.13932

How Does LLM Reasoning Work for Code? A Survey and a Call to Action
The rise of large language models (LLMs) has led to dramatic improvements across a wide range of natural language tasks. These advancements have extended into the domain of code, facilitating complex tasks such as code generation, translation, summarization, and repair. However, their utility for real-world deployment in-the-wild has only recently been studied, particularly on software engineering (SWE) tasks such as GitHub issue resolution. In this study, we examine the code reasoning techniqu…

FuboTV agrees to pay $3.4M to settle a 2023 class action lawsuit alleging it violated US and California privacy laws over user data; Fubo denies the claims (Luke Bouma/Cord Cutters News)
https://cordcuttersnews.com/fu…

Fubo May Owe You Money After Agreeing to Pay $3.4 Million to Settle Class Action Lawsuit Over Privacy Violations | Cord Cutters News
FuboTV Inc. and FuboTV Media Inc. have agreed to pay $3.4 million to settle a class action lawsuit alleging the companies violated federal and California privacy laws, including the Video Privacy Protection Act (VPPA), the California Invasion of Privacy Act (CIPA), and California Civil Code § 1799.3. The lawsuit claims Fubo improperly collected, stored, used, […]

CodeDiffuser: Attention-Enhanced Diffusion Policy via VLM-Generated Code for Instruction Ambiguity
Guang Yin, Yitong Li, Yixuan Wang, Dale McConachie, Paarth Shah, Kunimatsu Hashimoto, Huan Zhang, Katherine Liu, Yunzhu Li
https://arxiv.org/abs/2506.16652

CodeDiffuser: Attention-Enhanced Diffusion Policy via VLM-Generated Code for Instruction Ambiguity
Natural language instructions for robotic manipulation tasks often exhibit ambiguity and vagueness. For instance, the instruction "Hang a mug on the mug tree" may involve multiple valid actions if there are several mugs and branches to choose from. Existing language-conditioned policies typically rely on end-to-end models that jointly handle high-level semantic understanding and low-level action generation, which can result in suboptimal performance due to their lack of modularity and interpret…

Frustrated with lack of a visual diff for KiCad PCBs in git, I made a simple shell script that does 90% of what I want. Here's a demo of it in action. Now I can "git diff" my PCBs!
The code: https://gist.github.com/todbot/aa644de99d9dacf0307267ea03fdbc64

Frustrated with lack of a visual diff for KiCad PCBs in git, I made a simple shell script that does 90% of what I want. Here's a demo of it in action. Now I can "git diff" my PCBs!
The code: https://gist.github.com/todbot/aa644de99d9dacf0307267ea03fdbc64

LLM-as-a-Judge for Reference-less Automatic Code Validation and Refinement for Natural Language to Bash in IT Automation
Ngoc Phuoc An Vo, Brent Paulovicks, Vadim Sheinin
https://arxiv.org/abs/2506.11237

LLM-as-a-Judge for Reference-less Automatic Code Validation and Refinement for Natural Language to Bash in IT Automation
In an effort to automatically evaluate and select the best model and improve code quality for automatic incident remediation in IT Automation, it is crucial to verify if the generated code for remediation action is syntactically and semantically correct and whether it can be executed correctly as intended. There are three approaches: 1) conventional methods use surface form similarity metrics (token match, exact match, etc.) which have numerous limitations, 2) execution-based evaluation focuses…

Excitation of toroidal Alfv\'en eigenmode by energetic particles in DTT and effect of negative triangularity
Guangyu Wei, Fulvio Zonca, Matteo Valerio Falessi, Zhiyong Qiu
https://arxiv.org/abs/2508.14622

Excitation of toroidal Alfvén eigenmode by energetic particles in DTT and effect of negative triangularity
A linear gyrokinetic eigenvalue code is developed to study the stability of toroidal Alfvén eigenmode (TAE) in general axisymmetric toroidal geometry, with the self-consistent treatment of energetic particle drive and core plasma Landau damping in a non-perturbative way. The general particle responses of both circulating and trapped particles are incorporated in the calculation by means of the action-angle approach, and, particularly, the finite Larmor radius and orbit width effects of energet…

There was no cake left in the rain, just a sunny day gone dark as #Drumpf military men mount horseback, don facemasks and occupy #MacArthurPark for show of force, irking #LA mayor

Federal Agents March Through L.A. Park, Spurring Local Outrage
Federal officials said it was an immigration enforcement operation, though it was unclear if anyone had been arrested. “It’s the way a city looks before a coup,” Mayor Karen Bass said as she condemned the action.

This https://arxiv.org/abs/2405.04406 has been replaced.
initial toot: https://mastoxiv.page/@arXiv_csIT_…

Rényi divergence guarantees for hashing with linear codes
We consider the problem of distilling uniform random bits from an unknown source with a given $p$-entropy using linear hashing. As our main result, we estimate the expected $p$-divergence from the uniform distribution over the ensemble of random linear codes for all integer $p\ge 2$. The proof relies on analyzing how additive noise, determined by a random element of the code from the ensemble, acts on the source distribution. This action leads to the transformation of the source distribution in…

Blueprint First, Model Second: A Framework for Deterministic LLM Workflow
Libin Qiu, Yuhang Ye, Zhirong Gao, Xide Zou, Junfu Chen, Ziming Gui, Weizhi Huang, Xiaobo Xue, Wenkai Qiu, Kun Zhao
https://arxiv.org/abs/2508.02721

Blueprint First, Model Second: A Framework for Deterministic LLM Workflow
While powerful, the inherent non-determinism of large language model (LLM) agents limits their application in structured operational environments where procedural fidelity and predictable execution are strict requirements. This limitation stems from current architectures that conflate probabilistic, high-level planning with low-level action execution within a single generative process. To address this, we introduce the Source Code Agent framework, a new paradigm built on the "Blueprint First, M…