Tootfinder

PSA/TIL #fedora dracut does an fsfreeze on /boot - so do not do something like:
cd /boot
dracut --debug ... > dracut.debug 2>&1
because then the system starts locking up on any access to /boot with unkillable processes.
Discovered the hard way.

We added an extension to test your Godot projects directly into Xogot:
https://github.com/xibbon/xogot_remote_debug

GitHub - xibbon/xogot_remote_debug
Contribute to xibbon/xogot_remote_debug development by creating an account on GitHub.

Yesterday @… selflessly jumped on a call with me to help me debug a really deep JS / Embroider / Vite issue! Thanks so much for your help <3

Playing more with the Trion devkit.
Got my APB GPIO core building and running with almost no code changes (just had to switch from initializing module outputs in the module declaration vs explicit "initial" blocks).
The logic analyzer IP works, but is very bare bones: you have to explicitly connect to a particular scan chain with one debug core on it (does this mean a max of two debug cores in a Trion?) then set up a capture and it'll output to a VCD.
The soft…

The amount of pointless, useless, overly-complex indirection I see in so many well-established, popular projects makes me very sad.
Except when I am trying to debug it; then it makes me very angry.
#PHP #Programming

@… @… @… I’d start here:

Might be the longest file I've had in (n)vim:
30G position: 592564829,23 - yep, ~600M lines.
A #qemu debug logfile.

How AI Vibe Coding Is Erasing Developers’ Skills
Developers believe AI is boosting their productivity, but it is actually weakening core coding skills. Vibe coding is creating a generation of devs who cannot debug, design, or solve problems without AI.
https://www.finalroundai.com/blog…

How AI Vibe Coding Is Erasing Developers’ Skills
Developers believe AI is boosting their productivity, but it is actually weakening core coding skills. Vibe coding is creating a generation of devs who cannot debug, design, or solve problems without AI.

An Investigation Into Secondary School Students' Debugging Behaviour in Python
Laurie Gale, Sue Sentance
https://arxiv.org/abs/2508.14833 https://arxiv…

An Investigation Into Secondary School Students' Debugging Behaviour in Python
Background and context: Debugging is a common and often frustrating challenge for beginner programmers. Understanding students' debugging processes can help us identify the difficulties and misunderstandings they possess. However, we currently have limited knowledge of how secondary students debug in a text-based language, a medium through which millions of students will learn to program in the future. Objectives: In this paper, we investigate the debugging behaviour of K-12 students learning a…

@… any ideas how to debug this? Posts from this person are showing up in my home feed but I don't follow them:
https://lemmy.ca/post/48071921

Eight Great BC Books to Read This Summer - Lemmy.ca

from my link log —
Let's Debug figures out why you can’t issue a certificate with Let's Encrypt.
https://letsdebug.net/
saved 2025-04-29 https://

A very simple code to describe emotions or how does this work in real life?!?? ;)
```rust
#[allow(warnings)]
fn main() {
let mut emo: &str;
match 1 1 == 0b10 {
true => emo = "🤓",
_ => emo = "😵‍💫",
};
println!("Perception: {}", emo);
}
```
Play 🦀:

ViTAD: Timing Violation-Aware Debugging of RTL Code using Large Language Models
Wenhao Lv, Yingjie Xia, Xiyuan Chen, Li Kuang
https://arxiv.org/abs/2508.13257 https://

ViTAD: Timing Violation-Aware Debugging of RTL Code using Large Language Models
In modern Very Large Scale Integrated (VLSI) circuit design flow, the Register-Transfer Level (RTL) stage presents a critical opportunity for timing optimization. Addressing timing violations at this early stage is essential, as modern systems demand higher speeds, where even minor timing violations can lead to functional failures or system crashes. However, traditional timing optimization heavily relies on manual expertise, requiring engineers to iteratively analyze timing reports and debug. T…

