Killing cockroaches

Sitting next to my desk is an "Altair 8800 computer". To the modern eye, it’s a strange beast; a rectangular white box about the size of a carry-on suitcase. The front panel is a mass of switches and red LEDs; some unfamiliar connectors lurk at the rear. It doesn’t look much like a computer. But yet it must be - it says so on the front.

Back in the late 1970s it was state of the art in home computing. If you were rich you could pair it with a display and a keyboard; if you weren’t you could operate it from the switches and LEDs on the front panel. Microsoft created their first product for this computer - a version of BASIC.

And you can play games on it. I showed my son "Kill the bit" - where a red light moves along a row of LEDs, and you have to flip the switch underneath it at just the right time to kill the bit. He wasn’t very impressed.

Under the covers it has an Intel 8080 processor; a close cousin of the 8086 that would go on to dominate the CPU world. It’s different. But familiar.

Since then CPUs have gotten faster. And memory cheaper. That has brought improvements in the user interface. The switches and lights gave way to terse command lines. Which, in turn, were replaced by the graphical user interfaces (GUIs) we’re familiar with today.

Act naturally

GUIs are undoubtedly an improvement. But they still leave something to be desired. You, dear user, need to learn how to use the machine. You have to learn the icons and menus. You need to know that an icon of a floppy disk means save, despite, if you are under thirty, probably never having used or seen a floppy disk outside of a museum. And don’t get me started on Obsidian with its monochrome squiggles for icons. What, exactly, do four different sized rectangles in a grid mean?

But increasingly my interface to my computer is natural language - either voice or typing. Recently it dawned on me that I no longer interact with git or cargo - Claude & Codex do all that for me - they are just part of the process of building function.

And it’s not just coding. A few weeks ago I bought my son a new Dell laptop. Which started crashing multiple times a day. Claude soon had the evidence of a hardware fault (I’ve bought two Dell laptops this year and both have failed; I’m getting good at this…), so back to Dell it goes.

I access my email via Claude, get Claude to write music for me, use Claude to find installed software… Natural language is, for me at least, a more, well, natural interface.

But it got me thinking. Where does this lead? Could we be about to have a revolution in UIs?

And if UIs change, what about the rest of the stack?

The big three

A really simple way of thinking about the current computing tech stack is to split it into three layers. At the top is the UI/OS (e.g. Windows). Below that are the high level languages we use to build software - C, Python, Rust. And below that there is the hardware - mostly x86 and ARM these days.

Changing any of these is incredibly hard. Take x86. It was only ever intended as a stopgap while Intel developed their iAPX432 architecture. But iAPX432 failed, so x86 got a reprieve.

Not to worry. Intel had a plan to replace x86 with the i860. But x86 beat that too. Even in the late 90s when x86 was wildly successful, Intel was still trying to kill it. That time it was Itanium that failed to defeat x86.

x86 really is the cockroach of the CPU world. Even Intel wouldn’t claim it’s a good architecture; but despite that it seems to be unkillable.

x86 works hand-in-hand with C. Together they make it easy to build high performance code; in the 1980s when CPUs were slow this mattered a lot. But the speed comes at a cost; C (and C++) are full of security and correctness vulnerabilities. And the x86 architecture does little to help.

Amazingly, the US DoD realised this back in the late 1970s. Back then they wrote up a set of requirements for a new, secure programming language. That become Ada. Ada is a highly robust, reliable, secure language. It’s the language you turn to if you want to write software to fly airplanes.

But it was even better than that. Intel developed a processor based on a capability architecture that provided hardware support for Ada. The processor and language working together to provide a secure environment. This was the iAPX432.

Unfortunately the hardware of the time couldn’t deliver on the vision. The iAPX432 worked but was slow and expensive. Plus Ada was hard to write. The future died in the early 80s.

Ponder for a minute how different things might have been if we’d been using Ada and iAPX432 based hardware. How many of the security panics of the past thirty years would have been avoided? Would we be worrying quite so much about the consequences of all the new exploits Fable is finding?

Unfortunately that’s not how things played out. x86 today isn’t so different from that of the 1970s.

And we’ve been stuck with C (and C++). The majority of mission critical code in use today is still C code; a language whose limitations were understood back in the late 1970s.

Change is coming - albeit slowly. Rust is a significant step to removing whole classes of defects that C is prone to. But Rust still has to fit in with the limitations of the hardware; x86 and ARM have gained some security features, but progress is glacially slow.

Stuck

The problem is everything is too big and complex to change. The challenge of backwards compatibility is real. Getting lots of people to move - especially when it is unclear what is in for them - is very hard. So change happens slowly, if at all.

But could AI shake this up?

AI makes it cheap to reimplement software we use on a daily basis. I’ve reimplemented codecs, communication stacks, games. Others have reimplemented design tools, apps. We’re starting to see people reimplementing Excel and Word. More will come.

So, yes, we can reimplement tools using improved programming languages. We can prune out the unused function. Done well this could be transparent to users; Microsoft could choose to build a simplified, reimplemented Excel. If they don’t others will be sure to step into the void.

But, perhaps, the real forcing function is conversational UIs. My finance spreadsheet exists to tell me, bluntly, whether I can retire. If there’s another way of answering that question, then I’m fine with that. I’m not attached to the spreadsheet format. If I can ask questions - and get answers I believe - then I’m fine with my future finance package having a very different interface.

I see that with our SDLC. I can’t remember when I last opened VSCode - it’s been months. I don’t look at code. Instead I have a conversation with Claude/Codex about what I want to achieve, agree the high-level plan and then leave Claude/Codex to it. When they are done they come back to me and we talk through the results. And it’s clear that pattern applies much more generally - could it be that the days of interacting with spreadsheets are numbered? How many people will be sad about that :)?

So it could well be that reimplementing apps is little more than a brief diversion on the way to conversational UIs. And a whole new UI/app paradigm. In twenty years time do I just end up talking to my robot friend - who provides the bridge between a conversational UI and all the gunky legacy systems we’ll be stuck with for years to come?

And when the software becomes trivial to port, then do we get into an interesting world where hardware innovation could flourish? Could someone do a RISC-V - and create an open-source hardware platform that is more secure and which is optimized for conversational UIs (perhaps running local inference)? Would this platform get designed hand-in-hand with the language and compiler above it? And finally build the unified hardware/software stack that iAPX432 and Ada tried to do all those years ago?

I’m weird; I get excited when I think about the opportunities ahead of us. It feels like we’re at the dawn of a new period of innovation and change. And that’s exciting. Not least because it means my grandkids will look at my son with the same look of bemusement my son gave me when I showed him my Altair 8800.