David Chisnall (*Now with 50% more sarcasm!*)

For people who still believe the GPL influences corporations in a meaningful way:

When I was at Microsoft, I worked on a product that used Linux. The product was cancelled for largely unrelated reasons before it shipped, so the exact details are irrelevant but anything that links Linux needs to loop in lawyers, so I spent a lot of time talking to them.

Maybe 10% of the total time was spent with the technicalities of the GPL. The fact that the GPL is ambiguous and poorly written and the Linux syscall exemption is even worse made me expect long discussions about the legalese. But instead the conclusion of the GPL-focused discussions was basically:

No one really knows what the GPL can actually enforce and half of the stuff that's done with Linux is technically in violation. Microsoft ships Linux images for Azure that come with a click-through license that prohibits running them on any other cloud and no one cares. We can make a convincing argument that this is okay. Only a handful of companies can afford a protracted legal battle with Microsoft and none of them are sufficiently motivated to take us to court over this, so it's unlikely to come up.

The remaining 90% of the discussions were around how the product would be perceived by Linux maintainers, the wider Linux community, and the broader F/OSS ecosystem. Microsoft had put a lot of effort into the 'Microsoft <3 Linux' marketing things. The Ballmer-era alienation of the most active developer communities had cost the company a lot of ecosystem market share. The risk of pushing developers away from Microsoft products and platforms was something that the lawyers regarded as a huge risk. If two of the senior Linux maintainers had said 'we think this is not an acceptable use of Linux' then that would have torpedoed the project instantly.

The moral of this story is that, if positive engagement with your community is perceived as valuable, you have an enormous amount of leverage over big companies. At the time, Microsoft was (by market cap) the largest company in the world. The legal text, in contrast, isn't worth the paper it's written on when your adversary can afford to outspend you in court by six orders of magnitude. When they happen to be aligned, the legal text may look as if it's working, but that's a coincidence.

This is really key for a lot of ‘AI’ success stories. The baseline is always not trying a thing. It’s never trying a different technique and allocating the same amount of compute power specialised for the task to it.

Vulnerability discovery is like this. We currently limit static analysers for C/C++ to a single compilation unit because the memory and CPU requirements for that work on a laptop or cheap cloud VM, whereas doing cross-compilation-unit analysis can require hundreds of GiBs of RAM and many hours of CPU time. Yet, when people are talking about the LLMs doing vulnerability discovery, they’re comparing against the run-on-a-cheap-laptop version, not the costs-as-much-to-run-as-LLM-inference model.

If you were willing to throw a huge amount of compute at static analysis, then generate coverage points for the paths in the predicted bug and use guided fuzzing techniques to create a reduced test case, I suspect you’d get higher success rates than LLM-based approaches. But VCs are willing to throw tens of thousands of dollars of compute per bug at the LLM approach because it makes the companies that they’ve invested in look good.

I have used vim since around 2000. I have written five books, a PhD thesis, a few dozen papers and over 150 articles with it. At this point, my higher brain functions are not engaged at all when I use a bunch of common vim commands, they just happen. Documents I wrote with anything else have random :w in the middle.

So I tried NeoVim when it was quite new. Vim that you are familiar with, but better? Great!

Persistent undo is one of my favourite features of vim (introduced a few years after I started using it). My .vimrc includes a couple of lines related to this. One sets the path to be under ~/.cache so the undo files do not clutter the rest of the filesystem (I do the same for the swap files). The other sets the undo limit to something large (10,000, I think) because disk space is enormous relative to pretty much anything involving human-readable quantities of plain text.

I don’t often need the persistent undo. But on the few occasions when I have needed it, it’s been invaluable: ooops, I deleted something from this file, maybe last week and one reboot ago, what was it? Undo until I find it, copy it, paste it into the current version. Or, a bit more commonly: I had this working, then I tidied it up ready to commit, now it isn’t working, what did I do?

Vim has kept this working across major version upgrades over a period of about 20 years. I don’t even think about it, it’s just part of Raskin’s First Law: A program may not harm a user’s data or, through inaction, allow a user’s data to come to harm. If vim or the computer crash, or if I close a file and come back to it six months later, my undo history is still there.

The first thing I noticed in NeoVim was that undo didn’t work. I tried opening the file in vim and undo didn’t work there either.

Neovim had changed the format of the undo files. It hadn’t upgraded the old one. It hadn’t used a different name for its undo files. It had just noticed the existence of a vim undo file, deleted it (losing all of the data in it) and replaced it with one that vim couldn’t read.