PSA: isc-dhcp-server >~3.0 sets the 'siaddr' in offers to 0 unless you set the next-server entry for a server; and Javastations don't like that. They used to set it to the server IP, like god intended.
(Yours after many hours of debug, bisection, tcpdump and reading the dhcp spec).
So if you're reading old config guides for old machines and using a modern DHCP server...

Android: #Obtanium (instead of #FDroid app) is really awesome for managing app updates.
However, this method has an issue when the naming schema of the #apk files change on the server side, and you're using a…

always a good day when you can remove a complex piece of code and make a more powerful system that is easier to understand
https://github.com/GlasgowEmbedded/glasgow/pull/873

BugGen: A Self-Correcting Multi-Agent LLM Pipeline for Realistic RTL Bug Synthesis
Surya Jasper, Minh Luu, Evan Pan, Aakash Tyagi, Michael Quinn, Jiang Hu, David Kebo Houngninou
https://arxiv.org/abs/2506.10501

BugGen: A Self-Correcting Multi-Agent LLM Pipeline for Realistic RTL Bug Synthesis
Hardware complexity continues to strain verification resources, motivating the adoption of machine learning (ML) methods to improve debug efficiency. However, ML-assisted debugging critically depends on diverse and scalable bug datasets, which existing manual or automated bug insertion methods fail to reliably produce. We introduce BugGen, a first of its kind, fully autonomous, multi-agent pipeline leveraging Large Language Models (LLMs) to systematically generate, insert, and validate realisti…

@… This is just confusing… I know I’m using an unsupported configuration, but maybe just assume I’m using a totally different piece of software, and then debug my issue for me with that assumption.
Wat.

#today at uni. Managed to debug the slightly vexing heat loss problem in my bungalow-2 model in progress. It turns out that I had the new roof segments on 'upside down' even though they have only one layer and are actually walls. (Don't ask ... yet... Maybe I'll understand what I'm doing in a few months!)

Anybody have a good source for premade 20 pin 1.27mm ARM Cortex debug/trace cables of various lengths?
Some of my test setups would be a lot neater if I could move the debugger slightly further from the DUT (even if I had to reduce the TCK/SWCLK frequency due to crosstalk or something)

CCSS: Hardware-Accelerated RTL Simulation with Fast Combinational Logic Computing and Sequential Logic Synchronization
Weigang Feng, Yijia Zhang, Zekun Wang, Zhengyang Wang, Yi Wang, Peijun Ma, Ningyi Xu
https://arxiv.org/abs/2507.08406

CCSS: Hardware-Accelerated RTL Simulation with Fast Combinational Logic Computing and Sequential Logic Synchronization
As transistor counts in a single chip exceed tens of billions, the complexity of RTL-level simulation and verification has grown exponentially, often extending simulation campaigns to several months. In industry practice, RTL simulation is divided into two phases: functional debug and system validation. While system validation demands high simulation speed and is typically accelerated using FPGAs, functional debug relies on rapid compilation-rendering multi-core CPUs the primary choice. However…

Its good to have many tests in your R package, but it can be a pain to debug some failing tests when it happens. {lazytest} for the rescue: only rerun the failing tests, until they pass: #RStats

Note to self: When starting doing something large and complicated in Visual Studio, regularly build and run in both Debug and Release configurations from the start, even while you are still very much debugging the stuff, so that you notice if the latter mysteriously doesn't work early enough.

