Reminder to people who have international meetings: the next week is George W Bush Golfing Time. The USA and Europe had an agreement to move clocks at the same time, so the time difference remained constant. George W Bush decided he wanted a few weeks more golfing time, so unilaterally moved the USA’s Daylight Saving Time. This move remains in effect so there are a few weeks of annoying disruption each year.

I made the mistake of flying the first time this happened, which is how I knew about it: the airlines were unprepared and sold me tickets on two flights where the time change meant that my slightly tight 45-minute change turned into a -15 minute connection time (fortunately the second flight was on a route they flew every two hours so I was only an hour late)l

One of the patterns I’ve seen with people using Claude for programming is:

A programmer in the past looked at a tradeoff space and decided to make a common operation fast and an uncommon operation slow.

Claude lacks proper context of the use of the software but spots a pattern that looks like things it’s training set has flagged as slow and so points to the slow path as a bottleneck.

The user asks for a test case and Claude provides a simple microbenchmark that triggers the slow path.

Now that it’s confirmed as slow, the user asks a ‘agentic’ harness to explore the design space and optimise for the benchmark. The swarm of Claude instances makes plausible changes to the code and reports back with a modified version that passes the test suite and improves the microbenchmark.

The test suite doesn’t exhaustively cover all possible race conditions and so the new version may include subtle concurrency bugs. It also probably makes the common case slower and so is a regression overall.

I don’t know if other LLMs encourage this flow, but I’ve seen it several times from people using Claude.

I suspect Linus’ recent embarrassing interaction with his kernel’s virtual memory code may have been an example of this pattern. It’s very easy to do with an LLM because each step appears to be a demonstrable improvement. It comes with an objective benchmark, it passes all of the tests. Unfortunately, software often depends on a load of extrinsic knowledge that the LLM is trying to infer from a load of likely misleading data points.

Wow, SwiftUI and all of the competent designers retiring has made #Apple so bad at UIs. I helped my mother set up a MacBook Air yesterday. We set the UI size to the maximum so she could see it easily. Around half of the setup boxes then had buttons that were either off the bottom of the screen or obscured by the dock (and therefore not clickable).

Almost all of them had huge amounts of empty space in the middle and so could easily have fitted if some idiots private aesthetic had been considered less important than accessibility at Apple.

All of them were either modal or app-modal (hey, Apple folks: you might like to read your own Human Interface Guidelines, they explain in detail why this is stupid). You couldn’t progress or go back until you’d hit the button that was off the screen and, because some were system-wide global, you couldn’t go to settings and change UI size without killing the thing that produced the box.

All completely preventable if anyone in QA had bothered to try the first-time setup flow on an Apple device using each of the five UI-size options.

Oh, honourable mention for #Microsoft if you install Word or Excel, the first launch window is a massive thing (which, at least, can be scrolled, unlike the Apple ones) giving you a bunch of options to buy an M356 subscription. There is no option anywhere in that window for logging in with your existing subscription. There is an option in the app menu, but it’s greyed out. If you close this window, the app exits. In your next release testing, try asking someone on your team to figure out how to log in from a fresh install. I eventually figured out the flow, but I was very close to the point of saying ‘let’s just put LibreOffice, Pages, and Numbers on this and not bother with the M365 stuff’. And I have a PhD in computer science and worked at Microsoft for five years: how do you think a vaguely normal human will do?

I just fixed a bug where someone had sent an LLM-generated fix. At first glance, the LLM fix was mostly right, except for a redundant atomic fence (LLMs seem to love __atomic_thread_fence in this codebase, no idea why).

But then I went to fix the bug. The problem was that a lock was initialised too late and so could end up being initialised twice. Ooops, locks are not meant to introduce concurrency problems!

And the LLM fix moved it earlier, so that's fine.

Except... there's another way that the object containing the lock might be reached via a global pointer and that didn't have any guards. I don't think it's possible to trigger the bug that way, but some of the future changes that I'd considered might introduce that as a path.

And there's no real reason for anyone to want the object without the initialised lock, so moving the initialisation to just before the point where any other thread might reach the object is a simple fix.

