Advent of Computing - Episode 189 - The IBM 701

Episode Date: September 27, 2026

At the end of the 1940s IBM stood at a crossroads. The punch card company had yet to enter the electronic computer market. Forces within and without were pushing them in that direction, but many man in blue suits would resist the coming change. Out of this climate emerged the Type 701, IBM's first commercial machine. How did it beat the odds and make it to market? And what even did folk do with these early machines? Like Advent of Computing? Then check out the after show! Adjunct of Computing is now LIVE: YouTube Spotify Apple Podcasts Join the conversation on the OFFICIAL discord server: https://discord.com/invite/GpFNu3DTU2

In time, we may get to a point in the perfect machine age when we shall be able and compelled to wave aside the old three R's, and everything else we have been supposing all these stupid centuries we had to learn at our mother's knee or the school blackboard. Maybe the world is on the way towards educating itself away from the need of education. Even the sideshow of the old days will be impossible, become uninteresting. One of the items in those old shows was the human lightning calculator. Occasionally, they appeared today, not in commercial sideshows, but in academic halls. Youthful prodigies who dash off feats comparable with that magic IBM 701 calculator.

Worcester Telegram, April 4, 1953 Computers are one of those inventions that have very deeply impacted the human condition. They're perhaps one of the more impactful inventions of the last couple centuries. They're up there with vaccinations and maybe some forms of agriculture, although I don't know if I'd rate computers quite as high as the development of domestic grains, but that would be a very difficult conversation to have. Folk knew at the time that computers represented a sea change. There was, however, a lag.

Early responses in the 40s are wild. Gigantic synthetic brains are about to unlock the secrets of the universe. Hidden machines are preparing an assault on all human knowledge. By the 1950s, things temper but in an interesting way. In reality, it's not the inventive. of the computer that represents the true C change. It was the spread of mass-produced computers. That led to a much wider cultural change.

That's really what's important. One of the leading vectors of this new digital culture was, of course, the IBM 701 calculator. Welcome back to advent of computing. I'm your host, Sean Hass, and this is episode 189, the IBM 701. Now, before we get started, a couple plugs at the top. One, we have an official after show, Adjunct of Computing. If you like Adjunct of Computing, you'll probably enjoy Adjunct. We've also started doing our recordings live on the official Discord server every other Friday night.

I'll have links to Discord and links to adjunct in the description. So if you want to join the conversation after hours, go check it out. Also, this is something that I should have moved to the front of the show, a lot longer ago, but Advent of Computing does have a Patreon. In fact, the show is sponsored by listener donations. So, if you're already signed up, thank you. If not, and you want to start supporting the show directly, you can go over to advent ofcomputing.com and click the support the show link. That money helps me get access to documents for the show, and it also helps me save up and plan larger projects and bigger gear upgrades. So it really does improve advent of computing.

Now, with all that said, let's get on to the podcast itself. Today, we're going back to Big Blue. We're going to be looking at the IBM 701, also known as the defense calculator. It was IBM's first commercial computer. So in many ways, this is when IBM turned into the IBM that would dominate the digital world for decades. From a distance, this can look like a very simple story. IBM was making punch card tabulators and had made a few one-off computers. Notably, they did the manufacturing for the Harvard Mark I. After a fashion, they decide to sell these computers, you know, make a little money.

The pivot, it seems, would be natural. Just start making machines, sell them in bulk. and live in Monopoly ever after, or at least until the 1980s. I think that also fits into the whole misconception about an instant digital revolution, that computers appear in 1945, everyone instantly loves them. They see that the future is digital, and they make the switch. Long-time listeners know that I don't subscribe to that belief, and that's not just my opinion anymore.

The sourcing backs up a slow digital revolution. We can see this in the numbers. Over the course of years, maybe even decades, really, computers as we know them grab hold of the future. This process happens both in the large and small scale. It happens in the overall industry, just as it happens inside IBM. One crucial step in this revolution is the mass production of computers. The shift from one-off machines to production runs of identical machines. The 701 is the first time IBM makes that shift.

Crucially, it was a struggle. There was a fight. It was seen by some as the wrong direction for the company to go. Not everyone saw a digital future. If the path was unclear, even inside Big Blue, well, that's certainly interesting. It points to the computer revolution being much more complicated than a brushfire. So today, let's look at how IBM made the move to computing. Along the way, we'll see how the 701 was designed, engineered, and manufactured.

I want to pay careful attention to how this shift occurred, or rather, to how big of a shift this was. Did IBM simply touch up their punch card machines to accept programs? Or was this a more fundamental change? This is one of those stories where you've got to be careful, where you choose to begin. It's the, at least I think of it as the classic, where you start at the beginning of the universe type of problem. You could say it goes all the way back to 1890 and Herman Hollerith's creation of the punch card tabulator. Or you could say it goes back to the automatic sequence control calculator, aka the Harvard Mark one. I'm not going to do that. I think it's best to

just say that by 1945, IBM had flirted with the idea of computers. But as always in this period, the line between complicated calculator and simple computer is blurry. Tabulators like the 604 and 603 were almost computers. These were mass-produced machines that crunched on punch cards. The later CPC, the card-programmed electric calculator, was even closer to a computer That device had memory and could be programmed, but only in a limited capacity. There were two changes that were needed. The first was honest-to-goodness stored program computers. IBM was getting close, but they weren't exactly there.