How to tell a vibe coder of lying when they say they check their code.
People who will admit to using LLMs to write code will usually claim that they "carefully check" the output since we all know that LLM code has a lot of errors in it. This is insufficient to address several problems that LLMs cause, including labor issues, digital commons stress/pollution, license violation, and environmental issues, but at least it's they are checking their code carefully we shouldn't assume that it's any worse quality-wise than human-authored code, right?
Well, from principles alone we can expect it to be worse, since checking code the AI wrote is a much more boring task than writing code yourself, so anyone who has ever studied human-computer interaction even a little bit can predict people will quickly slack off, stating to trust the AI way too much, because it's less work. I'm a different domain, the journalist who published an entire "summer reading list" full of nonexistent titles is a great example of this. I'm sure he also intended to carefully check the AI output, but then got lazy. Clearly he did not have a good grasp of the likely failure modes of the tool he was using.
But for vibe coders, there's one easy tell we can look for, at least in some cases: coding in Python without type hints. To be clear, this doesn't apply to novice coders, who might not be aware that type hints are an option. But any serious Python software engineer, whether they used type hints before or not, would know that they're an option. And if you know they're an option, you also know they're an excellent tool for catching code defects, with a very low effort:reward ratio, especially if we assume an LLM generates them. Of the cases where adding types requires any thought at all, 95% of them offer chances to improve your code design and make it more robust. Knowing about but not using type hints in Python is a great sign that you don't care very much about code quality. That's totally fine in many cases: I've got a few demos or jam games in Python with no type hints, and it's okay that they're buggy. I was never going to debug them to a polished level anyways. But if we're talking about a vibe coder who claims that they're taking extra care to check for the (frequent) LLM-induced errors, that's not the situation.
Note that this shouldn't be read as an endorsement of vibe coding for demos or other rough-is-acceptable code: the other ethical issues I skipped past at the start still make it unethical to use in all but a few cases (for example, I have my students use it for a single assignment so they can see for themselves how it's not all it's cracked up to be, and even then they have an option to observe a pre-recorded prompt session instead).

Third attempt, it calls this round replacing #ubuntu and the manual partition page seemed to have things right, but I'm surprised an installer that takes so long has so little to say. /var/log/installer peeps a DEBUG now and then, but betrays no secrets. 52 minutes and counting, just passed probert.network and another flurry of udevadm empty queue successes.

This looks like great fun; big big construction machines driven by AI - that's what we want our AI to be doing, driving huge machines with shovels on.
That must be great fun to debug.
https://bedrockrobotics.com/news/introducing-bedrock-robotics…

Bedrock Robotics

The joy of working on a #PHP package upgrade that isn't supposed to do I/O or anything OS dependant somehow fails on #Windows. This is going to be a fun debug session

from my link log —
Using otel to emit and view debug traces from Golang command-line tools.
https://github.com/jonjohnsonjr/til/blob/main/post/otel.md
saved 2025-05-27

til/post/otel.md at main · jonjohnsonjr/til
Contribute to jonjohnsonjr/til development by creating an account on GitHub.

Towards Bridging Formal Methods and Human Interpretability
Abhijit Paul, Proma Chowdhury, Kazi Sakib
https://arxiv.org/abs/2506.09759 https://

Towards Bridging Formal Methods and Human Interpretability
Labeled Transition Systems (LTS) are integral to model checking and design repair tools. System engineers frequently examine LTS designs during model checking or design repair to debug, identify inconsistencies, and validate system behavior. Despite LTS's significance, no prior research has examined human comprehension of these designs. To address this, we draw on traditional software engineering and graph theory, identifying 7 key metrics: cyclomatic complexity, state space size, average branc…

are you a platform/embedded developer?
do you need to interact with hardware in a semi-custom manner?
would you like to suffer a lot less doing it?
if so, #GlasgowInterfaceExplorer might be for you. the code below is all you need to build a custom testbench for a DUT you've never seen before. just as easily you can add JTAG/SWD debug, protocol analyzers, etc.…

Initial proof of life out of the flash: using normal x1 operation, it appears to be fully functional when driven by the MCU over APB.
So far, I haven't tested actually reading/writing data, but it's doing everything I would expect from a fully functional, correctly soldered flash. Not sure why Vivado doesn't like it.
It's definitely hooked up to the right pins since I'm using the STARTUPE3 hard IP to interface with it.

from my link log —
Poke-a-hole (pahole) and dwarves: examine data structure layouts in DWARF debug info.
https://lwn.net/Articles/335942/
saved 2025-07-30

