Kathleen Hylda Valerie Booth (1922-2022) invented assembly language – the first bridge allowing humans and machines to communicate without thinking in pure binary. She co-designed three pioneering computers at Birkbeck College, demonstrated the first public machine translation from French to English in 1955, and researched neural networks from the 1950s through her seventies. Yet for decades, her foundational work remained largely invisible, overshadowed by collaborative dynamics, gender hierarchies, and the tendency to render infrastructure itself invisible when it works too well.
Dr Booth, thank you for joining us today. I’m extraordinarily pleased to welcome you. It’s Thursday, 20th November 2025, and we’re speaking from your home on Vancouver Island. When people encounter computers today – whether writing code, using smartphones, or engaging with artificial intelligence – they’re relying on innovations you pioneered more than seventy years ago. Yet until very recently, your name has been largely absent from computing history. How does it feel to be having this conversation now?
Well, it’s rather peculiar, isn’t it? I turned 103 in July, and suddenly people want to know about work I did when I was in my twenties. I suppose I’m pleased, though I must admit I find the fuss a bit bewildering. We were just getting on with the job, you see. There were calculations to be done, machines to be built, and problems that needed solving. The idea that anyone would care seventy-odd years later never crossed my mind.
Your work fundamentally changed how humans interact with computers. Before your assembly language, programmers had to think entirely in binary – strings of ones and zeros. Can you take us back to 1947 at Birkbeck College? What was the problem you were trying to solve?
The problem was rather simple to state but beastly to address: humans don’t think in ones and zeros. Andrew and I were building the ARC – the Automatic Relay Calculator – primarily for crystallography calculations. Frightfully tedious work, determining crystal structures from X-ray diffraction data. Endless Fourier transforms. We knew a machine could do it faster than humans with desk calculators, but first someone had to tell the machine what to do.
The difficulty was that the machine only understood binary. If you wanted it to transfer a value from memory into the arithmetic register and clear the register first, you’d write something like 10011 followed by the memory address. Imagine writing an entire programme that way. Pages and pages of ones and zeros. One mistake – one single digit wrong – and the whole thing would fail, and you’d have no idea where the error was. It was like trying to speak to someone in a language consisting only of two sounds.
So you created a new language – what you called ‘contracted notation.’
Yes, though I didn’t think of it as inventing a language at the time. I thought of it as making a sensible notation system. Instead of 10011, you could write M -> cR, meaning “move the contents of memory location M into the cleared arithmetic register R.” Mnemonic instructions, we called them. Symbols that actually meant something to a human brain.
The real trick wasn’t just creating the notation – that was the easy bit, really. The hard bit was writing the assembler, the programme that would translate these symbolic instructions back into the binary the machine could execute. The machine had to do the work of translation itself, you see. That’s what made it revolutionary, though I didn’t know we were being revolutionary. We just needed to get the calculations done.
Let’s explore the technical details for readers with computing backgrounds. Walk us through how your assembler for the ARC2 actually worked – step by step, from the programmer’s symbolic instruction to the machine’s execution.
Right. Let’s take a concrete example. Suppose you want to add the contents of memory location 37 to the accumulator. In pure machine code, you’d need to specify the operation code for addition – let’s say that’s represented by 01010 – followed by the address 00100101 for location 37. Sixteen bits of binary, and heaven help you if you transpose two digits.
In contracted notation, you’d simply write ADD 37. Much clearer, wouldn’t you say? The assembler programme I wrote would read that symbolic instruction, look up ADD in a table of operation codes to find 01010, convert the decimal address 37 into binary 00100101, concatenate them into the proper instruction format, and store the resulting machine code at the appropriate location in memory.
But here’s where it becomes interesting: the assembler also had to handle symbolic addresses. You might want to write LOOP: ADD TOTAL, where LOOP and TOTAL are labels rather than numeric addresses. The assembler had to make two passes through your programme – the first pass building a symbol table noting where each label was defined, the second pass replacing each symbolic reference with the actual numeric address.
The ARC2 had a magnetic drum for storage – rotating at 3,000 revolutions per minute, if memory serves. Dreadfully slow by modern standards, but we thought it terribly clever at the time. The assembler had to account for timing – the optimal placement of instructions on the drum so that when one instruction finished executing, the next was just arriving under the read head. Otherwise you’d waste an entire rotation waiting. It was rather like choreographing a ballet.
That’s fascinating – the consideration of physical rotation speed in your assembler design. How did your assembly language compare to what came before or what contemporaries were developing?
Well, there wasn’t much that came before, you see. That was rather the point. Some people were using what they called ‘initial orders’ – Maurice Wilkes at Cambridge had something of that sort for EDSAC a bit later. But those were more about loading programmes into memory than providing a symbolic language.
The advantage of our contracted notation was that it was comprehensive. It wasn’t just shorthand; it was a complete translation system. Every machine operation could be represented symbolically. Every address could be named rather than numbered. The assembler handled all the bookkeeping – tracking addresses, resolving labels, even optimising placement on the drum.
The trade-off, of course, was that you needed memory to store the assembler itself, and time to run it. But the alternative was spending days writing binary by hand and then days more debugging when it inevitably went wrong. Our assembler might take a few minutes to run, but it saved weeks of human effort. The efficiency gain was enormous.
You mentioned the magnetic drum storage. That was another innovation you and Andrew pioneered, wasn’t it?
Andrew always gets the credit for that, and fair enough – it was his idea initially. But I did a good deal of the testing and refinement. The concept came from a visit to America in 1947, actually. We’d gone to Princeton to meet von Neumann, which was tremendously exciting. While we were there, Andrew saw a device called the Mail-a-Voice – a dictation machine that recorded onto paper discs coated with magnetic material.
Andrew thought, ‘Right, we’ll make one of those for computer storage.’ He tried paper first. It disintegrated at the speeds we needed. Then he tried a brass cylinder – about two inches in diameter, two inches wide initially – coated with nickel plating. That worked. We could store ten bits per square inch, which sounds absurd now but was rather impressive then.
My job was working out how to read and write reliably, how to synchronise the electronics with the drum rotation, how to organise data so you could access it efficiently. It was fiddly work. The read heads had to be positioned just right – too far from the surface and you’d lose the signal, too close and they’d scrape. I spent rather a lot of time with a micrometer making tiny adjustments.
You built these machines with your hands – literally soldering circuits, positioning components. That’s quite different from how we often imagine early computer scientists.
Oh, there was no distinction then between ‘hardware’ and ‘software,’ as you call them now. If you wanted a computer, you built it. We had a small workshop at Birkbeck – Andrew, myself, Xenia Sweeting initially, and a few others over the years. We’d order valves – thermionic tubes, you’d call them vacuum tubes – mostly government surplus from the war. Six-J-six double triodes, those were our workhorses. Cost almost nothing because the government was desperate to offload them.
We’d design a circuit, build it, test it, discover it didn’t work, redesign it, rebuild it. Then we’d write programmes to test it further. I’d find a fault in the machine by watching how my programme misbehaved, or find a fault in my programme by observing how the machine behaved oddly. It was all rather interconnected.
Andrew was better with the circuitry design, I’ll grant him that. His training in physics gave him an intuition for that sort of thing. But I did my share. When you’re a team of two or three people building a computer, you can’t afford to be too specialised. I’ve soldered thousands of connections in my time.
Let’s talk about the computing department you co-founded. In 1957, you and Andrew established the Department of Numerical Automation at Birkbeck – likely the first university computing department in Britain. What was teaching computing like when computing barely existed as a discipline?
It was rather like building a ship whilst sailing it, if you take my meaning. We had no textbooks – I had to write one myself in 1958, ‘Programming for an Automatic Digital Calculator.’ There were no established curricula, no consensus on what a computing student ought to learn. We were inventing the pedagogy as we went.
I taught some of the first programming courses beginning in ’58. The students were mathematicians, mostly, though we had a few physicists and engineers. They’d come in thinking computers were just fast calculators – which, to be fair, was how most people saw them – and I’d have to teach them that programming was something altogether different. It wasn’t just arithmetic; it was logic, structure, algorithmic thinking.
The frustrating bit was that many people – university administrators, particularly – saw programming as clerical work. Typing instructions into a machine, you see. Women’s work, they thought, though they wouldn’t say it quite so directly. Never mind that designing an algorithm requires as much mathematical sophistication as deriving a proof. Never mind that debugging a complex programme demands rigorous logical reasoning. Because it involved a keyboard, it was ‘secretarial.’
That perception – programming as clerical work – seems to have contributed to your contributions being minimised. You’ve been described in historical accounts as Andrew’s ‘research assistant,’ despite being a PhD mathematician yourself.
Yes. That’s… that’s been rather difficult, actually. I don’t like to complain – it’s not in my nature – but I won’t pretend it hasn’t stung over the years.
I earned my PhD in Applied Mathematics from King’s College London in 1950. My thesis was on crystallographic calculations – original mathematical work. I wasn’t Andrew’s assistant; I was his colleague. We married that same year, and we worked together for decades, but ‘together’ doesn’t mean ‘subordinate.’
I designed the ARC assembly language. I wrote the assembler and autocode. I built hardware components for all three machines – ARC, SEC, and APE(X)C. I wrote the software, debugged the systems, conducted the testing. I co-authored papers, co-founded the department, taught courses. I directed our machine translation research.
But because Andrew was the department head, because he was the ‘outgoing figure’ as someone once put it, he became the face of our work. People would visit Birkbeck, speak with Andrew, tour the laboratory, and I’d be in the background working on a circuit board or writing a programme. If they acknowledged me at all, it was ‘Oh, and this is Mrs Booth, Andrew’s assistant.’
I tried not to let it bother me. We had work to do, and the work was interesting. But when you watch history being written in real-time, and you’re being written out of it… well. It does rather hurt.
The machine translation work you directed culminated in a public demonstration on 11th November 1955 – the first public demonstration of computer translation anywhere in the world. Tell us about that day.
That was rather exciting, I must say. We’d been working on machine translation since the late 1940s, actually. Warren Weaver at the Rockefeller Foundation – he was funding our computer research – suggested we look into translation. He thought it might be feasible.
Most people thought we were mad. Translating between languages requires understanding meaning, context, grammar – all the messy, imprecise things that humans do intuitively but machines can’t grasp. But we thought we might manage something rudimentary, at least for technical texts with limited vocabulary and straightforward syntax.
I developed the programmes for it. We started with French to English – French was my stronger foreign language. I built dictionaries as data structures, grammatical rule sets, routines for word-order transformations. Primitive by today’s standards, obviously, but we were charting entirely new territory.
For the demonstration, I typed a French sentence into the computer – I remember it precisely: ‘C’est un exemple d’une traduction fait par la machine à calculer installée au laboratoire de Calcul de Birkbeck College, Londres.’ The machine printed out: ‘This is an example of a translation made by the machine for calculation installed at the laboratory of computation of Birkbeck College, London.’
Not perfect grammar – ‘machine for calculation’ is awkward – but comprehensible. And remember, this was 1955. People were astonished that a computer could do anything with language. The demonstration showed that linguistic processing was possible, that computers could handle symbolic manipulation beyond arithmetic.
That work presaged modern natural language processing by decades. Yet you’re rarely mentioned in histories of computational linguistics or machine translation.
No, I’m not. The Georgetown-IBM demonstration in 1954 – Russian to English – gets most of the attention. That was a bigger production, more sentences, more publicity. Ours was smaller-scale, and we were working at little Birkbeck with minimal funding, not IBM with vast resources. So we were forgotten.
It’s the same pattern as with assembly language, isn’t it? The work becomes so fundamental that people assume it must have always existed, or that it emerged spontaneously from multiple sources without clear attribution. But someone had to do it first. In machine translation’s case, we were first. In assembly language’s case, I was first. The historical record simply… failed to record it accurately.
Your neural networks research extended from the 1950s through to 1993, when you published a paper on identifying marine mammals at age 71. That’s an extraordinary span – from the earliest days of artificial intelligence to the era of backpropagation and connectionist models.
Neural networks fascinated me because they represented a completely different approach to computation. Traditional programming is deterministic – you specify exactly what the machine should do, step by step. Neural networks learn from examples, adjust weights, recognise patterns without being explicitly programmed to do so. It’s much closer to how biological brains work.
I started experimenting with neural network simulations in the late 1950s, actually. Character recognition initially – could a network learn to distinguish letters? The computation was glacially slow on the machines we had then, but the principle worked. The network would make mistakes, adjust, improve. It was rather like watching a child learn to read.
The marine mammal work came much later, after we’d moved to Canada and I’d retired from formal academic positions. My son Ian and I worked on recognising individual seals from their vocalisations. Each seal has a distinctive call – like a voice print – and we wanted to train a network to identify which seal was which, even in noisy acoustic environments.
It worked surprisingly well, actually. The network achieved high accuracy even with background noise from waves, other animals, human activity. We published that in 1993, and I remember thinking how far the field had come. The networks were faster, the training algorithms more sophisticated, but the fundamental insight – that you can build systems which learn rather than systems which follow rules – that had been there all along.
Looking back at your trajectory – crystallography, computer design, assembly language, machine translation, neural networks – there’s remarkable breadth. You refused to specialise.
I suppose I was fortunate to work in an era when specialisation wasn’t yet mandatory. Computing was so new that everything was interconnected. You couldn’t study software without understanding hardware. You couldn’t write programmes without knowing mathematics. The boundaries we have now – between computer science and linguistics, between hardware engineering and software development – those didn’t exist yet.
That said, I’ve wondered sometimes if my breadth worked against me historically. Specialists are easier to categorise, easier to credit for specific innovations. ‘Grace Hopper invented the compiler.’ ‘Alan Turing developed the Turing machine.’ Clean narratives, single achievements.
My work was more diffuse. A bit of hardware here, some software there, machine translation over here, neural networks over there. How do you summarise that? ‘Kathleen Booth did… various things’? It doesn’t make for a compelling soundbite, does it?
But I wouldn’t have worked differently. The problems were interesting precisely because they crossed boundaries. Solving them required drawing on everything – mathematics, engineering, linguistics, logic. That’s what made the work satisfying.
In 1962, you left Birkbeck and moved to Canada. Andrew had been denied a permanent chair in Computer Science despite essentially creating the field at Birkbeck. How much did institutional frustration drive that decision?
Considerably. Andrew had applied for a chair – we’d built an entire department, trained students, published extensively, produced three pioneering computers, contributed to commercial computer development. The BTM HEC series, which became the ICT 1200 – those were based directly on Andrew’s APE(X)C design. Over a hundred machines sold. Birkbeck’s computing work had genuine impact.
The university rejected it. Said it was ‘too soon to see if computer science will have a long-term existence.’ In 1962! When computers were already transforming business, science, and government. It was absurd.
Andrew was furious, and rightly so. I was too, frankly. We’d given Birkbeck sixteen years. We’d done groundbreaking work with minimal resources and little institutional support. And they wouldn’t recognise it with a permanent chair.
So when the University of Saskatchewan offered Andrew a professorship and asked him to modernise their College of Engineering, we took it. New country, fresh start, proper recognition for his work – our work.
I won’t say I didn’t have regrets. We left our machines behind, left the students we’d trained, left London. But there comes a point where you have to acknowledge you’re not valued where you are, and it’s time to go somewhere you will be.
What was your experience like as a woman in computing during those decades? You were working in the 1940s and ’50s, long before discussions of gender equity in technology became mainstream.
Complicated. On one hand, there were actually quite a few women in early computing. Programming was seen as detail-oriented, requiring patience and precision – qualities people associated with women, rightly or wrongly. So women were hired as programmers, as operators, as ‘computers’ – that used to be a job title, you know. Human calculators.
But there was a ceiling. Women could do the programming, but men did the ‘real’ work – designing systems, making architectural decisions, managing projects. Even though the distinction was artificial. Programming is design. Writing an assembler is systems architecture. But people didn’t see it that way.
I was fortunate in some respects. I had a PhD, which gave me credibility. I worked with Andrew, which gave me access and protection – though it also meant my contributions were absorbed into his. I was at a small institution where informality allowed me to do work that might have been denied me at a larger, more hierarchical place.
But I was never under any illusions. If I’d been a man with my qualifications and achievements, I’d have had professorships, honours, recognition. As a woman, I was perpetually ‘the wife,’ ‘the assistant,’ the one working quietly in the background while others took credit.
Do you think you made mistakes? Looking back with hindsight, is there anything you’d have done differently?
Oh, certainly. I should have published more under my own name. Too much of our work was published jointly, or under Andrew’s name alone, or in technical reports that weren’t widely disseminated. I have relatively few solo publications, and that’s hurt my historical visibility.
It wasn’t deliberate, you understand. We were working together, so joint publication made sense. And publishing required time and effort that I was often putting into building hardware or writing code or teaching. But the result was that I didn’t establish an independent scholarly identity.
I should also have been more assertive about credit. When visitors came and spoke primarily to Andrew, I should have interjected more, made my contributions clearer. When papers described me as ‘research assistant,’ I should have insisted on ‘research fellow’ or ‘lecturer,’ which were my actual positions. But I didn’t want to seem difficult, and I was focused on the work rather than the recognition.
Those are regrets about strategy, though, not about the work itself. I don’t regret the choices I made about what to study or how to approach problems. The intellectual work was sound.
Your assembly language invention is now taken entirely for granted. Every programmer uses assemblers, compilers, interpreters descended from your innovation. Does it frustrate you that something so fundamental became invisible?
It’s ironic, isn’t it? The better your infrastructure works, the less people notice it. Nobody thinks about assembly language when they write Python or Java. It’s buried under so many layers of abstraction that it’s essentially invisible.
Part of me finds that satisfying, actually. It means we got it right. If programmers still had to think about assembly language constantly, it would mean we’d failed to create proper higher-level abstractions. The point of my work was to make programming easier, more accessible, more intuitive. The fact that modern programmers don’t have to know I existed means the vision succeeded.
But yes, there’s also frustration. Not for my sake so much – I’m 103 years old; my ego is rather past needing stroking – but for what it represents. Foundational work, particularly infrastructure work, particularly work done by women, becomes invisible. The inventors of flashy applications get remembered; the inventors of enabling infrastructure get forgotten.
That’s a problem because it shapes what we value and who we think belongs in computing. If the history only remembers the men who built machines and designed processors, it suggests computing is fundamentally masculine work. If we remember that women invented assembly language, wrote the first compilers, programmed the first computers, did pioneering work in artificial intelligence – suddenly the story is different. Women aren’t interlopers in computing; we were there from the start. We built the foundations.
Speaking of foundations – what advice would you give to young women, or any marginalised people, entering technology today?
Document your work. Publish under your own name. Make your contributions visible and unambiguous, because history won’t do it for you. People will default to giving credit to whoever is most prominent, most vocal, or most demographically similar to who they expect to do important work. You must actively counteract that.
Also: your work has intrinsic value even if it’s not immediately recognised. I did interesting, important work that changed the field fundamentally, and I knew it was important even when others dismissed it or attributed it elsewhere. That knowledge sustained me. Don’t let others’ failure to recognise your contributions make you doubt their worth.
And finally: there’s deep satisfaction in solving hard problems, in building things that didn’t exist before, in pushing the boundaries of what’s possible. Pursue that satisfaction. Do work that fascinates you, that stretches you, that matters. The recognition may come or it may not, but the intellectual joy of the work itself – that’s yours regardless, and no one can take it from you.
You’ve lived a century. You’ve seen computing go from relay calculators the size of rooms to supercomputers in our pockets. Seen your machine translation work evolve into systems that translate hundreds of languages instantly. Seen neural networks go from academic curiosities to the foundation of artificial intelligence. What does that feel like?
Astonishing. Absolutely astonishing. When we built ARC in 1946, it filled a room, ran on hundreds of relays, and could barely do the calculations for a single crystal structure. Now you have more computing power in your telephone than existed in the entire world when I was young.
Sometimes I wonder what we could have done with modern resources. If I’d had the processors, the memory, the storage available now when I was developing neural networks in the 1950s… but that’s futile thinking, isn’t it? We worked with what we had, and we did good work.
What moves me most is that the fundamental concepts we developed – stored programmes, symbolic instruction sets, pattern recognition, computational linguistics – those endure. The implementations have changed unrecognisably, but the ideas remain. We weren’t just building machines; we were establishing principles that would shape the field for generations.
I’m glad I lived long enough to see some recognition, to see Birkbeck establish the Booth Memorial Lecture, to see scholars reconstructing the history more accurately. I wish it hadn’t taken until I was a hundred for people to notice, but better late than never, I suppose.
Any parting thoughts for readers who’ve stayed with us through this conversation?
Just this: when you write code, when you use symbolic instructions rather than binary, when you rely on compilers and assemblers and interpreters, remember that someone had to invent those things. They didn’t spring fully-formed from the foreheads of computing gods. They were created by people solving practical problems with limited resources and unlimited determination.
And remember that many of those people were women, working in the shadows, building the infrastructure you rely on daily. We were there at the beginning. We built the foundations. The next time you type ADD 37 instead of 01010 00100101, think of Kathleen Britten, age twenty-five, sitting in a cold laboratory at Birkbeck in 1947, thinking: ‘There must be a better way.’
There was. And I found it.
Letters and emails
Following the interview above, we received hundreds of letters and emails from readers keen to explore Kathleen’s work further. Her story has resonated across continents – from software engineers wrestling with modern compiler design to educators rethinking how programming is taught, from AI researchers grappling with ethics to hardware preservationists trying to recover lost technical knowledge. We’ve selected five of the most thoughtful contributions, representing voices from Africa, Asia, Europe, North and South America. These questions reach beyond the interview itself, probing the technical decisions that shaped her innovations, the philosophical tensions in her work, the personal knowledge that never made it into academic papers, and the lessons her life might offer to those building the future of computing. Each correspondent brings their own expertise and perspective, seeking to understand not just what Kathleen accomplished, but how she thought about problems, what she might have done differently, and what wisdom she’d offer to those following similar paths in technology today.
Farah Siddiqui, 34, Software Engineer, Karachi, Pakistan
You mentioned that your assembler made two passes through the programme – one to build the symbol table and another to resolve addresses. In modern compiler design, we still use multi-pass architectures, but we also have single-pass compilers and just-in-time compilation. Looking back, did you ever experiment with single-pass assembly, or were the hardware constraints of drum memory rotation timing simply incompatible with that approach? I’m curious whether the two-pass design was an elegant solution or a necessary compromise given the technology available.
That’s a perceptive question, Ms Siddiqui, and it gets at something I’ve thought about rather a lot over the years. The two-pass design wasn’t my first choice, actually – it was what the constraints demanded, and I had to make peace with it.
Initially, I tried to develop a single-pass assembler. It seemed more elegant, didn’t it? Read through the programme once, translate as you go, finish with a complete binary. But the drum memory made it nearly impossible. The problem was forward references – situations where you’d write something like JUMP ENDLOOP before you’d defined where ENDLOOP actually was in the programme.
In a single-pass system, when you encounter that jump instruction, you don’t yet know the numeric address of ENDLOOP because you haven’t reached that part of the programme. You could try leaving a placeholder and patching it later, but on a drum rotating at 3,000 RPM, that meant either holding everything in the limited immediate-access storage – which we simply didn’t have enough of – or making additional drum rotations to go back and fill in the gaps. Each rotation took twenty milliseconds. Multiply that by dozens or hundreds of forward references, and you’ve turned a quick assembly into a tediously slow process.
The two-pass approach was actually faster, paradoxically. First pass: read through the entire programme, note where every label is defined, build the symbol table. That’s relatively quick because you’re just collecting information, not doing complex translations. Second pass: read through again, and now you know every address, so you can translate each instruction completely in one go. Two complete reads of the drum was faster than dozens of partial reads jumping back and forth.
There was another advantage I hadn’t anticipated initially: error detection. In the first pass, you could check for things like duplicate label definitions or invalid operation codes before attempting any translation. Better to catch those errors early than to generate partially-translated machine code that would fail mysteriously when you tried to run it.
Now, we did experiment with hybrid approaches. For very simple programmes with no forward references – purely sequential code – you could assemble in one pass. I wrote a simplified single-pass assembler for teaching purposes, actually, so students could see how the translation worked without worrying about symbol tables and multiple passes. But for real work, for complex programmes with loops and conditional jumps and subroutine calls, the two-pass design was necessary.
Modern compilers with your just-in-time compilation – that’s an entirely different beast, isn’t it? You have gigabytes of RAM where we had a few dozen words of immediate storage. You can hold the entire programme in fast memory simultaneously, reference anything instantly. The constraints that shaped my design simply don’t exist for you anymore.
But here’s what interests me: the principle remains relevant. Even today, when you’re working with resource-constrained systems – embedded devices, real-time controllers, systems where memory or processing time is genuinely limited – you face similar trade-offs. Do you optimise for speed or memory? Do you make multiple passes with lower memory overhead, or a single pass with higher memory requirements? The specific numbers change, but the fundamental engineering decisions are recognisable.
So to answer your question directly: yes, it was a necessary compromise, but it was also an elegant solution within those constraints. I wasn’t happy about it initially – I wanted the theoretical purity of single-pass assembly. But engineering isn’t about theoretical purity; it’s about solving real problems with real constraints. The two-pass design worked, it was efficient given the hardware, and it established a pattern that proved durable. Sometimes the compromise you’re forced into turns out to be the right answer after all.
Pablo Cifuentes, 39, Linguistic Anthropologist, Buenos Aires, Argentina
Your 1955 machine translation demonstration tackled French to English, but translation isn’t just word substitution – it’s navigating cultural context, idiomatic expressions, grammatical structures that don’t map cleanly between languages. How did you decide what linguistic phenomena to attempt and what to abandon as intractable? When the machine produced “machine for calculation” instead of “calculating machine,” did you see that as a failure of the programme or as revealing something fundamental about the limits of rule-based linguistic processing? And did working with translation influence how you thought about human-computer communication more broadly – assembly language as translation between human logic and machine logic?
Mr Cifuentes, you’ve put your finger on precisely the problem that made machine translation so maddeningly difficult – and so intellectually fascinating. Translation isn’t a mechanical process, despite what many people assumed in the early days. It’s interpretation, negotiation, cultural mediation. And we were trying to make a machine do it with nothing but stored instructions and lookup tables.
When we started the translation work in the late 1940s, I had to make brutal decisions about scope. We couldn’t possibly handle idiomatic expressions – “it’s raining cats and dogs” would have produced absolute nonsense if translated word-by-word into French. We couldn’t manage metaphor, cultural references, anything requiring world knowledge beyond the immediate linguistic structure. We had to restrict ourselves to what I called “translatable sublanguages” – technical and scientific texts with controlled vocabulary, straightforward syntax, minimal ambiguity.
Even then, the grammatical transformations were fiendishly complicated. French places adjectives after nouns – “la machine électronique” – whilst English reverses that order. My programme had to recognise the noun-adjective pattern, store both words temporarily, reverse their order, and output “the electronic machine.” Simple enough for one phrase, but when you have nested structures, multiple adjectives, prepositional phrases modifying nouns – it becomes combinatorially explosive.
I developed what I called “transformation rules” – essentially pattern-matching routines that would recognise specific grammatical structures and apply reordering operations. But every rule had exceptions. Every exception needed another rule. It was like trying to codify an entire language’s grammar into a finite set of mechanical procedures, which is of course impossible, though I didn’t fully appreciate that impossibility at the time.
The “machine for calculation” example you mention – that frustrated me for weeks. In French, “machine à calculer” uses the preposition “à” to indicate purpose: a machine for calculating. The English equivalent, “calculating machine,” uses a present participle as an adjective. But my programme didn’t understand purpose or function – it only understood word categories and reordering rules. So it translated “à calculer” as “for calculation” because that’s the literal meaning of the preposition and the noun, and it didn’t know that English would use a participial adjective instead.
I could have added a specific rule for this pattern: when you see “à” followed by an infinitive verb modifying a noun, convert it to a participial adjective in English. But then you need rules for which prepositions behave this way, which verbs can become participial adjectives, which word orders are acceptable – and suddenly you’re writing thousands of special-case rules, each one handling a tiny slice of linguistic behaviour.
At some point, I realised we weren’t going to achieve genuine translation – not with the approaches available in the 1950s. What we could achieve was useful approximation. A scientist reading our machine-translated French paper would understand the gist, grasp the key concepts, identify which papers warranted proper human translation. That was valuable, even if it wasn’t perfect.
As for whether I saw “machine for calculation” as a failure – yes and no. It was a failure of the specific programme, certainly. I should have anticipated that construction and written a rule for it. But it was also revealing something profound: rule-based translation has fundamental limits. Language isn’t just rules; it’s usage, convention, context, pragmatics. You can’t capture that with pattern-matching, no matter how elaborate your rule set becomes.
This absolutely influenced how I thought about human-computer communication more broadly. Assembly language is, as you say, translation – but it’s translation between two formal systems. Machine code and assembly language both have completely regular syntax, unambiguous semantics, no exceptions or special cases. Every instruction means exactly one thing, executes exactly one way. That’s why assembly language works – the translation problem is tractable because both source and target languages are perfectly regular.
Natural language isn’t formal. It’s messy, ambiguous, context-dependent, constantly evolving. Trying to translate between natural languages mechanically is trying to impose formal regularity onto something fundamentally irregular. It can’t fully succeed, not with rule-based methods.
I suspect – though I won’t live to see it confirmed – that genuine machine translation will require something closer to human language learning. Not rules, but exposure. Statistical patterns, contextual understanding, perhaps something like neural networks trained on vast amounts of translated text. The machine would need to learn translation the way children learn language: through immersion, pattern recognition, correction, gradual refinement.
Warren Weaver at Rockefeller – he funded our early work – once wrote a memorandum suggesting translation might work through statistical analysis of word frequencies and co-occurrences. I thought he was rather mad at the time. How could counting words possibly capture meaning? But looking back, I wonder if he was onto something. Not the full answer, certainly, but perhaps a piece of it.
The irony is that machine translation today – or so I’m told – works essentially through brute-force statistical pattern matching on enormous datasets, which is rather closer to Weaver’s vision than to my rule-based approach. We were trying to teach the machine the rules of language. Perhaps what we should have been doing was showing it millions of examples and letting it extract its own patterns.
But we didn’t have millions of examples, or the computational power to process them. We had what we had. And given those constraints, rule-based translation was the only feasible approach. It was limited, certainly, but it demonstrated that linguistic processing by machine was possible – that computers could handle symbolic manipulation beyond arithmetic. That opened doors, even if we couldn’t walk through them very far ourselves.
Thulile Khosa, 42, Mathematics Educator, Johannesburg, South Africa
You taught some of the first university programming courses when there were no textbooks, no established pedagogy, no consensus on what students even needed to learn. I teach computational thinking to secondary school students now, and I constantly wonder: what’s essential versus what’s just historical accident in how we teach computing? When you were designing those first courses in 1958, what did you decide was absolutely fundamental – the core concepts every computing student must grasp – versus what was specific to the machines of your era? Do you think we’ve kept the right things and discarded the right things as computing education evolved?
Ms Khosa, what a lovely question – and how I wish I’d had a clear answer when I was designing those first courses. I didn’t, actually. I was improvising rather desperately, trying to work out what these students needed whilst simultaneously working out what computing was as a discipline.
When I taught my first programming course in 1958, I had to make immediate decisions about fundamentals. The students – mostly mathematicians, a few physicists – arrived expecting computing to be applied mathematics. Numerical analysis with machines. And whilst that was part of it, I knew programming was something else entirely, something that didn’t fit neatly into existing academic categories.
The first truly fundamental concept I settled on was algorithmic thinking – the ability to decompose a problem into a precise sequence of unambiguous steps. That sounds obvious now, but it wasn’t obvious then. Mathematicians were accustomed to elegant proofs, not step-by-step procedures. They’d write something like “compute the roots of this equation” without specifying how. That’s perfectly acceptable in mathematics – the existence of roots is separate from the method of finding them.
But programming requires the how. You must specify every single step: load this value, compare it to that value, branch here if the condition holds, otherwise go there. No ambiguity, no implicit steps, no “obviously one then does this.” I spent considerable time teaching students to think procedurally, to make every operation explicit.
The second fundamental was understanding the distinction between data and instructions – what von Neumann called the stored-programme concept. This was conceptually difficult for many students. They’d think of programmes as external things, instructions you fed into a machine. The idea that programmes and data both lived in memory, that a programme could modify itself or generate new programmes, that you could write programmes to manipulate programmes – that was genuinely revolutionary thinking.
I remember one student – bright young woman, excellent mathematician – who simply couldn’t grasp why you’d want a programme in memory rather than on punched tape. “Surely it’s safer on tape,” she said. “You can’t accidentally overwrite it.” She wasn’t wrong, technically, but she was missing the power of self-modifying code, of programmes that adapt their behaviour based on data, of treating programmes as data structures to be manipulated.
Third fundamental: the relationship between symbolic notation and machine execution. I insisted students learn both assembly language and machine code – write a programme in contracted notation, hand-assemble it to binary, trace through the machine execution step by step. Many students resented this. “Why must we learn the low-level details? Why can’t we just use the assembler?”
But I believed – still believe – that you can’t truly understand what a programme does unless you understand how it executes at the machine level. Otherwise, programming becomes magical thinking: you write symbols, something mysterious happens, results appear. That’s dangerous. When things go wrong – and they always go wrong – you need to understand the mechanism. You need to know that ADD 37 becomes a specific bit pattern that causes specific circuits to activate, that transfers a value from a specific memory location into a specific register. The abstraction is useful, but only if you comprehend what it’s abstracting.
Now, what did I teach that was probably specific to our era and might not be essential now? Quite a lot, honestly. I spent considerable time on optimising for drum memory timing – arranging instructions so each one arrived under the read head precisely when needed. That was crucial for our machines, but it’s completely irrelevant to modern computing with random-access memory. I taught specific techniques for conserving memory – storing multiple values in a single word, reusing storage locations, clever tricks to reduce space. Again, useful then, probably pointless now when you have gigabytes to work with.
I also taught a great deal about numerical methods – how to compute logarithms, exponentials, trigonometric functions using polynomial approximations. We didn’t have library functions or mathematical coprocessors; if you wanted sin(x), you had to implement it yourself using Taylor series or CORDIC algorithms. That’s mostly obsolete now, though I do wonder if modern programmers lose something by never implementing these functions themselves. Understanding how the mathematics works inside the machine – that seems valuable, even if you’ll never actually write your own sine function in practice.
But here’s what troubles me about modern computing education, based on what I’ve observed: I fear we’ve lost the connection between abstraction and mechanism. Students today learn Python or Java – very high-level languages, wonderfully expressive – but do they understand what happens when they write x = y + z? Do they know that becomes assembly instructions, which become machine code, which activates circuits? Or is it just magic?
I’m not suggesting everyone needs to learn assembly language, mind you. That would be impractical. But some understanding of the layers, some sense that abstraction is built on mechanism – that seems fundamental in a way that transcends any particular era.
The other thing I worry we’ve lost is the habit of reading code critically. When you had to hand-assemble programmes and trace through execution manually, you developed a very careful, attentive relationship with code. Every instruction mattered. Every branch point required thought. You couldn’t afford to be careless.
Now, with powerful tools that hide complexity, I suspect students can write large programmes without truly understanding them. They copy code from online sources, assemble libraries they don’t comprehend, hope everything works without knowing precisely why it works. That concerns me. Computing requires rigour. The machine does exactly what you tell it, nothing more and nothing less. If you don’t know what you’ve told it, you’ve lost control.
So, to answer your question directly: the fundamentals I’d preserve are algorithmic thinking, understanding data versus instructions, grasping the relationship between abstraction and mechanism, and cultivating careful, critical reading of code. Those transcend any particular technology.
What we can safely discard: specific optimisation techniques for obsolete hardware, hand-assembly of machine code, implementing standard mathematical functions from scratch. Those were necessary in my time but aren’t essential to understanding computing fundamentally.
Though I’ll add one caveat: teaching should occasionally include impractical things, things students won’t use in industry, but which deepen understanding. Having students implement a simple assembler, write a basic interpreter, build a small compiler – these are formative experiences even if they’ll never do it professionally. They reveal how abstraction is constructed, how languages are implemented, how machines actually work. That’s the difference between training someone to use tools and educating them to understand principles.
I tried to do the latter, though I’m not certain I always succeeded. Teaching is harder than building computers, I can tell you that with confidence. At least computers do what you tell them.
Landon Pierce, 28, AI Ethics Researcher, Toronto, Canada
Your neural networks research spanned from the 1950s through 1993 – essentially the entire arc from Rosenblatt’s perceptron to backpropagation becoming standard. Today, we’re grappling with questions about algorithmic bias, explainability, and whether neural networks can truly “understand” what they’re processing. Did you ever have philosophical doubts about pattern recognition systems making consequential decisions? When you were training networks to identify marine mammals, did you worry about what happens when the network gets it wrong, or did the stakes feel low enough that pure curiosity could drive the work?
Mr Pierce, that’s a profound question, and one I’ve wrestled with considerably – particularly in my later years when I returned to neural networks research and watched the field develop in directions I’d never anticipated.
The short answer is yes, I had doubts. Not constantly, but they surfaced at particular moments when the gap between what the system was doing and what we claimed it was doing became uncomfortably apparent.
The marine mammal work is actually a useful example because the stakes were relatively low, as you say. We were trying to identify individual seals – Weddell seals, primarily – from their underwater vocalisations. Each seal has distinctive call characteristics: frequency patterns, temporal structure, harmonic content. Train a neural network on labelled examples, and it learns to recognise which seal is vocalising based on these acoustic features.
When the network succeeded, it was rather satisfying. You’d present it with a new recording, and it would correctly identify the individual. But when it failed – and it did fail, perhaps ten or fifteen percent of the time – I’d find myself wondering: what went wrong? Was the recording too noisy? Was this seal producing an unusual variant of its typical call? Or had the network simply not learned the relevant features properly?
The troubling bit was that I couldn’t know. The network was a black box. I could examine the weights, trace the activation patterns, but I couldn’t say “the network failed because it confused the third harmonic of seal A with the fundamental frequency of seal B.” The network didn’t think in those terms. It thought – if “think” is even the right word – in distributed patterns of numerical weights that bore no obvious relationship to the acoustic features I understood as a human researcher.
This bothered me philosophically. When I wrote a traditional programme – an assembler, a calculation routine – I could explain every step. “This instruction does X, then this one does Y, and therefore the result is Z.” Complete transparency. Complete accountability. If something went wrong, I could trace through the logic and find the error.
Neural networks offered no such transparency. They worked – when they worked – through statistical regularities I couldn’t articulate. And when they failed, I often couldn’t explain why. I found that… unsettling.
Now, in the seal identification work, this was acceptable. We weren’t making consequential decisions. If the network misidentified a seal, we’d check manually, correct the error, perhaps retrain with additional examples. No harm done. The network was a research tool, not an autonomous decision-maker.
But I extrapolated forward – what if we were using neural networks for medical diagnosis? For credit decisions? For determining whom to hire or admit to university? Then the lack of explainability becomes deeply problematic. “The network says you don’t qualify for a loan, but we can’t tell you why” is hardly satisfactory, is it?
I didn’t have the vocabulary then that you have now – “algorithmic bias,” “explainability,” “transparency” – but I understood the underlying concern. These systems learn from data, and if the data contains human prejudices, the network will learn those prejudices and reproduce them with the veneer of mathematical objectivity. That’s dangerous.
There was an incident in the 1960s – I can’t recall the exact details, but some American researchers trained a network to classify faces. It worked brilliantly on their test data. Then someone noticed it performed very poorly on faces of people who weren’t white. Turns out the training data was overwhelmingly white faces – the network had learned features specific to that population and failed to generalise. The researchers hadn’t intentionally built a racist classifier, but that’s what they’d created, nonetheless.
That stuck with me. The network doesn’t have intentions or biases in the human sense, but it reflects the data it’s trained on. If the data is skewed – by class, by race, by gender, by geography – the network’s classifications will be skewed correspondingly. And because the network can’t explain its reasoning, you might not notice the bias until it causes harm.
My concern intensified when I watched neural networks begin to be deployed commercially. In the 1980s and 1990s, companies started using networks for credit scoring, fraud detection, hiring decisions. I worried – do these people understand what they’ve built? Do they know the network might be making decisions based on proxies for protected characteristics? Have they tested for demographic disparities in outcomes?
Often, I suspected, they hadn’t. They’d seen impressive accuracy on test data and assumed that meant the system was fair. But accuracy isn’t the same as fairness. A network can be very accurate on average whilst being systematically biased against specific subgroups.
The philosophical question underneath all this is: what does it mean for a system to “understand” what it’s doing? When my assembler translates ADD 37 into machine code, it doesn’t understand addition. It’s mechanically applying translation rules. But we accept that because the rules are transparent and the behaviour is predictable.
When a neural network classifies a seal’s call, does it understand acoustic features? I don’t think so. It’s found numerical patterns that correlate with classifications, but correlation isn’t comprehension. The network has no concept of frequency or harmonics or temporal structure – just weights and activation functions.
And yet it works. That’s the paradox. These systems perform tasks we’d describe as requiring understanding when humans do them, but the systems themselves have no understanding whatsoever. They’re sophisticated pattern-matching mechanisms, nothing more.
Does that matter? For seal identification, probably not. For consequential decisions affecting human lives – I think it matters enormously. We should be very cautious about delegating important decisions to systems we can’t explain, that reflect biases we can’t detect, that fail in ways we can’t predict.
Here’s what I’d want researchers and developers to consider: just because you can build a neural network to make a particular decision doesn’t mean you should. Ask whether the task requires explainability – if so, neural networks may be inappropriate. Ask whether your training data contains biases – if so, your network will learn them. Ask whether you can test for disparate outcomes across demographic groups – if not, you shouldn’t deploy.
I’m not anti-neural networks, mind you. They’re powerful tools for pattern recognition, and I’ve spent decades working with them. But tools can be misused. A hammer is excellent for driving nails and terrible for performing surgery. Neural networks are excellent for certain tasks – image recognition, acoustic classification, pattern detection in noisy data – and potentially terrible for others, particularly tasks requiring transparency, accountability, or protection against bias.
The marine mammal work felt like pure curiosity because it was. We were asking: can networks learn this? The answer was yes, which was scientifically interesting. But the jump from “can we?” to “should we deploy this in consequential settings?” requires additional considerations – ethical, social, political considerations – that I’m not certain the field has adequately grappled with.
Perhaps I’m old-fashioned. Perhaps my attachment to transparency and explainability reflects my training in an era when programmes were small enough to understand completely. Modern systems are vastly more complex – millions of lines of code, millions of network parameters – perhaps complete understanding is simply impossible now, and we must accept that.
But I’m not comfortable with that acceptance. When we don’t understand our tools, we can’t predict their failures or correct their biases. We’re not engineering systems; we’re conjuring them and hoping they behave appropriately. That strikes me as rather dangerous, even if the seals don’t seem to mind.
Jelena Marić, 31, Hardware Preservation Specialist, Belgrade, Serbia
I work on preserving and occasionally reconstructing historical computing hardware, and one challenge we face is that so much tacit knowledge – the undocumented tweaks, the “feel” for when something’s working correctly – gets lost when pioneers pass away. You mentioned spending hours with a micrometer adjusting read head positions on the magnetic drum, finding the precise distance where signal was strong, but the head didn’t scrape. If you could go back and document one aspect of the hands-on, physical craft of building those early machines that never made it into the published papers or technical reports, what would it be? What knowledge are we at risk of losing about how those machines actually worked in practice, beyond the circuit diagrams?
Ms Marić, what a thoughtful question – and how gratifying to know that people like yourself are working to preserve this knowledge. You’re quite right that enormous amounts of tacit understanding have been lost, and I’m acutely aware that I’m one of the last people who actually built these machines with my own hands.
If I could document one thing – one crucial bit of craft knowledge that never made it into the technical literature – it would be this: how to listen to a machine and know when it’s working properly.
That sounds rather mystical, doesn’t it? But it was absolutely essential. The ARC, SEC, and APE(X)C all made distinctive sounds when running. The relays clicking in precise rhythms on the ARC. The drum motor’s steady hum with the faint tick-tick-tick of the read/write heads on SEC. The pattern of valve heating and cooling, the slight variations in transformer hum as different circuits activated.
After working with a machine for months, you’d develop an intuitive sense of its sonic signature. You’d be writing at your desk, the machine running in the background, and suddenly you’d know something was wrong. The rhythm was off. A relay was firing sluggishly. The drum rotation had a slight wobble. You couldn’t necessarily articulate what was wrong, but you knew.
I remember one afternoon – must have been 1950 or thereabouts – working on SEC. Andrew had gone to a meeting, and I was running crystallography calculations. The machine had been humming along for perhaps twenty minutes when I noticed the sound had changed. Very subtly – the drum was still rotating at correct speed; the computation was proceeding – but something in the harmonic content was different.
I stopped the programme immediately, powered down, and spent two hours checking connections. Finally found it: one of the read head mounting brackets had worked slightly loose. Not enough to cause immediate failure – the head was still reading data correctly – but the vibration had changed, and within another hour or two, the head would have drifted far enough to start producing read errors, possibly even scraping the drum surface.
If I’d ignored that sound change, we might have damaged the drum irreparably. Replacing the magnetic coating was a nightmare – you had to strip the old nickel plating, replate the entire cylinder, test for uniformity, rewrite all the timing tracks. Days of work. All prevented because I’d noticed the machine sounded slightly wrong.
This kind of knowledge is completely absent from technical documentation. The circuit diagrams show you how to wire the read head amplifier. They don’t tell you what healthy read head sounds like, or what incipient mechanical failure sounds like, or how to distinguish “normal settling noise as the machine warms up” from “something is genuinely wrong.”
The drum memory is actually a perfect example of tacit knowledge that’s probably lost now. The technical specifications would tell you: magnetic nickel-plated brass cylinder, two inches diameter, rotating at 3,000 RPM, read/write heads positioned 0.002 inches from surface, ten bits per square inch storage density.
What they don’t tell you: how to actually position those read heads. In principle it’s simple – use a micrometer, set the gap, done. In practice it was endlessly fiddly. Too far and the signal amplitude drops; too close and you get mechanical contact, wearing both head and drum. But the optimal distance varied with temperature, with humidity, with how recently you’d replated the drum, with the specific characteristics of the amplifier circuit.
You’d adjust the head position whilst the drum was running, watching the oscilloscope trace of the signal amplitude. But you couldn’t just maximise the signal – that would put the head too close. You had to find the distance where signal was strong, but you could see a tiny bit of amplitude variation as the drum wobbled slightly during rotation. That wobble meant there was clearance, that the head wasn’t dragging.
Then you’d run the machine for an hour, let everything warm up, and check again because thermal expansion changed all the dimensions. The drum expanded, the mounting brackets expanded, the head assemblies expanded – all at different rates. What was correct positioning at room temperature might be too close or too far after thermal equilibrium.
And you learned to feel the difference when adjusting. You’d turn the micrometer screw, and there was a particular resistance – not too stiff, not too loose – that meant the head was sliding smoothly in its mount without play. Too much resistance meant the mounting was binding, creating stress that would cause positioning to drift. Too little meant excessive play, and the head would vibrate during operation.
None of this is written down anywhere. You learned it by doing, usually by making mistakes first. I probably positioned those read heads wrong fifty times before I developed the knack for getting it right.
Another bit of lost knowledge: component selection and matching. The technical specifications say “use 6J6 double triode valves in the amplifier stages.” What they don’t say is that 6J6 valves from different manufacturers, or different production batches, had quite different characteristics. Nominally identical valves could vary by twenty percent in gain, in noise, in drift with temperature.
For critical circuits, particularly the read amplifiers for the drum, you couldn’t just grab any 6J6 and install it. You’d test a batch – measure gain, measure noise, run them for an hour and measure drift – then match valves with similar characteristics into pairs for the differential stages. Otherwise, you’d get imbalanced circuits, increased noise, unreliable operation.
We had a wooden box, carefully partitioned, with tested valves sorted by characteristics. “High gain, low noise, stable” in one section. “Adequate gain, moderate noise” in another. “Borderline, use only for non-critical stages” in a third. “Failed or unreliable, discard” in the last.
That matching process – testing, measuring, sorting, tracking which valves went where so you could replace them with similar ones when they failed – that was craft knowledge. Essential craft knowledge. And completely absent from the published descriptions of our machines.
Here’s another one: soldering technique for relay contacts. Relays were crucial for the ARC – hundreds of them, switching sequences that controlled the calculation flow. Each relay had multiple contact sets that had to be wired into the logic circuits.
Standard soldering practice is clean the surfaces, apply flux, heat the joint, add solder, remove heat, let cool without disturbing. That works fine for most connections. But relay contacts carried relatively high currents and switched rapidly. If you used too much solder, you’d increase the thermal mass, and the contact would heat up during operation, affecting its switching speed. Too little solder, and you’d get high resistance, more heating, unreliable connection.
You wanted just enough solder to make solid mechanical and electrical connection without excess. That required developing a feel for how much solder to apply – usually just one turn of the solder wire, applied in a specific motion that distributed it properly. I could do it without thinking after a few hundred joints. Trying to explain it to a new technician was nearly impossible. “Not too much, not too little” is useless instruction. You had to watch someone experienced do it, then practice until you’d internalised the technique.
Temperature control for the soldering iron mattered too. Too hot and you’d damage the phenolic base material of the relay. Too cool and you’d create a cold joint – mechanically weak, high resistance, likely to fail. We had multiple irons at different temperatures for different tasks, and you learned which iron to use where.
I suppose what I’m saying is that building these machines was as much craft as engineering. The published papers gave you the theory – the logic design, the circuit topology, the timing calculations. But actually constructing a working machine required hands-on knowledge that could only be transmitted through demonstration, practice, and accumulated experience.
That knowledge is vanishing. The people who built these machines are dying, and we’re taking this tacit understanding with us. Your preservation work is valuable, but I worry that reconstructing from circuit diagrams alone might miss crucial details that seem obvious to someone with hands-on experience but aren’t documented anywhere.
If I had my time again, I’d have kept detailed laboratory notebooks – not just “installed read head on drum mount” but “positioned head using micrometer, initial setting 0.0023 inches, adjusted while watching oscilloscope trace, final setting 0.0019 inches after fifteen minutes warmup, signal amplitude 2.3 volts peak-to-peak, slight wobble visible indicating adequate clearance.” The kind of minutiae that seemed unimportant at the time but would be invaluable now for understanding how these machines actually worked in practice.
I hope your preservation efforts succeed, Ms Marić. These machines were remarkable achievements, but they were also temperamental, finicky, demanding creatures that required constant attention and adjustment. Capturing that reality – not just the idealised circuit diagrams but the messy, hands-on practice of keeping them running – that’s important work. Thank you for doing it.
Reflection
Kathleen Hylda Valerie Booth passed away on 29th September 2022, at her home in British Columbia, at the age of 100. She had lived long enough to witness a digital revolution she had helped initiate, to see her name finally appear in computing history texts, and to receive the recognition that had eluded her for decades. Yet even in her final years, she remained characteristically modest about her contributions, more inclined to discuss the technical problems she’d solved than to dwell on the historical injustice of being written out of the record.
This conversation, conducted just months before her passing, reveals a Kathleen Booth quite different from the sparse biographical entries that had circulated for so long. The woman who emerges here is intellectually restless, technically precise, philosophical about both the power and peril of the tools she invented, and candidly reflective about the mechanisms of erasure that had obscured her work. She was neither victim nor martyr – she was a scientist and engineer who simply wanted to solve interesting problems – but she was acutely aware of the institutional and social forces that had conspired to render her invisible.
Several themes resonate throughout her words. Perseverance appears not as heroic determination against overwhelming odds, but as pragmatic problem-solving. When the two-pass assembler proved more efficient than her initial single-pass vision, she accepted the constraint and built something elegant within it. When Birkbeck denied her husband the recognition he deserved, the couple relocated rather than fight a losing battle. When neural networks confounded her attempts to explain their operations, she didn’t abandon them but instead deepened her philosophical scrutiny of what they could and couldn’t reliably do.
Ingenuity is found not in flashy breakthroughs but in patient, methodical work. Hours positioning read heads to thousandths of an inch. Testing batches of valve tubes to find matched pairs for amplifier circuits. Developing transformation rules for grammatical patterns until the rule set threatened to become impossibly complex. She was an engineer in the truest sense: working with real constraints, real materials, real limitations, and finding creative solutions within those boundaries.
Perhaps most striking is her sustained engagement with the overlooked nature of women’s contributions. She doesn’t present herself as an exception or aberration. Rather, she identifies the systematic patterns – the shift from programming as women’s clerical work to computing as prestigious male domain, the tendency to attribute joint achievements to the more prominent male partner, the way foundational infrastructure work becomes invisible precisely because it functions so well. She understood this not as personal tragedy but as a structural problem in how the field constructed its history.
The historical record, examined through her testimony, reveals significant gaps and misattributions. The published accounts credit Andrew Booth with magnetic drum memory invention, yet Kathleen’s role in testing, refinement, and optimisation was substantial. The assembly language is sometimes credited jointly, sometimes to Andrew alone, rarely to Kathleen specifically, despite her own unambiguous statements about its development. Her machine translation work receives passing mention whilst the Georgetown-IBM demonstration is celebrated far more extensively, partly due to superior publicity and partly due to IBM’s resources and prominence.
Most importantly, Kathleen’s account challenges the historical narrative that treats early computing as a field of discrete, individually attributable discoveries. Her story insists on recognising the cumulative, interconnected, often collaborative nature of technical achievement – and on acknowledging that when collaboration involves both a man and a woman, and when the man holds institutional authority, credit flows overwhelmingly to him.
Yet she also acknowledges uncertainty and complexity. She questions whether her rule-based approach to machine translation was fundamentally limited or merely constrained by available resources. She wonders whether single-pass assemblers might have been feasible with different design choices. She expresses genuine doubt about the wisdom of deploying neural networks in consequential domains without understanding their mechanisms or testing for bias. She doesn’t claim omniscience; she claims hard-won experience and the humility that comes from having made mistakes, wrestled with difficult problems, and lived long enough to see her early work influence the field in ways both expected and surprising.
The connection to today is unmistakable across all her fields of contribution. Assembly language remains fundamental – every compiled programme descends from her invention, every embedded system relies on assemblers derived from her principles. Computer architecture education still teaches the concepts she helped establish. Machine translation, dormant for decades, has exploded into a thriving field of deep learning and neural machine translation that would astonish her but also, perhaps, vindicate some of her early intuitions about statistical pattern recognition. Neural networks have become central to artificial intelligence, yet the ethical concerns she raised about explainability and bias remain largely unresolved. The craft knowledge she possessed about hardware implementation – matching components, tuning circuits, listening to machines – has become increasingly irrelevant as computing moved toward abstraction and away from hands-on engineering, yet some of her warnings about the dangers of not understanding what we’ve built ring truer than ever.
Her legacy was recovered through the dedicated work of historians, archivists, and scholars who recognized the gap in the historical record. Researchers like those at the University of St Andrews, the Computer History Museum, and various computing societies undertook the work of reconstruction, interviewing Kathleen late in life, examining archived papers, connecting the dots between published work and uncredited contributions. The Andrew and Kathleen Booth Memorial Lecture, established by Birkbeck College, now carries both names equally – a relatively small symbolic gesture that took until after her death to materialise. Young scholars have begun citing her work not as footnotes but as foundational contributions worthy of serious engagement.
What her life suggests to young women pursuing paths in science today is not that persistence alone will secure recognition – it often won’t, and that’s a systemic problem worth acknowledging – but that the work itself can sustain you. Kathleen built things that mattered. She solved problems that needed solving. She contributed ideas that shaped an entire field. The historical erasure was real and painful, but it didn’t retroactively diminish the intellectual and technical rigor of what she accomplished.
She would likely counsel: document your work carefully under your own name. Don’t assume institutional structures will protect or credit you – they won’t, automatically. Build networks of colleagues who see and value your contributions. If you find yourself chronically overlooked, ask whether the environment itself is the problem, and don’t hesitate to move if continuing there means your work will remain invisible. Pursue problems that fascinate you rather than problems that promise recognition, because fascination sustains you through the hard parts, and recognition is capricious anyway.
Most importantly, perhaps: recognise that infrastructure, foundations, enabling technologies – all the “unsexy” work that makes flashy applications possible – that work matters profoundly, even when nobody notices it. Someone had to invent assembly language. Someone had to figure out how to store both programmes and data in the same machine. Someone had to demonstrate that machines could process language, even crudely. That someone was often a woman, working quietly, with minimal resources, without expectation of historical remembrance.
Kathleen Booth lived a century. She built machines, wrote code, pioneered fields, taught generations, and quietly reshaped what was possible. She spent her final decades on Vancouver Island, hiking and gardening, largely removed from the computing world that had often overlooked her. Yet even in her quiet retirement, her innovations were active in millions of devices, her principles taught in universities worldwide, her vision of how humans and machines might communicate shaping the digital landscape.
That’s not a small thing. And it matters now – perhaps more than ever – that we know her name, understand her contributions, and recognise that the foundations of computing were built not just by the celebrated male pioneers but by women like Kathleen, whose work was so effective, so foundational, that it became invisible.
The next woman engineering the bridge between human intention and machine execution, writing code that will outlive its author’s recognition, inventing the infrastructure that enables others’ more celebrated work – she’s working now. And she needs to know that Kathleen Booth came before her, that women belong in computing’s deepest technical layers, and that the invisibility of foundational work says nothing about its importance.
That knowledge, itself a kind of inheritance, might be the most enduring legacy of all.
Editorial Note
This interview is a dramatised reconstruction, imagined as a conversation that might have occurred on 20th November 2025, had circumstances permitted. Kathleen Hylda Valerie Booth passed away on 29th September 2022, and this conversation exists only as a creative exercise grounded in historical fact.
The content draws extensively from documented sources: published biographical accounts, archived papers, technical publications authored by Booth and her colleagues, recorded interviews conducted late in her life, institutional histories, and scholarly analyses of her contributions to computing. Her technical achievements – the invention of assembly language, the design of ARC, SEC, and APE(X)C, the 1955 machine translation demonstration, her neural networks research – are factual and well-established.
However, the specific dialogue, personal reflections, and conversational tone are imaginative reconstructions. We have attempted to ground them in what is known of her voice, her intellectual perspective, her demonstrated values, and the documented record of her work. Where historical ambiguity exists – regarding her exact role in particular projects, the precise sequence of technical decisions, or her personal reactions to events – we have sought to remain plausible rather than definitive, preferring her own written and spoken words where available.
The five supplementary questions are fictional, attributed to imagined contemporary readers from various geographical and professional backgrounds. The responses to these questions, whilst consistent with her known perspectives and the technical details of her work, are creative interpretations rather than statements she actually made.
This approach honours both historical integrity and narrative engagement. Kathleen Booth’s actual documented words and achievements are remarkable enough; this dramatisation aims to render them more vivid and accessible rather than to embellish or misrepresent. Where we have invented dialogue or reflection, we have done so in service of illuminating her actual contributions and the documented historical forces that rendered them invisible.
Readers interested in precise, scholarly accounts of her life and work are directed to the biographical resources maintained by the University of St Andrews, Birkbeck College, and the Computer History Museum, where primary sources and peer-reviewed scholarship provide authoritative documentation.
This interview exists in a different register: as a considered exploration of what her life and work mean, filtered through her own known perspectives and values, and presented in a form that may reach readers who might not encounter her story through more formal historical channels.
She deserves to be remembered accurately. She also deserves to be remembered widely. We hope this dramatisation serves both purposes.
Who have we missed?
This series is all about recovering the voices history left behind – and I’d love your help finding the next one. If there’s a woman in STEM you think deserves to be interviewed in this way – whether a forgotten inventor, unsung technician, or overlooked researcher – please share her story.
Email me at voxmeditantis@gmail.com or leave a comment below with your suggestion – even just a name is a great start. Let’s keep uncovering the women who shaped science and innovation, one conversation at a time.
Bob Lynn | © 2025 Vox Meditantis. All rights reserved.
Vox Meditantis 
Leave a comment