You can argue that the CPC is a computer, but you can't argue that it's a stored-program computer. The second change needed was manufacturing. IBM mass-produced unit record equipment, all the machines that ate and made punch cards. With the 604, they were manufacturing electronic sequence-controlled calculators. But the only computers that IBM had ever made were one-offs. Even then, those machines weren't stored programmed computers. So how did IBM adopt the digital?

How did they take their final two steps towards a quote-unquote modern machine? Well, that's a long story. My main source for today is IBM's early machines from MIT Press. It's a, it's a tome of a book. The thing has four authors, an entire section just for references and footnotes, and tells you everything you'd ever want to know about IBM. It's a dense day by day of the development. of IBM's early machines. It's also a pain to sort through, but that tome, plus other references,

lets us construct a very clear picture. I'm going to start our tale in the late 1940s. That's when IBM made the first step. In that year, a group of researchers inside Big Blue became keenly interested in computing. In that cadre was one Nathaniel Rochester. He was, believe it or not, a radar guy. Previously, he had worked as a researcher at MIT's Radiation Lab, which was more concerned with radar than nuclear radiation. After MIT, he works at Sylvania. That's where he caught a glimpse of the future. Sylvania had a contract to construct the arithmetic logic unit for Whirlwind 1 of an early vacuum tube computer. That's basically the calculator that the computer controls, the circuits that handle logic and math.

Rochester designed and built those circuits. He came away from the project believing that computers were the future. He becomes one of the core of believers that's important to the slow digital revolution. He also believed that Sylvania wasn't the best place to be part of that future. The contract sounded a little more incidental, or at least Rochester viewed it that way. He wanted to be in the middle of things. So he went out and got hired by IBM. His logic was that IBM must be the heart of the new digital age.

Rochester was in for a disappointment. The IBM he entered wasn't the IBM that we all know and love. It was a punch card company. Punch cards were what was profitable. It's what built and sustained the business. IBM sold cards and machines to eat them. Crucially, those machines were electromechanical. They had motors and clutches and levers.

They had oil pumps and gears. Most electronic device in that machine, well, that was some relays. There was a firm resistance to change in the late 40s. Punch cards were what made IBM, and punch cards were mechanical. That said, there was a glimpse of hope. The 603 was an electric calculator that hooked up to a card reader and punch, basically another tabulator. The bigger deal, though, was how the 603 did math. It was electronic instead of mechanical.

It used vacuum tubes. That was already a huge step for IBM. Even the Harvard Mark 1 had been electromechanical. The 603 was IBM's first dive into large scale. scale use of vacuum tubes, and apparently it caused a split in the family. At the time, Watson Sr. was head of IBM. Watson Jr. oversaw the 603 project. The older Watson didn't think it was such a good idea to go messing around with these new electrical things, but the project survived and almost thrived. IBM made a small run of 603s. The design was improved,

into the 604, so there was a small corner of IBM that was experimenting with tubes. The rest of the company, however, was still mechanical. That is, until tape. In 1983, MIT put together an oral history panel with four IBMers who were involved in the development of the 701. Among them was Rochester. He claims that tape drives scared the pants off of Big Blue, including the conservative faction in the company. That would make an opening. The whole point of a tape drive

is it can access data faster than punch cards. To make use of that speed, you need a faster device than a tabulator. You need something that can click faster than a relay. You need a computer. At least, that was the argument that Rochester made to IBM management. That strikes me as wild. The idea that tape scared IBM's suits off, but they still needed convincing about the computer thing. I've done a lot of reading on the subject, and I can assure you that magnetic tape went hand-in-hand with computers. Digital magnetic tape was never a separate technology from computing. The two developed side-by-side. From other sources I can track down, it sounds like it was less a fear of competition and more a fear of expansion.

Punch cards were reaching their limit. One of IBM's biggest clients was the Social Security Administration. They were using so many cards that they had to have massive card storage facilities. Cards are not very dense storage media. They're literally 1890s technology. And they're also not very fast. This is, classically, the information problem. Users have way too much data to manage reasons.

on cards. It takes so much time to track down cards, so much time to read them, and so much space to store them, that operations become unsustainable. TAP emerges in the late 40s as an alternative, or at least as another option for digital storage. In theory, it could be more dense, more fast, more better. Getting there is a challenge, but one that would open up new opportunities. In 1949, Rochester starts designs for a computer called the test assembly. This was to be an experimental frame to test the viability of two things, electrostatic memory and tape drives. The heart of the computer was a modified IBM-type 604 electronic tabulator. When you really get down to it, the 604 is basically an ALU, an arithmetic logic

unit that's just missing the rest of a computer. It was first designed to be used with punch cards, but that hamstrung the device. It could crunch numbers faster than a mechanical reader could eat cards. Little is recorded publicly about the test assembly. It was devilishly simple, basically just a proof that IBM could build a computer, and these new computers would function at all, and they could use tape. It worked enough that Rochester and his colleagues, were able to move on to something more ambitious, the tape processing machine. This would be a computer built from scratch. It dropped the 604 in favor of its own math circuits, and it was much more tape-oriented. It would be a test bed for new ideas.