But that isn't what the LLM proposed. Instead, it fixed the immediate issue without any reference to the long-term impact and maintainability of the codebase.

My fix was a fairly simple change: one new line of code, four new lines of comment, and six deleted lines of code (so worth doing for code readability even if the bug hadn't been real). And even a change that small, if you accepted the LLM recommendation (three new lines of code, no new comments, and six deleted lines), would have made the code less maintainable and more subtly broken.

And that's why I refer to these things as Technical Debt as a Service.

RE: https://mastodon.sdf.org/@netbsd/117396625341557692

Hey #FreeBSD folks, NetBSD hit more than double their funding target after adopting a strong no-LLMs policy. Something to think about while you draft yours, perhaps?

When the kittens were small, I thought my fist was roughly cat-head sized and shaped and so might be easier for them to relate to than an entire human, so I’d hold out my fist for them to investigate and get comfortable with. And it worked. Except friendlykitten has developed a habit of not just sniffing it but full-on headbutting my finger with his nose. Walks up, sniffs fist, hits closest finger as hard as he can with his nose, then consents to scritches. This cannot be good for his nose.

He’s also basically full cat sized now. I might have to stop calling him a kitten.

Relative to my age the Fediverse is full of...

RE: https://fosstodon.org/@TomSeppert/117387085601828071

This is basically me. Fortunately, I married someone who will distract the human while I talk to their dog.

Periodically I try LLMs to see if they actually are useful for programming. This week I was writing an AsciiDoctor plugin. I’m not particularly familiar with Ruby (I struggle to imagine the mindset that believes Smalltalk, or, indeed, any language, can be improved by adding Perl syntax) and I find the internals of AsciiDoctor to be very poorly documented and hard to follow. So this seemed like a great task for LLM assistance: I know the problem domain very well (I’ve written other document processing tools) but not the details of the codebase I’m working on.

GPT-5.6 repeatedly sent me down misleading paths and wasted time, and gave suggestions that looked right but were completely wrong. It kept going back to the same thing that would cause a later phase to infinite loop. It eventually gave me a solution that was so convoluted that I couldn’t believe AsciiDoctor wouldn’t have a better way of doing it (I didn’t try it: if that was the only way of making it work I’d rather ditch AsciiDoctor than apply it, so I have no idea if it actually worked).

I actually solved the problem by finding a bug report from someone trying to solve a similar problem, which linked to their eventual solution. Reading that, I was able to find the missing conceptual bit in my understanding of how AsciiDoctor worked. And I finished the thing.

In total, the time spent with an LLM did not advance me towards the solution at all. None of the code that it suggested that I write ended up in the final plugin.

If I had used an ‘agentic’ setup, where I had given it my document, the desired output, and told it to keep trying until it did it, it would probably have got something that worked. The last throw looked like it would have ended up working, but it would have been an order of magnitude more complexity than I actually needed. And would have been completely unmaintainable: if all of the surrounding justification text had been comments, it would have looked like entirely plausible code, but with deeply fragile connections between the different phases.

Importantly, if I hadn’t solved it myself, I would not have really understood the gap between the complexity of a good solution and the LLM-generated one. I might have accepted it was the best available option, in spite of it being terrible. And this was fairly low-stakes code (processing a document for internal consumption), so that might have been fine. But doing that for anything used in production would be an absolute long-term disaster: you’d acquire all of that technical debt without knowing that it is technical debt, you’d just think the feature was done.

RE: https://toot.cafe/@baldur/117364953454550116

This should be read by everyone participating in the #FreeBSD LLM policy working group.

I don’t understand the panic over ‘LLMs can tell people how to build biological weapons and plan assassinations’. So can Tom Clancy novels. And both sources will tell you things that are more likely to get you killed than achieve your nefarious goal.

I just got an email from Microsoft telling me about the exciting new things in Copliot for Office. Unfortunately, all of the placeholder text in their examples was in actual placeholder XML tags and not rendered as that tag is in their normal documentation.

So what’s the explanation?

HOW DID I NOT KNOW OTTERS CARRY AROUND THEIR FAVOURITE ROCK?!?!

(The picture is slightly misleading, that looks like a river otter and this is apparently a sea-otter behaviour)

Butterfly is much less fun to say than papillon so I am using the standard process in the English language: deprecating a common-usage word and replacing it with a foreign word that I like better. From now on, all uses of the word ‘butterfly’ shall be deemed archaic.

Thank you for your patience during the transition.

Please stop enforcing mandatory time limits on credentials that are trivial to revoke!

The point of mandatory expiration is that revocation happens eventually. In the case of a compromise and leak of that credential, an attacker has a guaranteed sunset when their stolen credentials will stop working. This is sometimes a useful property.

For example, checking certificate revocation lists on every TLS session is slow. It's common for clients to skip this and rely on revocation sets that are pushed out during software updates. Short lifespans here serve to optimise the performance of revocation lists / sets: if your certificate lifetime is five days and you revoke it, after five days it can be deleted from revocation lists. Scale this to the number of certificates issued across the entire Internet and that's a big saving.

But the big down side of requiring frequent generation of short-lived credentials is that the credentials needed to generate that credential (which, by definition, are more privileged) are frequently accessed.

If I am generating a token to go into some release flow and I can do it once via a cumbersome process that requires multiple rounds of authentication and then put it in some secure credential store where it's accessed only from an ephemeral VM doing my release flow, then I don't care about the effort of generating the token. I do it once and, in the happy case, forget about it. If there's a trivial mechanism for revoking it, we're done: if there's evidence of compromise, revoke it and go through the slow process again.

But if that token expires every 30-90 days, I need to automate generating it. Which means that some automated process that is likely to be as vulnerable as the token itself now has access to the credentials required to mint the token. And that's introduced additional complexity without introducing additional security.

TL;DR: If you have an expiration policy for credentials, make sure that you have a threat model that it is intended to address and that you understand the operational complexity that you're introducing and any security weaknesses that this is will cause.

I am trying a new thing:

Only boosting posts that make me happy or have something actionable for readers. It's good to be informed about depressing issues, it's not good to be constantly bombarded with things about them.

Not posting about things that annoy me unless I have an actionable proposal for how to improve them. Grumbling can be cathartic but is not especially helpful.

I don't promise I'll be good at this, but I'm going to try!

There’s a depressing human tendency (independent of position of the position on any political spectrum) to follow the following train of thought:

1. We have identified X as a problem.
2. Y looks, on paper, like it would solve X.
3. We will do Y!
4. Hmm, we have observed that Y did not fix X.
5. We must do Y more!
6. It appears that Y is actually causing secondary effects that exacerbate X.
7. Do even more Y! Look, our predictions from step 2 said Y will fix X!

So, OpenAI admits two things in disclosures presented to the court:

• That their products are utterly dependent on work ingested without compensation.
• That their derived product is directly substituting for this work, removing the economic incentive to perform that work in the first place.

Meanwhile, the EFF filed an amicus brief in the case claiming that this use is exactly what was intended by the ‘To promote the Progress of Science and useful Arts’ justification for the existence of copyright in the US Constitution.

Journalists:

A Ponzi Scheme is not a generic name for an investment scam. It is a very specific investment scam. It is misleading to refer to NVIDIA’s circular financing scheme as a Ponzi Scheme.

They are booking payments as investment and then having that same money come back to you as revenue, which drives up their share price. Because NVIDIA’s P/E is 30, $1 of money moved in this way translates to a $30 increase in NVIDIA’s market cap (possibly more, because this shows growth, which pushes up the P/E). This allows NVIDIA to issue more shares and repay the current investment.

This has some similarities with a Ponzi scheme: it relies on new investors putting money in and it allows early investors to cash out using money from new investors. But it is a different mechanism and a different-shaped flow of money.

In the interest of accuracy, please refer to it as a Huang Scheme.

It's fun to mock Canada, but any country that has a Strategic Maple Syrup Reserve (this is a real thing, look it up) clearly has a set of priorities that the rest of us can learn from.