Should we teach vibe coding? Here's why not.
Should AI coding be taught in undergrad CS education?
1/2
I teach undergraduate computer science labs, including for intro and more-advanced core courses. I don't publish (non-negligible) scholarly work in the area, but I've got years of craft expertise in course design, and I do follow the academic literature to some degree. In other words, In not the world's leading expert, but I have spent a lot of time thinking about course design, and consider myself competent at it, with plenty of direct experience in what knowledge & skills I can expect from students as they move through the curriculum.
I'm also strongly against most uses of what's called "AI" these days (specifically, generative deep neutral networks as supplied by our current cadre of techbro). There are a surprising number of completely orthogonal reasons to oppose the use of these systems, and a very limited number of reasonable exceptions (overcoming accessibility barriers is an example). On the grounds of environmental and digital-commons-pollution costs alone, using specifically the largest/newest models is unethical in most cases.
But as any good teacher should, I constantly question these evaluations, because I worry about the impact on my students should I eschew teaching relevant tech for bad reasons (and even for his reasons). I also want to make my reasoning clear to students, who should absolutely question me on this. That inspired me to ask a simple question: ignoring for one moment the ethical objections (which we shouldn't, of course; they're very stark), at what level in the CS major could I expect to teach a course about programming with AI assistance, and expect students to succeed at a more technically demanding final project than a course at the same level where students were banned from using AI? In other words, at what level would I expect students to actually benefit from AI coding "assistance?"
To be clear, I'm assuming that students aren't using AI in other aspects of coursework: the topic of using AI to "help you study" is a separate one (TL;DR it's gross value is not negative, but it's mostly not worth the harm to your metacognitive abilities, which AI-induced changes to the digital commons are making more important than ever).
So what's my answer to this question?
If I'm being incredibly optimistic, senior year. Slightly less optimistic, second year of a masters program. Realistic? Maybe never.
The interesting bit for you-the-reader is: why is this my answer? (Especially given that students would probably self-report significant gains at lower levels.) To start with, [this paper where experienced developers thought that AI assistance sped up their work on real tasks when in fact it slowed it down] (https://arxiv.org/abs/2507.09089) is informative. There are a lot of differences in task between experienced devs solving real bugs and students working on a class project, but it's important to understand that we shouldn't have a baseline expectation that AI coding "assistants" will speed things up in the best of circumstances, and we shouldn't trust self-reports of productivity (or the AI hype machine in general).
Now we might imagine that coding assistants will be better at helping with a student project than at helping with fixing bugs in open-source software, since it's a much easier task. For many programming assignments that have a fixed answer, we know that many AI assistants can just spit out a solution based on prompting them with the problem description (there's another elephant in the room here to do with learning outcomes regardless of project success, but we'll ignore this over too, my focus here is on project complexity reach, not learning outcomes). My question is about more open-ended projects, not assignments with an expected answer. Here's a second study (by one of my colleagues) about novices using AI assistance for programming tasks. It showcases how difficult it is to use AI tools well, and some of these stumbling blocks that novices in particular face.
But what about intermediate students? Might there be some level where the AI is helpful because the task is still relatively simple and the students are good enough to handle it? The problem with this is that as task complexity increases, so does the likelihood of the AI generating (or copying) code that uses more complex constructs which a student doesn't understand. Let's say I have second year students writing interactive websites with JavaScript. Without a lot of care that those students don't know how to deploy, the AI is likely to suggest code that depends on several different frameworks, from React to JQuery, without actually setting up or including those frameworks, and of course three students would be way out of their depth trying to do that. This is a general problem: each programming class carefully limits the specific code frameworks and constructs it expects students to know based on the material it covers. There is no feasible way to limit an AI assistant to a fixed set of constructs or frameworks, using current designs. There are alternate designs where this would be possible (like AI search through adaptation from a controlled library of snippets) but those would be entirely different tools.
So what happens on a sizeable class project where the AI has dropped in buggy code, especially if it uses code constructs the students don't understand? Best case, they understand that they don't understand and re-prompt, or ask for help from an instructor or TA quickly who helps them get rid of the stuff they don't understand and re-prompt or manually add stuff they do. Average case: they waste several hours and/or sweep the bugs partly under the rug, resulting in a project with significant defects. Students in their second and even third years of a CS major still have a lot to learn about debugging, and usually have significant gaps in their knowledge of even their most comfortable programming language. I do think regardless of AI we as teachers need to get better at teaching debugging skills, but the knowledge gaps are inevitable because there's just too much to know. In Python, for example, the LLM is going to spit out yields, async functions, try/finally, maybe even something like a while/else, or with recent training data, the walrus operator. I can't expect even a fraction of 3rd year students who have worked with Python since their first year to know about all these things, and based on how students approach projects where they have studied all the relevant constructs but have forgotten some, I'm not optimistic seeing these things will magically become learning opportunities. Student projects are better off working with a limited subset of full programming languages that the students have actually learned, and using AI coding assistants as currently designed makes this impossible. Beyond that, even when the "assistant" just introduces bugs using syntax the students understand, even through their 4th year many students struggle to understand the operation of moderately complex code they've written themselves, let alone written by someone else. Having access to an AI that will confidently offer incorrect explanations for bugs will make this worse.
To be sure a small minority of students will be able to overcome these problems, but that minority is the group that has a good grasp of the fundamentals and has broadened their knowledge through self-study, which earlier AI-reliant classes would make less likely to happen. In any case, I care about the average student, since we already have plenty of stuff about our institutions that makes life easier for a favored few while being worse for the average student (note that our construction of that favored few as the "good" students is a large part of this problem).
To summarize: because AI assistants introduce excess code complexity and difficult-to-debug bugs, they'll slow down rather than speed up project progress for the average student on moderately complex projects. On a fixed deadline, they'll result in worse projects, or necessitate less ambitious project scoping to ensure adequate completion, and I expect this remains broadly true through 4-6 years of study in most programs (don't take this as an endorsement of AI "assistants" for masters students; we've ignored a lot of other problems along the way).
There's a related problem: solving open-ended project assignments well ultimately depends on deeply understanding the problem, and AI "assistants" allow students to put a lot of code in their file without spending much time thinking about the problem or building an understanding of it. This is awful for learning outcomes, but also bad for project success. Getting students to see the value of thinking deeply about a problem is a thorny pedagogical puzzle at the best of times, and allowing the use of AI "assistants" makes the problem much much worse. This is another area I hope to see (or even drive) pedagogical improvement in, for what it's worth.
1/2

Computer Science Education in the Age of Generative AI
Russell Beale
https://arxiv.org/abs/2507.02183 https://arxiv.org/pdf/2507.0218…

Computer Science Education in the Age of Generative AI
Generative AI tools - most notably large language models (LLMs) like ChatGPT and Codex - are rapidly revolutionizing computer science education. These tools can generate, debug, and explain code, thereby transforming the landscape of programming instruction. This paper examines the profound opportunities that AI offers for enhancing computer science education in general, from coding assistance to fostering innovative pedagogical practices and streamlining assessments. At the same time, it highl…

Hmm my #Fedora 42 is unhappy with yesterdays 6.15.9-201 - falling back to 8-200 is fine.
Got as far as 'basic target' but no further; it's not hung (caps lock and ctrl-alt-del work). Time to break out some systemd options to get some more debug. Nothing hit the logs on disk.

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

Speculative Automated Refactoring of Imperative Deep Learning Programs to Graph Execution
Efficiency is essential to support ever-growing datasets, especially for Deep Learning (DL) systems. DL frameworks have traditionally embraced deferred execution-style DL code -- supporting symbolic, graph-based Deep Neural Network (DNN) computation. While scalable, such development is error-prone, non-intuitive, and difficult to debug. Consequently, more natural, imperative DL frameworks encouraging eager execution have emerged but at the expense of run-time performance. Though hybrid approach…

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