It would also test if IBM could make an accounting machine did a tape instead of cards, if they could take a step in the right direction to replace punch cards with a better medium. This test machine, the TPM, is wild. It's a bit of a black hole of information that are internal reports that are probably stashed in a filing cabinet in New York somewhere. In this period, IBM didn't really publish much publicly. I have two sources of data to work with here. IBM's early machine has a description of the TPM in its appendix, which is drawn from internal memos, but that's based off design notes. What I like a little more is actually a period source.

I know, shocking. Me liking contemporary sources. The NSA published a report on this new machine. The specific document is called a trip report. Look, what can I say? I'm a simple man. I love a good NSA-funded trip report. We have this document because, in 15,

IBM offered to sell a TPM to the NSA. So the NSA sent some spooks over to check out the machine. So we get a report describing what they saw and what they thought. We already know the two most important parts of the TPM, some early tape drives and some early IBM math and logic circuits. The tape drives were very, very early indeed. IBM releases their first commercial drives in 53, so what the NSA saw were rough vacuum column drives. The TPM also had memory. In fact, it had two forms of memory. Its main space was composed of

electrostatic tubes. That was totally new technology and totally new to IBM as well. These are the early CRT-based random access memories. They were unreliable. They were unreliable, and actually very difficult to manufacture, but they were a popular option for a few years in the really early days. This is kind of one of those decisions that's super specific to this period. This was backed up by a magnetic drum. That would serve as something like a scratch pad, more long-term than electrostatic memory, less long-term than tape.

The system was rounded out by a card reader and a card punch, and, well, a power supply. Gotta have one of those. Even at this stage, these were separate components. That was practiced with unit record equipment. IBM would sell you a system composed of standardized parts. Each part could do something independently, but they were only really useful together. That allowed IBM to mix and match components to better serve clients. This also made it easier to install the system.

At least, so goes the theory. This was a fully stored program machine. You loaded code into its flaky CRT, memory and let it rip. The TPM had a very simple instruction set. You could do all the usual math and compare and jumps backed up by orders to read and write to tap and drum. So what did the NSA think? Well, they didn't like it, to quote, the TPM is not small in size, will not be soon available, and is not easy to program, and in general is not suited to agency use. The trip report continues. It is considered that, from the point of view of the IBM Corporation, we would be rendering IBM

a disservice to indicate too great an interest in TPM. Requests for IBM to expedite production at this time, before agency opinion on the machine has time to be made firm, would place an obligation on the agency to follow through with some measure of support. Should the unfavorable recommendation expressed above become agency policy, we might have caused IBM to make un-economical deviations in their own production schedule to respond to such an unwarranted enthusiasm. In quote. I love this so much. Harsh, but not unwarranted. Then S.A. One, doesn't like the machine. Two, doesn't want IBM to spend money on it. Three,

doesn't want to encourage IBM to spend money on it. It's a funny report, but also very realistic. The NSA had specific requirements. They wanted cryptographic machines, beasts that would eat tape and spit out deciphered text. And they already had that. ERA had built the Atlas One for the NSA specifically. That machine, after some corporate drones, would become the Univac 1101.

There are really two things there. The first is that the Atlas 1 was a reliable enough computer that in a couple of years, it was good enough to be mass produced. The second is that the Atlas 1 was actually practical for text processing. It was a very reasonable machine. So by 1951, IBM was straight up behind the curve. They didn't have a mass-producible computer, and they didn't have a very flexible computer. The architecture of the TPM was also, well, how do I put this? It was foo-barred.

It wasn't very reasonable. For instance, take memory. The TPM was, in part, designed to be an accounting machine. So it had some text-oriented features. Its word size was seven bits, just enough to represent a single character. Each instruction required six words of storage. That's not six bits. Why is that bad? Well, to explain, let me talk about another bad choice that led to the TPM's staggeringly unreasonable design. The TPM was a serial machine. It operated one pulse at a time.

Now, I'd say we can't fault IBM, but I'm going to fault them. a little bit. The 604, the closest thing IBM had to an electronic computer, operated in parallel. When the 604 crunched numbers, it did it eight bits at a time. That means adding two eight-bit numbers on the 604 was one pulse, just boom, done. But on the TPM, numbers moved and were crunched one bit at a time. To add two eight-bit numbers required eight pulses. Bop-bop-bop-bop. pop, pop, pop, pop, pop. Everything moved over one wire instead of multiple wires. That is a very fundamental structural design that limited the TPM's speed.

IBM's early machines points out exactly how funny this is. It meant that the TPM actually acts like it as serial memory, as if it used a delay line, a even older form of computer memory. Loading an instruction took multiple cycles. If you had to access six words of RAM to get your next instruction, and each of those words had to percolate down a wire, that's going to take some time. The electrostatic tubes used in the TPM were advanced.

They were totally new technology, just one or two years old. IBMers had to work backwards from scientific papers and engineering samples to manufacture their own storage tubes. That took a lot of effort. The result was really the first type of true random access memory devices. Very fast memory devices. TPM circuits reduced them to serial. So, yeah, the machine ends up being slow due purely to these structural mistakes, really.

