In 1984, two first-time chip designers, Steve Furber and Sophie Wilson, created what would become the most popular processor in the world (ARM). I interviewed Steve about how they did it with such a small team that had no formal training.
Can you imagine building a computer today without access to the internet or your favorite AI tools?
That’s what they did and knowing that, I couldn’t help but ask him how they figured everything out.
I asked him a bunch of questions about hardware design and his answers were so clear. If you’re curious about hardware design too, then hopefully you’ll enjoy the episode.
Check out the episode wherever you get your podcasts: YouTube, Spotify, Apple Podcasts.
Timestamps
00:27 - Building his first computer
10:28 - Designing the ARM processor
17:15 - Why their design was better
23:38 - Emulators and interpreters
25:58 - Instruction sets and microarchitecture
31:08 - How they learned chip design
34:27 - Why they were so successful
44:10 - Neuromorphic computing
50:45 - His most proud engineering
51:46 - Top technical book recommendation
52:29 - Advice for young people
Transcript
00:27 — Building his first computer
Ryan:
[00:27] What’s the first computer you built and why did you build it?
Steve:
[00:35] I’d been interested in flying as a teenager. I flew model aircraft, not very successfully. I did a bit of glider flying at university, but then I’d kind of thought, well, you have to spend a long time to get a few minutes in a glider. Maybe I should be interested in flight simulation. And then I heard about some guys who were starting a student society at the university called the Cambridge University Processor Group.
[01:06] And this was people who built computers for fun. So I thought, well, if I’m interested in building a flight simulator, then maybe starting off understanding how to build a computer would be a good idea. So I wasn’t a founder of this society, but I went along to their foundation meeting and became quite closely involved. And then in that society, the real men — and it was principally male, as I remember it — built computers out of TTL chips, and the wimps like me used these newfangled microprocessor things.
[01:46] And I ordered a microprocessor. It was a Signetics 2650 from a store in California. This was very scary, ordering by phone, with credit cards, which were relatively new at the time, and some other components, and hand-assembled the machine using a technique called Verowire, which had a—you got a standard PCB and you could put chip sockets in, and then you could wire them together with a wiring pen.
[02:17] And this had a very fine copper wire with a polyurethane insulation layer. When you soldered it, it melted the insulation and you got a connection. But when you ran these wires around the board, the insulation meant you could run different wires through the same routes and they wouldn’t short. So that was my first computer.
Ryan:
[02:37] What’s a TTL chip?
Steve:
[02:39] If you were building computers in the 1970s, you were almost certainly building with TTL. It stood for transistor-transistor logic, and there was an orange data book from Texas Instruments, which was the TTL data book. TTL chips came in from small chips that had maybe four NAND gates to slightly bigger chips that had something like a 4-bit ALU, or a 4- or 8-bit bus buffer. They were at the level of individual logic gates or a couple of flip-flops or something like that.
[03:18] So, all the functional components you need to build a computer, but you need lots of TTL chips to build a functioning computer.
Ryan:
[03:26] Oh, so it’s the components within the CPU. So, you could buy an ALU and hook it up to whatever other AND or OR gates.
Steve:
[03:36] Yeah, TTL logic had a standard format, so they had compatible logic swings. And I guess each logic gate was, I don’t know, half a dozen transistors and a similar number of resistors or so. So if you looked at the standard basic part was the 7400. They all started with 74. 7400 was a quad NAND gate, so it would have about 30, 40 components on there forming these four NAND gates.
Ryan:
[04:11] Somewhere in some interview, you mentioned that you were anodizing aluminum in your own kitchen sink. What is that for when you were building your own computer? Why would you need to do that?
Steve:
[04:25] Well, I did quite a lot of chemistry in the kitchen sink. One of which was—I can’t remember what the technique was called—but with single-sided PCBs, you could etch off the copper. So you get a PCB that was just a solid copper sheet. You could draw on it with a pen that sort of waterproofed that area of the board and then stick it in ferric chloride. And that would etch off the copper where you hadn’t used the pen, and you’d have a printed circuit board.
[04:59] Okay, so now anodizing aluminium was something I did for the front panel of my first computer. So it gave the aluminium a nice finish. You could then attach Letraset to it to label things and produce a nice, reasonably professional-looking front panel.
Ryan:
[05:19] Did you have roommates at the time? What did they think of all this?
Steve:
[05:25] Well, I cleaned up, right? I didn’t leave the stuff lying around.
05:28 — BBC Micro
Ryan:
[05:28] So one of the famous things that you worked on was the BBC Microcomputer.
[05:29] What’s the story behind you getting involved in that project?
Steve:
[05:38] I became involved in Acorn because Acorn grew out of a company called Cambridge Processor Unit Limited. That was formed by Hermann Hauser and Chris Curry, who wanted to build a business around these newfangled microprocessor things. And in order to find people to do some of the technical work, they went to the Cambridge University Processor Group. It’s an obvious place to go look. And that’s where they found me and Sophie Wilson and one or two other people.
[06:15] Now, I was a PhD student at the time; I couldn’t actually do paid work for them, but I could do bits of design. And we had a kind of deal where they’d give me components, and I’d build my own computers, which I used in my PhD research and subsequently in my research fellowship. So there was synergy between my day job and what I was doing with Acorn. But as I was getting towards the end of my research fellowship, which ended at the end of September ’81, Acorn got to hear about the BBC looking for a computer to support a series of TV programs, and Acorn secured the contract based on a design that was to a considerable extent based on the machine I built at home, not the Signetics 2650 system, but the one after that.
[07:11] And at the end of my research fellowship, I joined Acorn as a formal employee in October ‘81.
Ryan:
[07:18] How does someone go about building a computer back then? Because when I think about doing anything today, I think, okay, I’m going to look it up on the Internet and I’m going to find all these tutorials, or—but none of that existed back then. So how did you figure out everything you needed to build a commercial computer?
Steve:
[07:37] There were various ways of approaching the computer, one of which was, of course, joining the university society and talking to other people who were doing it, sharing ideas. There were also hobbyist magazines. So a very longstanding hobbyist magazine in the UK was called Wireless World, which wasn’t just about computers, but it did cover aspects of computer technology. And there was something I think called Electronics Today International or something, another— so there were people publishing magazines that included hobbyist designs for people to build their own things.
[08:23] But lots of the time we were just working from datasheets, so my first microprocessor was the 2650. I got the 2650 datasheet, worked out how to connect that to memory and get that up and running. Friends in the student society would come around and poke at it and find bugs and generally help you fix things. So... yeah, it was a social activity. And of course, the Internet did exist at that time, but the World Wide Web did not.
[09:02] So the Internet was a very different beast and not particularly useful in this context.
Ryan:
[09:08] When I think of manufacturing consumer electronics at scale, I usually think of it being done in China or some other country, but at this time in history, I believe it was before China had risen to prominence in being a manufacturing powerhouse. So how were all of these computers manufactured? Were there factories in the UK that put together everything?
Steve:
[09:36] Yes, yes. I mean, I don’t remember all the details, but I know that at one time quite a lot of BBC Micros were manufactured by ICL in Kidsgrove, which is not that far from here. And ICL was the big UK mainframe computer manufacturer, a sort of British IBM. But as a computer manufacturer, they had production lines for assembling printed circuit boards, and they subcontracted assembly of BBC Microcomputers.
[10:11] So yes, most of the manufacture was done locally in the UK. I mean, the BBC Micro was also manufactured under license in India for the Indian market and in some other places, but the UK manufacture was basically here.
10:28 — Designing the ARM processor
Ryan:
[10:28] After the BBC Micro, later you worked on Arm, which I think most people are very familiar with. It’s in almost all of our devices. What’s the story behind going from building a computer to building the actual chips themselves.
Steve:
[10:46] The story of designing our own chips does start with the BBC Micro because the BBC Micro, the main circuit board had 102 chips on and 100 of those were standard off-the-shelf parts, 6502, quite a lot of TTL packages, some CMOS. But 2 of the chips on there were semi-custom chips designed specifically for the BBC Micro, and they were uncommitted logic arrays manufactured by Ferranti in North Manchester.
[11:25] And the uncommitted logic array was basically a chip with a sea of gates that, with a single layer of metallization, you could customize to your bespoke function. Sinclair used these as well in the ZX81, and you could get the equivalent of 10 or perhaps 20 TTL packages, the functionality of those 10 or 20 packages, onto a single chip with ULAs and thereby bring the size of the circuit board down somewhat.
[11:56] So that was my introduction to semi-custom chip design. But early in the ‘80s, Acorn, in particular Hermann Hauser, had decided that the company needed to get more into chip design. One of his quotes I remember was that he was saying, in 10 years’ time, there’ll be 2 sorts of computer companies: those that have learned to design chips and those that have gone bust. So Acorn recruited a small team of chip designers, professional chip designers, and it adopted chip design software from VLSI Technology in the States.
[12:43] And so it had this chip design resource available. Now, we, and principally Sophie Wilson and I, were thinking about what we did to follow on from the BBC Micro, and it was pretty clear that the world was moving from 8-bit microprocessors to 16-bit. And we tried several 16-bit microprocessors. The BBC Micro had a dual processor capability, so you could plug a fairly simple board in with it, with another processor and some memory.
[13:19] And the BBC Micro did all the I/O, so the system you had to design was relatively simple. So we built quite a number of second processors with 16-bit microprocessors on them, and we didn’t particularly like what we found. And the things we didn’t like were, firstly, those 16-bit microprocessors had worse real-time performance than the 6502. On the BBC Micro, we made very heavy use of interrupt handling real-time data streams from floppy disks, and you just couldn’t do that with these 16-bit microprocessors.
[13:58] Their interrupt response was too slow. And secondly, through all these experiments, we’d come to the strong view that the main thing that determined the performance of a computer was the amount of memory bandwidth the processor could access and use, and all of these 16-bit microprocessors were effectively slower than the memories at the time. They would take multiple cycles to access the memory, and the memory was capable of significantly higher bandwidth.
[14:31] So we were sitting there with these two sort of thoughts frustrating us a bit as we were deciding which microprocessor we might choose for a successor product when we heard about the RISC papers from, particularly from UC Berkeley, but also from Stanford under David Patterson and John Hennessy’s leadership respectively. And we looked at these and we saw that in the Berkeley case, a postgraduate class had designed a competitive microprocessor in a year.
[15:05] And so that started us thinking, if they can do that, maybe we can. And the principle underpinning that success was RISC, which I’ve mentioned, reduced instruction set computing. And this is the idea that instead of making your processor more powerful by adding ever more complex instructions, you make it more powerful by simplifying the instruction set and enabling those instructions to run much faster.
[15:34] The microprocessor is a different design environment from the minicomputers of the ‘70s, upon which a lot of the 16-bit processors were based. You have a finite transistor resource, and how you use those transistors matters, and the optimization point is different. And what RISC showed was that if you make the instruction set simple enough that you can pipeline the processor, you get more performance than you ever get from adding complex instructions.
[16:09] So it was that inspiration that fed into the design of ARM. And it started, I think, in ‘83, Sophie Wilson looking at the Berkeley and Stanford designs and coming up with her own instruction set. Sophie had written all Acorn’s BASIC interpreters, so she had a very good idea of what instructions needed to do to support a high-level language. And that went into her instruction set design. I turned those instruction set architectures into a microarchitecture, built a reference model. I built it in BBC BASIC.
[16:54] It’s 808 lines of BBC BASIC. It describes all the internal operation of the first Arm chip. And this silicon design team we’d assembled then translated the reference model into a silicon implementation. And 18 months after we started, we had the first Arm silicon.
17:15 — Why their design was better
Ryan:
[17:15] The new generation of chips after the 6502, they were too slow when they used the memory. Well, what’s the intuition behind why they were bad at using the memory and why the ARM processor was able to fully utilize memory bandwidth?
Steve:
[17:36] The processors were slow because they typically used microcoded instruction execution, and that meant that each instruction took several clock cycles. And clocks were not that fast. Those days, we’re talking about clocks around 6 MHz. The memory chips available at the time could support about 4 million random accesses per second, or twice that if you use locality. They had an optimization called page mode.
[18:17] Where if you were accessing a location close to the previous location, i.e., in the same basic row of the memory, then you didn’t have to do a full access. You could do effectively a double-speed access. So effectively, these memories would go up to 8 mega accesses per second, and the processors were using multiple cycles of a clock around 4 or 6 megahertz. So they just couldn’t work the memories hard.
[18:48] On Arm, by adopting RISC principles, we had an architecture where a lot of instructions execute in a single cycle, not all of them, but by designing the processor so that it gave out a signal which told you if the next address it wanted to access was close to the previous one, effectively sequential was the only interpretation of close that we used. So if you’re fetching sequential instructions, then you can do a lot of that in page mode, right, and reach the full speed of the memory.
[19:25] Arm also had load/store multiple instructions which use sequential addresses quite deliberately, again to make use of this double memory speed. So we could see that by using this approach, we could—and the other thing about Arm, of course, is it was not a 16-bit processor. It was 32-bit from the outset, which immediately gives you double the bandwidth and therefore double the performance. So we could see that going from the 6502 in the BBC Micro, we could get something like 25 times increase in the useful memory bandwidth.
[20:02] Wow. Going from 8 to 32-bit gives you a factor of 4. Going up by about a factor of 6 in clock speed gives you a factor of 6. So we could see a huge step in potential performance, provided we could design the processors that it could run smoothly at that higher rate.
Ryan:
[20:21] If increasing the word size from 8-bit to 32-bit improves memory bandwidth, how come in modern-day processors I don’t see anything past 64-bit? Why not go to 128 or something like that in designing a computer?
Steve:
[20:42] That’s a good question. The answer is that the point at which that width matters has moved. So pretty much all current processors actually run much faster than the memory. Okay, but they don’t talk directly to the external memory. They talk to a cache memory that’s on-chip, and then the cache memory does reloads from external memory, and that can often in multiword chunks. So that could use a very wide bus, but there is cost associated with width.
[21:22] Every time you double the bus width, you need twice as many pins to make the connections. You need twice as many memory chips to build the memory. So, yeah, 64 seems to be a useful place to stop. 32 bits was a great place because it was the first point at which a processor could handle an address as a single data item. Right. For 8-bit microprocessors, most addresses were 16-bit.
[21:54] For the 16-bit microprocessors, the addresses had pushed through to at least 24 bits. At 32 bits, for quite a long period, you could hold a whole address as a single datum on the processor. So 32 bits was a sweet spot. And 64 was quite a long time coming.
Ryan:
[22:14] Why are the word sizes often powers of 2? Is that complete convention? Why not 63-bit or 65-bit or 30-bit or something?
Steve:
[22:26] Well, that’s a very good question as well. If you look at some of the very early computers, then you do see quite a wide range of different word widths in the machine. Although, interestingly, the first operational stored-program computer, which was the Manchester Baby machine, it was a 32-bit machine, but it was large. It was a serial machine. And after then, you find all sorts of issues. I mean, there was no real agreement on how big a byte should be for some time.
[23:01] I mean, for a basic alphabet and digits, you can manage with 6 bits, just about. But eventually, everybody settled on 8-bit bytes as the basic unit of storage. And so a multiple of 8 became a natural feature. You can build machines that have 40 bits or 48 bits, but I guess if 32 bits is a natural unit, then being able to hold 2 of those at once is a sensible next step.
23:38 — Emulators and interpreters
Ryan:
[23:38] When I was reading about the development of the ARM microprocessor, and I think you also mentioned earlier in the development, the idea of using or building an interpreter to facilitate testing of the instruction set was useful. Can you explain the role of the interpreter in developing hardware?
Steve:
[24:00] Yes. Was it an interpreter or an emulator? I think at Acorn we built a number of software models that would execute ARM code. Okay, the one I built of the microarchitecture very much modeled the way the processor would work, so it had a sort of a model of a 2-phase clock, and it had latches on phase 1 and latches on phase 2. Every 32-bit register in the processor is represented by a variable in the model.
[24:36] Okay, so that’s a— today I think we’d call that a register-transfer level, an RTL model of the processor. But if you want to test code, that tends to be a slightly slow way of doing it. So Acorn also built instruction-level emulators that just implemented the function of the instruction without attempting to emulate the hardware at all. And that allows you to write bigger programs and test them before you’ve got real hardware available.
[25:07] And one of the most important things that was developed in the course of the ARM development was a set of instruction test programs. So these were programs that tried to exhaustively test every function of, for example, the barrel shifter or the ALU or the register file or whatever. And these were much quicker to develop on a higher-level emulator before you then ran them on the microarchitecture emulator.
[25:48] to check that the microarchitecture didn’t have bugs.
Ryan:
[25:50] So this emulator, it’s a way to simulate the hardware before actually crystallizing it?
Steve:
[25:58] Yes.
25:58 — Instruction sets and microarchitecture
Ryan:
[25:58] Okay. I read that Sophie Wilson—and you mentioned as well—Sophie Wilson worked on the instruction set and then you worked on the microarchitecture. Could you explain these two pieces of work and how they’re interrelated?
Steve:
[26:15] So the instruction set is the interface between the computer, the processor, and the programmer at the lowest level. Most programmers work in high-level languages, but they have a compiler that works from their high-level language down to this interface. So I guess today it’s more accurate to say that the instruction set architecture is the interface between the computer hardware and the compiler.
[26:44] And it defines things such as how many registers there are, how they’re organized. So on ARM, there are separate registers for handling interrupts and so on. And then what you can do by way of individual operations. So ARM follows the RISC philosophy of using a load-store architecture, which means that the only interactions you have with memory are loading bytes, halfwords, words from memory into the register, or storing them back.
[27:19] Unlike earlier 16-bit processors, which would do things like memory-memory add or divide, on ARM, if you wanted to add 2 values in memory, first you loaded those 2 values into separate registers. And then you used a different instruction to add those registers together to get a result in the third register, and then you could save that third register to memory if that’s where you wanted the result.
[27:44] So the instruction set architecture defines the functionality of those load and store instructions and adds and multiplies, and also more subtle things such as operating system calls. Subroutine calls and so on. The microarchitecture is the structure of the hardware which supports that instruction set architecture. So the architecture has defined, there are 16 registers plus a number for handling interrupts.
[28:20] So in the microarchitecture, you physically implement 16 registers. And those registers are then connected by things called buses to, for example, the barrel shifter. A barrel shifter is a functional unit which will take a 32-bit number and shift it an arbitrary number of bits to the left or to the right, possibly rotating the bits that fall off the end back onto the beginning, or possibly not, possibly doing a sign extension as it goes.
[28:53] And the instruction set architecture defines what functionality is required there, but then the microarchitecture could implement that in a number of ways. So on the Arm, we implemented it as a highly parallel structure which would do any of these shifts in a fraction of a clock cycle. But we could have implemented it as a shift register which took the value in and then shifted it 1 bit per clock.
[29:20] So if you wanted to shift 15 bits, it would take 15 clocks. That’s at the microarchitecture level. And a typical microarchitect works by drawing block diagrams and buses between the block diagrams, between the units on the block diagrams, and working out which values go down which bus at which point in each instruction. So I literally started the microarchitecture design by sketching an arrangement of registers and barrel shifters and ALUs and so on, on a piece of paper, making lots of photocopies, and then for each instruction, for each clock cycle, coloring in what was happening on this microarchitecture in this Phase 1 of this cycle, phase 2, next cycle, and so on.
[30:17] And you get to a point where there’s an instruction you want to implement that doesn’t map nicely. And at that point you think, well, actually what I need is a slightly rearrangement of the buses to make that work properly. So you throw all your colored-in sheets of paper away, you redraw the initial sketch, make multiple photocopies, and start coloring in again. Now, I’m sure today you wouldn’t do it with photocopiers and pieces of paper.
[30:45] You’d do it with a diagram you drew on a computer, and then you’d probably still want to color it in by hand for the first iteration on the computer. But back then in 1983, finding a computer you could do that on usefully was harder than finding a photocopier.
31:08 — How they learned chip design
Ryan:
[31:08] When I hear all of this, my immediate thought is: how did you learn all of this? Because not that schooling is everything, but your PhD was in aerodynamics. So I get the sense that you had to pick up all of this kind of by doing it. Where did you learn all of this?
Steve:
[31:27] I think we made it up. I mean, we had the Berkeley papers to refer to, and I think there was a book written on the Berkeley RISC processors by Manolis Katevenis. It was his PhD thesis. I think he’s still a professor at a university in Greece. And that went into quite a lot of detail as to how the Berkeley RISC processors were conceived and put together. And I think we just worked from that and made things up.
[32:03] I mean, yes, nobody on the Acorn team had had any involvement in designing a processor before. It was our first attempt for all of us. But we were quite experienced at designing hardware. We had some kind of thought before we started the ARM project that there was a bit of mysticism and magic to designing a processor. But we designed hardware, memory, high-performance memory systems, graphics systems, and so on.
[32:33] And it turned out that designing a processor is actually just another piece of hardware design. It’s not fundamentally different from designing the sort of hardware we’d done previously. Nobody taught us. We picked up what we could from books and papers and made the rest up.
34:27 — Why they were so successful
Ryan:
[34:27] You mentioned maybe a 9x speedup compared to some of the competing offerings. And I guess, why was this team so successful? Because this was your first time ever doing it, and there was a bit of mysticism around this process to even begin with. And the team was tiny. I mean, it sounds like there were some technicians and people helping, but it was largely just you and Sophie Wilson.
Steve:
[34:58] I think the culture at Acorn at that time was very strong.
[35:02] We’d done a number of quite challenging things and pulled them off. There were things the BBC Micro did that nobody had done before, one of which was telesoftware. This was still before the days of the World Wide Web, and to distribute software, the BBC had set up sending data over the unused scan lines in a TV program, in a TV broadcast. The TV broadcast was set up in the days of analog TVs, and so there’s quite a lot of slack at the top and bottom of the screen, and they sent data out, and we built a decoder for the BBC Micro that would pick up that TV signal and extract the data from it.
[35:51] And all that kind of stuff worked. So we did get technically pretty confident that we could do things that we hadn’t done before. But I think with the ARM, the ultimate success is down to the fact that, yes, okay, we did a reasonable execution, okay? But we kind of thought all the while that the RISC idea was so obvious that mainstream industry would pick up on it. Acorn’s efforts would get trampled underfoot, but at least we’d have learned something for choosing a RISC processor from one of the big semiconductor houses.
[36:37] And it just didn’t happen that way. So the mainstream industry never really got going. It was another 10 years before they began to think, well, maybe RISC is a good idea after all. So we were very early into RISC, and RISC brought many advantages, both simplicity, and coming with simplicity was small size. So the processor was physically small and low power because it was simple. There weren’t that many transistors switching.
[37:17] And so it all came together in a very nice package. The fundamental concepts were inherited from the Berkeley and Stanford RISC work. We managed not to foul up the implementation, so it all came together.
Ryan:
[37:34] You make it sound like RISC was obvious. Why were all the CISC people saying CISC was obvious?
Steve:
[37:41] Well, I think they’d built up an investment in it. Now, in Intel’s case, they were probably right to continue with x86 because they had an established software base and they needed to maintain compatibility with that. Because that was in the PC market where software compatibility was very important. So for their business, continuing with CISC undoubtedly made sense. I mean, they did dabble in RISC. Intel did produce one or two rather unsuccessful RISC processors, but the x86 kept them going.
[38:24] If you look at an x86 today, then to a large extent what you see on the front end is an instruction translator that turns the x86 stream into a RISC-like stream, and then it all gets executed on a RISC-like core. So they haven’t ignored it, it’s just they’ve, they use it differently. But mainstream industry, I think, had too much invested in this concept of narrowing the semantic gap between the instruction set architecture and the high-level language.
[38:55] And they saw complex instructions as a good thing, and they didn’t recognize that by abandoning those and basically giving more work to the compiler, which is what RISC does, that you could then produce a much more streamlined hardware engine where the benefits of using the silicon, instead of using it for complex instructions, using it for pipelining, that was the first big win.
[39:27] The first Arm chip had a 3-level pipeline, which meant it could do fetch, decode, execute, and complete one instruction per tick. Not all the instructions were single tick, but most were. And yeah, a lot of the industry was slow to recognize this and then slow to work out what to do with it.
39:57 — America vs UK
Ryan:
[39:57] When you were deciding to build ARM, I understand that you also visited America. What was the difference in the work cultures in computing between the UK and the US in your perspective?
Steve:
[40:15] Our visit to the States, I think, was in October ’83, was to the Western Design Center in Phoenix, Arizona, where I think it was just Sophie and I who went. And we were expecting to find the usual gleaming American business office block. And what we found was that the Western Design Center was operating out of two bungalows in the Phoenix suburbs. Now, these bungalows had some fairly unusual equipment around them, but they were getting school kids in over the summer to design cell libraries.
[40:50] And our main interest there was they were developing a successor to the 6502, which was the 65C816, if I remember right, which had a bit of an address extension, so it would address more memory than the 6502. And Acorn did use that in some of their products subsequent to the BBC Micro. But it wasn’t the big step forward. It was an incremental improvement. And we came away from seeing those bungalows, which were sort of much less professional than we were anticipating, let’s put it that way.
[41:36] And that was one of the things that made us think, well, if they can design a processor, maybe we can too.
Ryan:
[41:41] Did Acorn ever consider building their own fab for these chips?
Steve:
[41:47] No.
Ryan:
[41:47] And why is that?
Steve:
[41:49] Building a fab was even then very expensive and completely out of proportion to Acorn’s business. And in any case, Acorn had this good relationship with VLSI Technology, who had a fab in San Jose, who fabricated all the early Arm chips and the Archimedes, the Arm support chips, because Arm was not a one-chip development. It was a four-chip system. The processor came with a memory controller chip and a video controller chip and an I/O controller chip.
[42:28] And it was the 4-chip set that went into the early Acorn Archimedes product. And we were perfectly happy with fabricating through VLSI Technology.
42:40 — Why Acorn failed
Ryan:
[42:40] So this ARM chip that was developed, it was incredibly performant, superior technology in many regards. But I saw that Acorn eventually kind of failed after— Acorn, the company, not ARM failed eventually. Why did it fail if the technology was superior?
Steve:
[43:04] Acorn had pushed the technology out in a joint venture with Apple and VLSI Technology in 1990. And there was good reason for this. I mean, Apple had come knocking saying they wanted to use the ARM in the Newton. But they would be more comfortable if it was an independent company. And Acorn’s business kind of stopped growing in the second half of the ‘80s, so they were quite keen to offload the cost of continuing ARM development.
[43:37] So Apple was effectively pushing on an open door, and the company was set up very quickly. And Acorn retained a shareholding in ARM. But Acorn itself was a company that was also listed on the stock exchange, and it reached the point where the value of ARM shares that Acorn owned was higher than the total value of all the Acorn shares. And at that point, they decided that it was not viable to continue as they were.
44:10 — Neuromorphic computing
Ryan:
[44:10] And so you left and you went to academia, and I saw that some of what you were working on was this SpiNNaker architecture and this idea of neuromorphic computing. Could you explain what that is?
Steve:
[44:30] So around 2000, I began to think that maybe just trying to sell asynchronous technology to industry was not going to succeed. And I got interested in thinking about computers and brains, what’s similar, what’s different, and how could my group as computer engineers contribute something to sort of understanding the mysteries of the brain. And after quite a long time thinking about this, including some key formative thinking periods while I was on sabbatical with Sun in 2005, we came to a set of ideas that formed the basis of the SpiNNaker project.
[45:22] So you use the word neuromorphic. Neuromorphic goes back to the 1980s and a group led by Carver Mead at Caltech, who observed close analogies between the equations that describe the flow of ions in ion channels in biological neurons and the flow of carriers in transistors operating in the subthreshold region. And they developed a number of sensor chips based on this analogy. And since then, neuromorphic technology has expanded to include a wider range of approaches.
[45:55] And SpiNNaker is not subthreshold analog, it’s all digital, but it’s still to a significant degree brain-inspired. Well, the goal of SpiNNaker was to build a platform for modeling brain regions. And we set ourselves the goal of putting a million Arm processors into a single computer that we could couple to run real-time models of brain regions in biological real time. In other words, the same speed as the biology.
[46:23] And the key feature of the machine that’s brain-inspired is how we connect those processors. Because the brain is very highly connected. Typical cortical neurons connect to 5,000 to 10,000 other neurons. So that’s the kind of degree of connectivity we had to aim for. And that gives SpiNNaker a unique communication system. It’s not a general-purpose communication system. It’s not good for everything, but it’s good at this one thing.
Ryan:
[46:56] You mentioned synchronous, asynchronous, or I presume that’s equivalent to clock and clockless.
Steve:
[47:03] Yes.
Ryan:
[47:03] What’s the pro and con of the two approaches?
Steve:
[47:08] Well, most electronic circuits operate off a clock. So a clock provides a regular beat that keeps all the activity on the chip in synchrony. An asynchronous circuit does not have that global clock. It has local circuits which manage the transmission of data from one unit to another, and generally that’s done as soon as the data is ready. So some parts of the chip can be running quite quickly and others quite slowly, and it’s just local management.
[47:41] It’s a bit more complex to design asynchronous circuits, particularly as the industry EDA tools don’t manage them very well. So that’s a drawback of asynchronous design. One of the advantages of asynchronous design is you generate far less radio interference, and the current spikes are less severe because the activity is not synchronized. Okay. So on a synchronous chip, when you hit the clock, lots of things switch straight away, and that gives you big transients in the supply current.
[48:19] In an asynchronous design, that doesn’t happen. And it also means that the radio emissions you get off are much lower and sort of broader spectrum than with the clocked design. But you can also enable things to go at their own speed. One view of a clock is it slows all the faster circuits down to match the speed of the slower circuits so that everybody keeps in step. In an asynchronous circuit, you don’t need to do that.
[48:51] The faster circuits can go faster.
48:52 — Winning an IMO medal
Ryan:
[48:52] When I was doing the research for this interview, I saw that I think this was in 1970, you won an IMO medal representing the UK. What was it like competing in the IMO back then, and how’d you get into it?
Steve:
[49:11] So I got into it because the school I attended regularly put pupils in for the National Mathematics Contest, as it was called in the UK. And that was a contest which was used to select the British team for the International Maths Olympiad. And one year I came in the top. I think there were 8 pupils sent to the IMO. The year I went, the IMO was in Hungary in a place called Keszthely, I think, if I remember right.
[49:48] And the nature of the IMO is loads of school kids, roughly end of school age, sit down and do exams for a couple of days, which then get marked and assessed. And there are a number of gold medals, a number of silver, a number of bronze. I got a bronze medal that year. But it was interesting. I was used to doing a lot of maths at school. I mean, my sixth form subjects were double maths and physics.
[50:21] And physics is kind of just another maths, really. So I was used to doing a lot of maths and enjoyed it. And that’s when I went to Cambridge, I went up to read maths. Later switched from maths to engineering and aerodynamics. But right through school and undergraduate university, I was a mathematician.
50:45 — His most proud engineering
Ryan:
[50:45] When you look back on your career, is there some particular engineering work you’re most proud of?
Steve:
[50:54] Arm is probably the singular highlight because it’s become so globally dominant. The last figure I heard is that over 350 billion Arm-powered chips have been shipped by Arm’s partner network. I mean, Arm itself doesn’t — well, until recently, didn’t make any silicon. It has now started making some AI silicon, I believe. But the fact that Arm is sort of everywhere on the planet now, and whenever you go into a room full of people, there are more Arm processors in the room than there are heads.
[51:31] It is something that, you know, I’m pleased to have been there at the beginning and formed the seed. Of course, thousands of people since have worked to make that success that it is.
51:46 — Top technical book recommendation
Ryan:
[51:46] Are there any book recommendations that were impactful for you, or something that you would recommend to others?
Steve:
[51:55] If you want advice for people wanting to work in computer architecture, then of course you have to go to the Hennessy and Patterson book. Or is it Patterson and Hennessy? I can—they seem to change their names around at random. But they’ve written a couple of books on computer architecture and computer organization, which are the books on the subject.
Ryan:
[52:20] With all the experience that you have now, if you could go back to yourself when you just entered the industry and give yourself advice, what would you say?
52:29 — Advice for young people
Steve:
[52:29] I think my advice is still the same: when you start, you go through school, you have subjects you like, subjects you don’t. What do you do at university? Is it obvious? For a few people, there’s a vocational calling that makes it clear. If you want to be a doctor, you better do medicine, right? If you want to be a vet, you need to do veterinary science, and so on.
[53:02] But most people are not so specific in what they want to do. And my general advice is, if you have to make a choice, then choose the course that keeps the most doors open, right? So try and maximize your future options unless you have a very specific course you want to follow. And look for opportunities as they arise. So I was 10 years in the university, undergraduate, PhD, research fellowship. That was maths and aerodynamics.
[53:43] But then the personal computer business was taking off, and that was clearly an opportunity. I mean, today, where are the opportunities? Well, I think you’d have to highlight AI as an area which is going to have huge impact. It’s already started. And there are many aspects to it. There’s designing better chips for AI at the hardware level, but there’s all sorts of ethical and philosophical issues at the very high levels and the software in between where people can have an impact.
[54:23] And that’s just in the computing domain. I mean, there’s lots of exciting things happening in the life sciences as well, which are quite a different subject area and one I know much less about.
Ryan:
[54:35] Awesome. Well, thank you so much for your time, Professor. I really appreciate it.
Steve:
[54:40] Okay, you’re welcome.