I raised an issue about this and was told that the persistent undo format was unstable and users should not rely on data being preserved in a feature explicitly called persistent undo. It had changed once and would probably change again.

And that ended my experience with NeoVim. The authors showed immediately that they absolutely could not be trusted with any of my data. Breaking persistent undo is something I could forgive as a bug, but the attitude that just because something is a persistent file on your filesystem that contains data that you might want is no reason for their program not to delete it meant they had no concept of a duty of care to their users.

Apparently now they’re platforming white supremacists. I am completely unsurprised. Different facets of the same underlying attitude.

One of my favourite memories from visiting Istanbul:

We got a bit lost trying to find the entrance to the bazaar and were wondering around the nearby (very narrow) back streets. We hadn't seen anyone actually selling anything, but there was a cat in the middle of the path. I turned to my partner and, jokingly, said 'Do you want to buy a cat?'.

From nowhere, a small child appeared and said, in crisply enunciated English: 'No! It is my puss cat!', picked up the cat, and disappeared again.

I really like the Pentium 4 as an analogy here.

The NetBurst architecture in the P4 was designed to be able to scale to 10 GHz. It initially shipped in the 1-2 GHz range. The performance was not that impressive compared to even the previous generation but, Intel told us, that didn’t matter: it would rapidly reach clock speeds that were completely impossible with the P3.

On the face of it, this wasn’t unreasonable. The Pentium Pro and Pentium 2 shared a fairly similar microarchitecture (P2 added MMX and a few other things). The Pentium Pro was introduced at 150 MHz and scaled up to 450 MHz after process shrinks.

When the Pentium 4 was in early design stages, it was completely reasonable to expect that 3-5x clock speed increases were possible.

And, technically, they were. The clock speed for a part is determined by how long it takes a signal to propagate across everything in a pipeline stage. Make the things smaller and the signal goes further.

That kept happening. The thing that stopped (completely by about 2007, but it wasn’t an abrupt thing) was Dennard Scaling. Beyond a certain point, making the transistors smaller meant you had a lot more leakage current and so the power went up. And power was already polynomial in terms of clock speed.

All this meant that, yes, in theory, you could run a Pentium 4 at 10 GHz, as long as you didn’t mind all the fire. Someone did eventually run one at this speed with liquid nitrogen cooling, but that wasn’t appropriate for a consumer device. The range topped out at 4 GHz, and those parts had infeasible high cooling and power requirements (and were outperformed by other designs at lower speeds).

The entire ‘AI’ bubble is predicated on the same assumptions of scaling of something foundational that the people building the end systems are not really paying attention to.

@nikitonsky

I really like this as an install flow, because it's all about direct manipulation. The application is a thing that you can pick up and use. The applications folder may be a simple flat space, but if you put the Finder in spatial mode then you can arrange things however you like and rely on spatial memory.

Windows 3.x's Program Manager looked like the Finder, but it was an extra indirection layer. From Windows 95, Microsoft completely visually separated the thing that is the program in the filesystem from the thing that you click to launch the program and never regained that connection.

But the place it falls down is uninstallation. Modern apps are stateful. At a minimum, they will record window positions in User Defaults on macOS, but they may also safe other preferences there. They may have local caches of data. They may have documents that you'd want to keep (for example, images that another program can open) or ones that are explicitly linked to the program (such as savegames). When you uninstall a program on macOS, you drag it to the bin, but that just removes the program, not any of that other stuff.

I vaguely recall a BeOS derivative providing a hook for when things are moved out of folders that you could use to clean things up.

So many POSIX 'RATIONALE' sections can be distilled to:

One vendor did stupid thing A. Another did stupid thing B. We defined this interface to permit both implementations because designing a third thing that's sensible is, sadly, not within our remit and there are existing consumers of both of the stupid APIs.

@HennaVirkkunen

So, just to confirm: you observed the US become dominated by billionaires and exploitative companies who are throwing trillions or dollars at technology that provides marginal (at best) benefits to society and entrenches their power, and your reaction was 'the EU should do that too!'?

For comparison, the amount that you're burning on this is more than twice as much as you'd need for the EU to build a competitive range of memory-safe sovereign CPUs from microcontroller up to server class devices and port most open-source software to run on them. This would reduce the attack surface for all EU infrastructure significantly and provide strong sovereignty guarantees.

Can you share how you did a cost-benefit calculation and decided that chasing a big-tech fad was the best return on investment for the bloc?