Why would IBM reach for serial when they had experience with parallel? Honestly, it may have been as simple as convention. Most computers in this very early period operated in serial. It was much easier to design serial machines, especially in laboratory settings, when you're making one-off computers. You only had to make a one-bit adding circuit instead of eight of those circuits chained together. If the objective was to make one computer, then cereal was fast. At least, fast for development.

You just took a hit during execution time. Let's just note the new hardware here. The TPM used electrostatic memory which IBM had to learn to make. That's new. It used taped drives, which IBM kind of had to invent. At least, their drives were very different from other drives, so that's, again, totally new. The computing circuits were built from scratch.

Of course, that's new. The only reused components are actually the punch card I.O. devices. That's it. The TPM is almost completely new hardware. But tragically, IBM was rebuffed. So that's it. That's the end of the story. IBM makes a new computer. There's steep resistance to the project internally, but it's greenlit. A prototype is cobbled together. A second machine is built and shown to customers. It's rejected. The NSA doesn't encourage IBM to continue this line of inquiry. IBM stays a punch card company and they never made another computer again. End of story.

By the end of 1952, IBM delivered their first stored program computer. Something wild happened between the rejection of the TPM and the release of this new machine. The heart of this shift comes down more to politics, both large and small, than technology. Competing forces would meet inside Big Blue. Watson Sr., then, president of IBM, was motivated by larger political forces. In 1950, the U.S. entered into the Korean War. He offered the Department of Defense anything they wanted. That same tactic worked out well during World War II. This would serve to further ties between IBM and the U.S. military, at least some parts of the military that wanted fast electronic computers.

At the same time, Watson Jr., then executive vice president of IBM, was trying to push the company towards more electronic and more digital devices. He had been a major backer of the test assembly and tape processing machine projects. Watson Jr. was looking for excuses to push that electronic agenda. And it really was the electronic part that mattered here, more than the digital. Electronicness was what was new for IBM. Lowering the organization, the TA and TPM projects were continuing.

The CPC project was also well underway, a somewhat programmable machine built around the 604. So we have all of these factions that are on a near-collision course towards an honest-to-goodness computer. It feels like they were just waiting for a nudge to make things fall into place. The U.S. Naval Ordnance Lab would press the issue. A certain IBM employee won Byron Havens through a rough draft of a computer design at them. Havens had in mind a fully electronic version of the SSEC, a recently completed near computer that used older relay circuits. The proposed machine would be fast, reliable, and fully electronic. The NOL bit.

They would actually like a modern electronic computer, believe it or not. That meant that IBM had one customer. The NOL wanted IBM to make them a custom one-off computer using the latest techniques and technology. That would be used in the Korean War effort. That is very much in line with what IBM had done in the past and what Watson Sr. wanted to do in the present. They could churn it out of the lab, make a little money, and get some more experience with these new computer things. It would be exactly like the Harvard Mark I all over again, helping the war effort and everything. But 1950 was a very different world than 1945.

By this time, it was public knowledge that UNIVAC was on the way. It was much delayed, but EMCC had been committed to producing at least six machines. That's six copies of a computer instead of a unique machine. a computer made on a production line instead of in a laboratory. It's true that Univac would take a long time to actually get delivered, but it was well known that the machine was in development. As this proposal for the NOL computer was passed around IBM, a wild recommendation was made.

Why don't we make more than one? Why doesn't IBM make a pile of these new computers? Let's turn the order for a unique computer into the start of a product. It was estimated that IBM could sell at least six machines. At least, that's what one engineer who had recently surveyed customers believed. Some factions in IBM viewed this as a very risky and dangerous proposal. It was a totally new path to the company. Some even feared that it would kill IBM itself.

Big Blue was a punch card company, after all. that served them well for decades. The shift to computers would be dangerous at best. Part of that fear came down to the mechanical versus electrical divide. Mass production meant that the machine would have to be made on IBM's factory floor. That was, by and large, a machine shop. IBM employed mechanics, not electrical engineers. There was a small corner cut out for the newfangled 604, but that was on the edge of thing. mass-producing a computer would mean a radical shift in manufacturing techniques and also manufacturing personnel.

Ultimately, the dissenting voices were drowned out because Watson Jr. really liked the idea of a new computer product. It aligned with his ultimate goal to electrify IBM. That kind of alignment is important. It's how an opportunity becomes easy to take. Thus, the project shifted. It was now a product, not a one-off contract. Internally, it was called the defense calculator, since, you know, the DoD was roughly where it would end up,

but it's better known as the IBM Type 701, or just the 701. From the start, there were some pretty tough project requirements. We get the usual things about speed and capacity. It had to be a fast computer, and there were numeric bounds on how fast it needed to multiply, for instance. There was also a time constraint. This was still partly a project for the Naval Ordinance Lab. They wanted the computer for use in the Korean War. No one knew how long that conflict would last, so it was crucial to get the machine finished quickly. Initial plans called for a crash project. I've seen records

suggesting that the defense calculator started with a timeline of just over a year, which is wild. Of course, that may not have been the most realistic expectation, and I have numbers to back this up. Planning for this project started in summer of 1951. The first generation of stored program computers were just coming online. That contrared machines had taken, on average, five years to develop. Machines that were operational in 1950 or 51 had began as projects in 1946 or 47. A one-year turnaround would mean intense velocity. That's not to mention the whole manufacturing aspect.

So, just to round it up, so we're all on the same page. Watson Jr. signed off on a crash project to force IBM to make a totally new machine and then mass-produce it. IBM had never made an acceptable stored program computer. IBM had never mass-produced an electronic computer. They had a year. Turmoil, perhaps, was the order of the day. One of the more interesting issues came down to manufacturing.

Previous machines, up to and including the TPM, had been made inside IBM's research labs. In fact, almost every computer up to that point had been made in a research lab. Univac may be the only exception here, but as of 1951, no units had been delivered. So made is a bit of a stretch for Univac. The eventual arrangement was to manufacture the 701 in two phases. The first handful of machines would be built like bespoke contract machines of old. Technicians and researchers in IBM's labs would put these early 701s together. During that process, a manufacturing manual would be written.

Later 701s would be made on the factory floor following, that manual, and supervised by the same researchers that built the first handful of 701s. That would give IBM the best of both worlds. Early units would be products and be deliverable, but they would also serve as a way to shake down the manufacturing process. Then the factory could ramp up production more smoothly, learning from lessons in the lab and supervised by the folk that learned those lessons. But let's back up before we get two-factor. into the manufacturing process. I know, I know. That's the riveting stuff, but we can come back to that if we need. How was the 701 designed and what was the machine like? Rochester was nominally in

charge of the machine's architecture, but this was a massive team effort. The overall design for the 701 was, to quote, the team via IBM's early computers, quote, like IAS, but with good input output, end quote. So, I guess that answer. One question. The IBM 701 was based off the IAS machine, but what exactly does that mean in this context? As I said, 1945 and 1950 were very different years. The earliest machines had taught us a lot. They'd given us new passes at design. One of those new passes was John von Neumann's IAS machine. That computer has been called a refinement of EDVAC, an earlier design that von Neumann was involved with. I don't know if I go quite that far. IAS is more like the next step in computing.

It was also a very influential step. The IAS machine used Williams tubes, a form of electrostatic memory to store its programs and data. That memory was organized into 40-bit words. Each word could contain two instructions. That layout is pretty specific to the IAS machine, so it forms a nice signature when looking for influence. This was also a parallel computer. Like the 604, the IAS machine added and crunched numbers one word at a time instead of one bit at a time. That made it faster than many contemporary computers. Better still, the IAS machine was a very well-documented architecture.

You could grab a few papers and understand the whole machine, or, better still, you could go to the Institute of Advanced Study and Johnny von Neumann would show you around. Many folk, including a few IBMers, would do that. There were a number of machines in the 50s that were heavily based off or inspired by the IAS machine. But inspiration can be a tenuous thing. Whenever I see a machine that's just marked as an IAS derivative, I always ask the question, how derivative? Are we looking at a clone, or are we looking at something that is a parallel computer that happens to have been made in a certain year? So what's the case for IBM?

Well, this mix of accessibility and performance made Rochester and his colleagues reach for the design as a starting point. that would give IBM a jump on the 701. But it wasn't as easy as just making a version of the IAS machine and painting it blue. For instance, the 701 uses a different word size. It's Williams tubes, the same memory device used in the IAS machine, store 36-bit numbers. Not a super impactful difference, but it is a difference. memory is really the heart of these old machines. So just by dint of having a different word size,

that means the circuits inside the 701 have to be pretty different than the circuits inside the IAS machine. The larger change, however, isn't how the 701 handles input and output. For one, it has magnetic tape. The storage complement of the 701 lines up with what the TPM was testing out. It has punch cards, mag tape, mag drum, and finally electrostatic tubes. Why all the options?

Part of it is transition. IBM customers were using punch cards. That's where their data lived. The 701 was designed to work with existing unit record equipment. That way, a user could hook in their punch card reader and slurp data up to something like tape drives. tape would serve as the new preferred form of long-term and slow storage. It was faster than punch cards, but still had limited speed due to its mechanical nature. IBM wanted folk to transfer their old paper data to faster acetate.

That was the idea, at least. Werner Butchholz describes the 701 in a paper from the IRA titled System Design of the IBM Type 701. In it, he explains that magnetic drum filled a gap between tape and electrostatic memory. I think that's true in a number of ways, right? As far as speed, drum sits in the middle. It's also an odd blend of features. Drum isn't entirely random access, but it's also not entirely sequential access. At least, drum is controlled in such a way that you can specify addresses. They just take a little while

to roll around. This loadout meant that the 701 was able to work with pretty large amounts of data. You could fill up its CRT memory, then use drum to store scratch data and tables, then use tape for input and output. This was all held together with just a few machine instructions. Tape and drum were both fully under software control. This very control is part of a larger trick of the 701's design, and this is where we are fully departed from the IAS machine. Remember, the 701 is designed to be easy and quick to build and manufacture. This is from Butchholes.

Quote, through the design of the system, the philosophy has been to keep the equipment to a minimum, to make that equipment fit a simple logical pattern, and to avoid special purpose devices. An effort has been made to keep the instructions as simple as possible and to avoid obscure restrictions and overlapping between the functions of different instructions. he continues. There existed a strict regime of discarding any frill, which would not be of benefit in more than one type of application. End quote.

So it's a no frills machine. If something can be done in software, it's not done in hardware. That saves IBM some work. This becomes very evident in how the 701 actually handles I.O. Data on tape or drummer, even the printer, is organized into so-called files. These are collections of unit records. Bit of antiquated language.

A unit record is a punch card. It's the smallest chunk of data you got. A file, then, is the equivalent of a stack of punch cards. It's a way to group data together. Descriptions of the 701 explain that you read and write whole files at a time. You point to a location in memory, and then you start reading from, say, tape, until a whole file has been loaded into your Williams tubes. This is even backed up by a special end-of-file mark

that tells you when you're done reading the file, right? But there's no hardware support for that workflow. If you want to read a whole file from tape, you write a loop that reads from tape one word at a time. The I.O. circuits have some optimization that makes that kind of loop work a little bit better. Basically, it keeps the tape warmed up while you're copying data over. Besides that, the hardware is completely general purpose.

You just write a loop in software. It runs until it sees an end of file mark. You write the code that checks for that mark. That saves a lot of hardware development. It saves a lot of solder. The 701's parallelism is another one of these tricks that saves hardware. Now, bear with me. this is a little counterintuitive.

In early lab-built machines, serial processing was easier to build. It's slow, sure, but you only need to make one-bit math circuits and then run through them a bunch of times. In mass production, you can tap into economies of scale. Sure, it's going to be more expensive to make 36 adding circuits. But manufacturing is tuned such that making a pile of simple devices is actually easier than just making a few of that device. If you've ever tried ordering PCBs, then you've seen this effect.

Often ordering 10 custom circuit boards is cheaper than ordering just one. We get this blend of cutting-edge design and tricks that made it possible to make more than one IBM 701. And then we get to, well, then we get to some unfortunate parts of the machine. There are many ways to build a computer. You can use relays or vacuum tubes. If you're cool, you can use mechanical logic gates. You can even use magnetic cores to construct logic gates.

Or you can use diodes. The 701 used what's called DTL, diode tube logic. The joke is that DTL usually means diode transistor logic, but transistors aren't quite here yet. Diodes were used to construct and and or logic gates, while vacuum tubes added the all-important not gate. That gave it the full complement needed to, well, to compute.

Diodes were, in theory, more reliable and more flexible in vacuum tubes. They at least didn't throw off massive amounts of heat. However, the early crystal diodes used in the 701 were a little flaky. It sounds like it was a manufacturing defect of some sort. Engineers described it as diode aging. After a while, certain diodes would come out of spec, acting unpredictably.

This proved a pernicious issue. It was ordained that a study would be undertaken to try to get to the bottom of things. From IBM's early machines, quote, In an attempt to accelerate the effects of aging as a part of the diode study, a number of environmental tests were devised. Diodes recycled in and out of high humidity chambers, boiled in water, and cycled through a household-type pressure cooker. I got to love the idea of an IBM engineer requisitioning a household-type pressure cooker.

Wonder what the product number for that was. Anyway, after days and days of cooking diodes, IBM's nerds didn't ever get to the root of the problem. They did, however, work up a good test regimen. Components in the 701 had to survive a battery of tests before they were enshrined in the machine proper. The crash program showed results in actual hardware. The first 701 was installed in December of 52,

although that was more of a publicity model. Type 701, serial number one, was installed in IBM's New York office on Madison Avenue. In 53, the first clients would get shiny new 701s. IBM churned out about one machine every month. Compared to punch card hardware, that was abysmally slow. But hey, this was brand new, after all. In total, 19 type 701s were manufactured and delivered.

The majority of those were actually made on factory floors. So, while not exactly mass production, I think it's safe to call it as serial production. 7-0-1s were more numerous than any machine out there. I think technically Univax end up outnumbering 701s, but that takes a number of years. The type 701 was only one part of the project. As with earlier unit record equipment, the computer was broken up into a pile of smaller units. The type 701 was just the CPU. Main memory was housed in a Type 706 cabinet.

The 726 and 727 provided external tape storage. The Type 732 held a magnetic drum. In total, there were 14 of these 7X units that made up a fully fleshed-out installation. Why break the machine down into so many parts? Well, I'm sure there were better reasons, but I'm going to give you my favorite rationale I've read. This made it so the computer could fit through doorways and into standard-sized elevators. The first customer to get their hands on a 701 was the Los Alamos Lab. From there, feds like the U.S. Navy, Weather Bureau, and NSA took deliveries, as did big industrial clients, like Boeing, North American Aviation, Con Bear, and General Electric.

Sales showed that there was a market for stored program computers. An electrical IBM was an eminent reality. This is also an interesting inflection point. The last 701 was delivered in 1954. That same year its successor, the 704 hit the scene. That machine would move over 100 units. The same year, the IBM 650 hit the streets, and would go on to sell over 1,000.

Prior to something like 1955, there's a pretty small number of computers in the world. You could inventory every computer ever built, where it was, and probably even who had used it. After this inflection point, that becomes almost impossible. You could almost say that computing started to spread like a virus. It reached a critical mass and breached containment. The 701 sits at the cusp of this point. Have you ever heard the factoid that Watson Jr. claimed there was maybe a market for five computers in the whole world? It's often trotted out and laughed at.

It's taken as a neat little story about how even IBM didn't realize how big computing was about to be, or perhaps a big executive out of touch with what was actually happening. that quote is about 701 sales and it's misquoted it's from a statement that Watson Jr. made during a 1953 stockholder meeting. The full quote given by IBM directly is, quote, IBM had developed a paper plan for such a machine and took this plan across the country to some 20 concerns that we thought could use such a machine. I would like to tell you that machine rents for between 12,000 and 18,000 a month, so it was not the type of thing that could be sold from place to place. But as a result of our trip, on which we expect to get orders of five machines,

we came home with orders of 18. In quote. Watson hoped to sell five machines. Initial orders were 18. 18 out of the, what, 20-some customers that Watson met asked for computers. The response was so positive that IBM actually had to cap the number of machines sold. Subsequently, there would be a lot more interest in the 701 than manufacturing capacity could handle. There was this whole market segment of folk that wanted computers but didn't want to build their all machines from scratch. IBM walked head first into that market. So what did these folks actually do with their 701s? Some of that is probably still classified.

Many 701 programs were going to be one-off bespoke things, but there is a class of programs that were developed on the 701 that bear special inspection. Compilers. That's right, we're talking programming languages. Now, jokes aside, the 701 actually gives us a really neat opportunity to look at some very, very early languages. In the middle of the 50s, at this very inflection point, something odd starts to happen around programming. In a truly automatic computing system, a 1956 paper by Mandalay Grims and E. Porter, there's this juicy detail,

quote, like many comparable groups, members of the computing facility at Boeing Airplane Company feel that it takes too long to prepare a problem for a digital computing machine. The daily repetition of effort expended in outlining a problem for coding, the tedious task of coding the instructions, and the time consumed in checking out or debugging the instructions all emphasize this fact. In this jet age, it is vital to shorten the time from the definition of a problem to its solution. end quote. One of the motivating factors for development of programming is a financial shift. At first, computers are supremely expensive, almost priceless. They're literally one-of-a-kind lab machines, their laboratory equipment. Software, on the other hand, costs nothing in comparison.

You had some clerical workers hammer it together. Then computers start to go down and process. price. They're still expensive, but they're not priceless. They're not unique. Software becomes more sophisticated as machines become more capable. And that means it takes more and more effort to produce software. More and more effort can actually be expended to produce software if you look at it in aggregate. What was a cheap afterthought turns into the main event when you don't have to build a computer yourself. Time is money. Thus, there is a very real financial. incentive to make programming faster. In this jet age, no one had time to program an unadorned

hexadecimal after all. If we take this hypothesis that the financial shift was the push that led to programming languages, the machines like the 701 and Univac are of vital importance. There are other factors, but I think the financial and availability elements are crucial to the story. The 701 is all about making a computer that's a product instead of a priceless piece of equipment. Improved programming techniques, I would argue, matched nicely with that mandate. Accessibility is the other key factor in this spread of programming. As computers become more accessible, and in this period, I really just do mean more numerous. More people are exposed to them. For the first time, you have folk that have the chance to use a computer, but didn't build that computer, or weren't closely

connected with the team that designed the machine. Languages, other than assembly, are developed that make programming easier, thus making so more people can use these more numerous computers. The early era of programming languages is a wild west, but let's be irresponsible. I'm going to shoot from the hip here and break it down into three periods. The first is the pre-compiler era before 1951. That's where theoretical languages exist. We will not discuss that era today,

just know there were ideas about programming that predated practical ways to execute those programs. The third era is post-Fortran after 1957. Fortran is the first successful compiler. It translates human-readable source code into computer-readable binary. This, as far as I'm concerned, is when programming languages first hit

it big. Fortran becomes hugely popular and hugely influential. It sets conventions that we still use today. Smack in the middle is the second period, which I'd like to call early compilers. These are actual languages that can be executed by computers. They exist before conventions that are well-established, are established. So they're strange to behold. It's in this period that the 701 sees the most use. There were as many as 20 early compilers developed for the 701, so we actually have a very broad feel to pull from. In 1953, Boeing took delivery of their 701. This was from a later batch, so it would have been made on the factory floor. Over the next three years, Boeing's programmers developed their own language. It was called Bacaic? I'm going to go with

Bacaic, the Boeing Airplane Company Algebraic Interpretive Computing System. It's described in the aforementioned Grims and Porter paper. Bacaic, besides sounding oddly close to basic, makes for a great case study in this early compiler period. It's a strange language for the jet age. Grims and Porter are very clear about their rationale. Quote, this system encourages the programmer to direct more attention towards the mathematical preparation of the expression. This is a field in which he probably is better trained and more

experienced than in the field of machine coding. More time can be spent concentrating on the phases of the problem which require human judgment and decisions and less time on the tedious task of coding. End quote. Coding here is used in the oldest sense of the word. Programmers used to write down their program as pseudocode or something like assembly language. and then manually converted into numbers that the computer could read. That process was called coding since you're turning your program into code, all by hand with pen and paper. This is actually the very same logic that led Grace Hopper to write the A-Zero compiler, the

world's first compiler. She argued that humans were natural symbol manipulators, but not very good at numeric manipulation. In other words, folk needed a more natural-natured. natural language that they could use to control computers. The Boeing team settled on a strange subset of traditional math notation, with some digital frills mixed in. Remember, when it comes to the 701, you've got to bring your own frills. Now, despite the Bacaic language having somewhat recognizable roots, it isn't really

recognizable to the modern programmer. The execution model, how code is absolutely. actually ran is odd. The best way I can describe it is it back aic. Its programs are kind of like a single function. You write up a set of expressions that crunch numbers, then you either throw those numbers onto tape or onto punch cards and pass it through. Once you've written your back aic program, you put it through the compiler, which turns it into a program the 701 can execute directly. Then you can actually execute the program. You load binary cards into the 701, hit run, and nothing happens. All Bacaic programs sit and wait for you to pass data cards.

Your program is written to take numbers from those data cards as inputs and then produce outputs. You know, like a function would. Most programming languages let you write anything. You can use Fortran to write a program that actually, like a back aic program. Many would have. But you can also use Fortran to write something that just runs on its own. One could say that back aic is specialized. It's meant for solving one class of problems. That's a hallmark of many early languages, many languages in this era. That's not to mention the actual source code. So without falling into the whole rabbit hole, let me give you a taste.

Variables, right? You know them. You love them. Those are the named spots where you store data. In Bacaic, you can use any letter for a variable, any single letter from A to Z, except K. Back Aic calls those the quote-unquote 99Ks. They're constants, which have to be fed in as data cards. I don't know why they picked K for constant instead of C. It's not explained. My guess would be they wanted to have A,

B and C for using quadratic equations. So you use K for constants. That's not as often used as a variable in traditional math, but no evidence there. Just my back-eic fan theory. You assign a value to a variable using an asterisk symbol. Backaic, in fact, just doesn't use the equal sign anywhere. It also does left-hand assignment, so you'd write. write something like 1 plus 1 asterix x. It's like saying x equals 1 plus 1. But wait, actually,

I'm wrong. That example won't work. So check this out. Numbers in backaic are treated as variables. Ha ha! That's right. You are forced to use the 99Ks. So you'd write something like K1 plus K1 asterix X, and then you would have to set K1 to 1 in your data card deck. The reasoning for that restriction comes down to the 701, actually. And this is a legacy of the IAS machine. The 701 has nice, wide words, but its machine code is packed two instructions per word. That means you can't actually write an instruction that sets a location in memory to a large number.

You can't write a program that just uses normal raw instructions to fully set a word in memory. You have to store those large numbers in memory manually and then operate on them. This is another hallmark of early languages. They have bleed over from their host hardware. While they do protect programmers from some of the esoterica of the machine, there are holes in that protection. In the case of early languages, those holes are large and they feel very strange and arbitrary. Folk hadn't figured out all the tricks to hide these types of idiosyncrasies.

Okay, so then what's the deal with the whole number variable thing? Well, it references line numbers. This is, well, I feel like I must have seen this before. it seems basic enough that I'm sure another language implements this, but I cannot place the idea. One plus two is actually telling Bacaic to take the results of the expression on line one and add it to the result of the expression on line two. You may have some questions. I did too.

Luckily, the Backeyeck paper presents just about everything you want to know. The key here is to remember that Bacayek executes most. much differently than modern language. Each expression is compiled on its own. That way a program can track what happened on line one or line two. That's not very normal. At least, to expose it to the programmer isn't very normal. But hey, for early languages, this is par for the course.

Norms are not yet established. It's on machines like the 701, these very early, serially-produced computers that norms start to fold. Looking at languages in this period is looking like the very beginning of an evolutionary process. All right, that does it for a dive into the IBM 701. It was IBM's first real shot at a computer. And by that, of course, I mean a computer by its long name. An electronic digital stored program computer.

There are a few crucial points to bring up here at the end. First is that IBM itself viewed the 701 as a major shift. Big Blue didn't make increasingly complex tabulators until they realized they were just a step away from a computer. Rather, the jump to computers was intentional and hard-fought. Internally, a number of prototypes had to be made to show IBM that they could even build computers, let alone sell them. External forces, like UNIVAC and, oddly enough, the Korean War, were also needed to push IBM to action. Second is that the IBM 701 wasn't a totally new computer, but it also wasn't a copy of an existing machine. This is part of my long-running beef with the list of IAS machines on Wikipedia.

IBM didn't just make a mass-producible clone. They drew on the design of the IAS machine, true, but they intentionally improved it. The 701 was an IAS with better input output, and a number of other little fixings. So related, yes, at least in terms of base design. Finally, is that we can look at the 701 as a machine at the tipping point of an era. In the mid-50s, we shift from unique machines to more serially and mass-princian. produced machines, and eventually we get true, honest mass production. That changes the very character of computing.

That change in character can be seen in the development and spread of programming languages. It can also be seen in more cultural terms, like the development of user groups and even degree programs in computer science. Thanks for listening to Admin of Computing. I'll be back in two weeks' time with another piece of computer. 's past. If you like the show, there are a few ways to get more. You can support the show on Patreon by going to add-in-of-computing and clicking the support-the-show link in the sidebar. You can also now listen to our official after-show adjunct of computing, available anywhere podcasts or

listened to. And you can join the conversation over on our official Discord server. Until next time, as always, have a great rest of your day.