Advent of Computing - Episode 36 - The Rise of CP/M

Episode Date: August 9, 2020

The IBM PC and MS-DOS, the iconic duo of the early 80s. The two are so interconnected that it's hard to mention one without the other. But in 1980 DOS wasn't IBM's first choice for their soon-to-be flagship hardware. IBM had wanted to license Gary Kildall's CP/M, but in a strange series of events the deal fell through. Legend states that Kildall lost the contract b was too busy flying his private plane to talk business with IBM, but is that true? Today we look at the development of CP/M, why it was a big deal, and why the PC ultimately shipped with Microsoft software. Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and stickers: https://www.patreon.com/adventofcomputing

The year was 1980, and IBM was on the prowl for software. The personal computer, the company's latest attempt at producing a small-sized machine, was approaching completion. The hardware was coming together nicely, but that's only one part of the equation. They needed some software to round the whole package out. But here's the deal. The PC was a totally new machine, so IBM couldn't just grab a pile of programs off the shelf and run. And with resources tied up finishing the hardware, IBM didn't really want to write their own

operating system. So they needed to find a partner, and they needed one quick. Their first choice was Gary Kildall and CPM. In 1980, CPM was the biggest and best operating system for home computers. It worked. It worked well. It could handle a host of different hardware configurations, and early adopters of microcomputers just plain liked CPM. But things didn't go as planned. In fact, things went so wrong that the stories become almost legendary in computing circles. My favorite rendition of this tale was written by Peter Norton.

Quote, As the story goes, when IBM came shopping for CPM, Gary Kildall, the man who created CPM, intentionally kept IBM's representatives waiting and fuming while he flew his plane for hours in the skies overhead. Kildall, we're told, thumbed his nose at IBM as a customer, while Bill Gates, head of Microsoft, rolled out the red carpet for IBM. Gates donned his rarely-worn business suits for meetings with IBM to demonstrate that he was serious about doing business with them.

In the end, Gates would win the contract with IBM. Microsoft DOS would ship with the PC just a year later, and Microsoft's star would rise even further. The story paints Kildall as a snob, whose own arrogance blew a massive business deal. But did this even happen? Did a power-mad software developer literally fly away from fame and fortune? As it turns out, the real story is a lot more complicated, and a lot more interesting.

Welcome back to Adrin of Computing. I'm your host, Sean Haas, and this is episode 36, The Rise of CPM. Today, we're tackling a story that's fascinated me ever since I was a kid. I learned to program with the help of my dad's old PC clone and stacks of his old programming books. Out of all of the resources that I had at my disposal, one of my favorite was Peter Norton's Inside the IBM PC. I still have the same copy sitting on my shelf today. The book is basically a guide to the PC, other IBM computers in the family, and some of the more prominent clones. It covers hardware, software, and a little bit of history behind all of it. And tucked away in the middle of everything is a short section on CPM, DOS, and why Microsoft won out. The story of Kildall flying over the

heads of angry IBM executives has stuck with me ever since, and I've seen it recounted in varying forms all over the internet and in countless other books. But here's the thing, it might not be true at all. Is that really why DOS shipped with the PC instead of IBM's original first choice? The short answer is no. As with a lot of good tales, the full story is a lot more complicated, and I think it's a lot more compelling. In the next two episodes, I'm going to do my best to lay out a more accurate description of events. Gary Kildall wasn't just a software profiteer with an ego and an airplane. No more was Bill Gates a perfect salesman selling a perfect and finished product. To do the story justice, we're going to need to take a look from all three sides of the issue. Today, we'll be looking at the roots of CPM and IBM's quest for PC software.

Next time, we'll pick up from the Microsoft side of things and look at how they won the biggest contract of their early years. So, let's kick it off. Who was Gary Kildall, and how did CPM become such a force to be reckoned with in the early era of microcomputers? How did Gates, Paul Allen, and Microsoft go from players in the basic world to shipping software alongside IBM? How did IBM get caught up in all this anyway? And perhaps most importantly for me, did Gary Kildall really fly away his best opportunity? To tell the tale, we need to start at its source, and that's Gary Kildall himself. To tell the tale, we need to start at its source, and that's Gary Kildall himself.

Now, Gary didn't start off life as a possible eccentric software developer. In fact, his first love was teaching. In the mid-1960s, he enrolled at the University of Washington in Seattle. His goal was to become a high school math teacher. But that dream didn't actually last for very long. While at UW, he came face-to-face with computers for the first time. Quoting from an interview with Kildall, A friend of mine had this Fortran statement card,

showed it to me, and told me it was going to be a really big thing. I became so intrigued that I had to get into it. So I took an assembly language programming course and Fortran right after that, and I was hooked. End quote. From then on, Kildall wanted to teach others to program. This is one of the areas where he got really lucky. Kildall ended up being in the right time and place for this to be possible. In the 1960s, computer science was a very new and very niche discipline. Computers were starting to show up on campuses around the world, but very few colleges actually had dedicated computer science departments. UW was one of the first to go that route. In 1967, the university formed their computer

science department and they started to offer graduate degrees in the field. If Kildall had enrolled just a few years earlier, that kind of degree would have been totally out of his reach. But the world was changing, and he was set to be right in the middle of that really quick change. Kildall earned his PhD in computer science in 1972. With that, he was more than qualified to work as a professor. But there was one little obstacle in the way, and that was named the Vietnam War. At this time, the US military was still populated by a draft. It was possible to get exemptions for a number of reasons, such as being in bad health or working in a critical field. In Kildall's case, he was safe from the draft while he was in school. Full-time students couldn't be drafted.

Once he graduated, that was no longer the case. Kildall was left in a position where he would either have to enlist or be drafted. This could have been disastrous for Kildall's career, but things actually took a really good turn. He chose to enlist with the Navy, and once signed on, was offered a posting as a computer science professor at the Naval Postgraduate School in Monterey, California. This arrangement ended up working out perfectly for Kildall. He was able to avoid combat while teaching at a university level. And as a professor at a well-funded program, he was able to stay up-to-date on the cutting edge of computing. From all accounts, he was able to stay up to date on the cutting edge of computing. From all accounts, he really liked the posting. It shook out to be pretty close to what he had dreamed of in college.

For most of the week, he taught programming classes, his favorite being data structures. That took up a lot of his time, but it left enough free time for him to program and tinker on his own. Kildall was set, he could happily spend the rest of his life teaching at the naval school. But that wasn't meant to be. Fate would step in and change things. This is where we come back to another one of our usual suspects, a little company known as Intel. In 1971, Intel introduced the 4004, the world's first microprocessor. At first, not many people were all that interested in the little chip. It was technically impressive. It was a totally new approach to computing. But no one really knew quite what to do with the thing. That included Intel itself. For those outside the

company, the 4004 was fascinating. But there was a shocking lack of support for the processor, plain and simple. There was no existing software to run on it, and very few tools to develop new software for the chip. But some people weren't that vexed or confused. There were a handful of folk who saw exactly where this future was leading. Sitting at his terminal one day, Kildall came across the 4004. Someone had posted about the chip on a bulletin board, essentially an antiquated type of forum. Kildall came across the 4004. Someone had posted about the chip on a bulletin board, essentially an antiquated type of forum. Kildall immediately realized that he was looking at the future. A computer on a single chip would change the whole world. It seems like a really obvious idea to us today. Of course, the microchip was a big deal, but at the time, no one knew what was

coming. Although sitting in his desk in 1972, Kildall did start to see the broad strokes. Computers in that era were still limited. They were only really used by big institutions and big businesses. The machines were just too expensive, too large, and too complicated for a single person to own or even operate. Those that were fortunate enough to have access to a computer in that era, well, they knew that they were amazing tools. But to everyone else, they might as well not exist. A microchip wasn't the last step, but it was a big one. If a cheap and simple computer could be built, one that a single user could afford and operate on their own, then that would be earth-shattering technology. The idea of a personal computer wasn't all that new in 1972, but it was starting to look

possible. Kildall would be one of the early adopters that would take that plunge and see where their future could go. A development system for the 4004, called the SIM 4-01, was a lot cheaper than a full-blown mainframe, but it still cost quite a bit. Kildall wasn't able to fork over the roughly $1,700 for a base system, so he went for the next best thing. All the developer docs for the chip were readily available, so in his spare time, he started to program a 4004 simulator on one of the school's mainframes. Without buying any new hardware, Kildall was able to punch in a program and run it on an emulated 4004, and he could do this all from the comfort of his own desk. By following Intel's documentation,

he was able to make his programs work just like the real thing. Now, writing an emulator is a pretty involved task. You need to be willing to get very, very comfortable with the platform you're emulating. You're basically re-implementing a whole processor, but in software, it's no small feat. For Kildall, that meant that he quickly became a 4004 expert, one of the first in few. But he soon came to realize that this wonder chip wasn't exactly what he expected. It was rudimentary, at least if we're being generous. The 4004 was really just the outgrowth of a design for a desktop calculator. Sure, it could be used as a processor, but it wasn't very powerful.

For someone like Kildall, who had only ever worked with mainframes, this new chip must have been a huge letdown. It was the seed for something big, that much was clear, but it had yet to grow very much. Gary would keep tinkering with his simulated 4004 over the course of 1972. For a test program, and to put the chip through its paces, he started to develop a simple navigation program for boating. But even a pretty basic program ran into some issues on this new chip. The big problem came down to the mathematics involved. Kildall's navigation program used simple trigonometry to calculate the location of a boat. On mainframe,

that kind of math is simple. Just call up a sine or cosine function and you're done. But the 4004 didn't have those functions built in. And even worse, it could only work with 4-bit numbers. Kildall had to hack together his own library of trig functions. It was slow going, but with some determination, it was possible. Most amazing of all, the code seemed to work just fine. He was able to get a really complex program running on a fake 4004. It was cool, but he wanted to work on the real thing. So Kildall moved to phase two of his plan. That is to get Intel to give him some free hardware.

As Kildall put it, All my 4004 programs came together, so I called Intel to see if I could scam a development system. I ran to Bob Garrow at a time when he was a fairly well-promoted engineer at Intel. I tried to sell him on the notion of trading my 4004 simulator for one of his $1,000 SIM401 development systems. Being a hardware nut, Bob didn't want the simulator. But he did want the trig routines because they were the beginning of a library for the 4004 of sorts. Hey, I didn't care. I just wanted the SIM401.

Kildall was a really early adopter of the microprocessor. So early, in fact, that Intel had yet to publish much software at all for their own chip. While his simulator was impressive, his 4004 programs were a lot more interesting to Intel. So after a call and a meeting over lunch, Kildall made the exchange. By the time 1972 was out, he had his very own 4004 development system, and Intel had a jumpstart for its own software library. And most importantly, this was the start of Kildall's long relationship with Intel. Over the next few years, he would spend his off hours contracting for the company, and slowly working towards a real personal computer.

Now, I'd be doing a disservice if I didn't bring up an interesting connection here. Kildall wasn't the only person in the Navy that was interested in personal computing. Far from it. Another early adopter was none other than Rear Admiral Grace Hopper. By 1972, she was already a living legend. She had created the first compiler, developed COBOL, and was flat out one of the first programmers in the world. She and Kildall were in a very similar line of work, and over the years, they'd get to know each other pretty well. And as it turns out, the two had a very similar view on microprocessors. As Kildall recalled, quote, Grace became a friend. I was helping to, quote unquote, man the Intel booth at the National Computer Conference in the fall of 1972,

and Grace came by proudly in her military dress. She gazed sneakily at me with those eyes that shone in that brilliance of hers, though her outward appearance was of a frail demeanor. With stealth, Grace reached into her purse and brought out an Intel 4004 chip, then whispered to me, this is the future. Grace Hopper had been there at the dawn of the computing revolution, and she'd played a big part in driving the fields forward. If the Admiral saw the same future that Kildall saw, well, that was proof positive he was on the right track. And, well, I can't really miss the opportunity to include an Admiral Hopper story wherever I can. Kildall's work with Intel would put

him squarely in the center of the next big revolution, and that would be the microcomputer revolution. After his initial brush with the 4-bit chip, he continued churning out code for the semiconductor company. As the 8008, Intel's next processor, was finishing up, Kildall became one of the first programmers to use it. Now, there was a monetary benefit to moonlighting and Intel, but for Kildall became one of the first programmers to use it. Now, there was a monetary benefit to moonlighting and Intel, but for Kildall, the biggest payout was getting to live on the cutting edge of computer technology. That and this arrangement made it so that Kildall was always well-supplied with chips and development systems from Intel. And hey, it was definitely a plus that he didn't have to spend money on any of them.

But Gary wasn't content to keep this new technology to himself. It wouldn't be long until he brought some development systems and some new chips into his classroom back at the Naval School. Kildall set up a makeshift microcomputer lab in the back of his classroom, and he started to spread the new gospel. But even with access to the new and improved 8008 processor, and all the specialized development hardware that Intel could throw at him, he still was underwhelmed by it all. These early processors were pretty limiting, and programming them was actually one of the most frustrating parts. In the software biz, we'd say that it wasn't a mature ecosystem.

In other words, there were still a lot of problems that needed to be ironed out. The biggest problem that Kildall faced was actually just programming Intel's chips. To fully understand his grievances here, let's take a minute to look at the process that he had to go through. Kildall was working with development systems provided by Intel. Now, these are types of specialized computers, essentially. Think of it as a reference model of a computer that a manufacturer puts out. In this way, the SIM4-01 system that Kildall had access to were some of the first and earliest microcomputers produced.

But they weren't meant for consumers. They were built specifically to give developers something to test code on. After the 8008 came out, Intel upgraded Kildall to their newest dev system, the Intellec 8. It was a much more capable chip and a much more powerful computer. But it was still built primarily as a testing and development system. It had all the latest and greatest silicon that Intel had to offer, something akin to a tricked out prototype rocket. Kildall should be happy, right? Well, here akin to a tricked-out prototype rocket. Kildall should be happy, right? Well, here's where we get into the fun part.

Even the idea of a microcomputer was still in its infancy. The computer part, at least a functioning processor and RAM, was all there. But in general, these early systems were pretty no-frills affairs. You didn't have a nice keyboard, and you didn't have a screen to work with. You had a steel box, some wires, lights, and switches. Let's take the Intellec 8 as an example. There were a few options to get a program loaded onto the computer. You could enter in a binary program using a set of switches on the front of the computer, bit by bit. You could grab an empty ROM chip, burn your program onto it, and then plug that into a socket on the Intellec 8. Or you could hook up a serial terminal,

toggle in a boot-up program on the front panel, and then read your program off a strip of paper tape. No matter how you cut it, things went really slowly. And with limited debugging capabilities, a mistake in your code was really hard to find. Kildall also couldn't program directly on the Intellec 8. One of the reasons that he kept dev systems in his classroom was because he still needed access to a mainframe to actually write code. In practice, he would sit down at a terminal hooked up to a navy computer,

hammer out some code, compile it, spit out a paper tape, and then feed that tape into the IntelliC8. So sure, you can use a microcomputer, you just need to have a mainframe if you ever want to program it. At this point, a small microprocessor-based machine couldn't take over any part of a mainframe's job, and that made it impossible to make it into a home computer. And this is where Kildall reached his big idea. Well, his series of big ideas, really. He already had a box sitting on his desk that could do the core task of computing, and sitting off in some air-conditioned room, he had access to a larger computer that could do everything else. Between the two systems, Kildall could get just about

anything he wanted done, but he wasn't super happy with either. So why not create some type of middle ground? Why not adapt what the mainframe could do and shrink it down to the scale of a microcomputer? That's a pretty broad goal, and there's a whole lot of directions that that could go. A microcomputer at this point was still missing a whole lot of what a mainframe had to offer. But in Kildall's approximation, there was one feature that would be the most important. And that was some type of mass storage. On larger computers, storage drives had already become a mainstay. Having access to relatively large random storage allowed for a lot more flexibility. Instead of loading in data from a strip of paper, you could just pull up a file, load it into memory, and then mess with the data to your

heart's content. Kildall wanted to adapt this type of technology to the microcomputer. This would open up a world of possibilities. A user could easily run different programs, and with the right software, you could even write and compile your own programs, all without the need for a mainframe. There were a few options, but at the time, the most reasonable choice had to be a floppy drive. This was a pretty new technology in the early 70s, but compared to hard drives, it was cheap and somewhat accessible. But this is where Kildall ran into a bit of a personal problem again. But this is where Kildall ran into a bit of a personal problem again. He was starting to look at getting a floppy drive around 1974, just after the release of Intel's latest and greatest chip, the 8080.

Kildall had been given an upgraded development system from Intel, and wanting to get the most out of his new toy, he went out and bought a brand new CRT terminal. When he finally got around to shopping for a floppy drive, he was pretty strapped for cash. So Kildall opted to get creative. He got in contact with Sugar Art Associates, one of the bigger floppy drive manufacturers in the region, and he tried to scam a free floppy drive. Quoting from Kildall again, quote, I misused my Intel credentials to get access. Fennis Conner worked as the marketing manager, Kildall had managed to embed himself within Intel. In exchange for tinkering around and writing code,

which he would have done for free on his spare time anyway, he managed to get a pile of very expensive development systems. And for his next trick, he used his association with Intel to get a gently loved floppy drive all for free. His account of events make it sound a little bit bumbling, but Kildall definitely knew how to get what he wanted. But even with all the parts in place, there was still one big hurdle. No one had plugged a floppy drive into a microcomputer before. This was mainframe hardware. And as a software guy, Kildall wasn't a very good person for that job. He'd end up needing some outside help.

This was the start for a bit of a rough patch in Kildall's quest. He kept on teaching at NPS and kept on contracting for Intel, but he didn't actually get any closer to a microcomputer or a working disk drive for that matter. Quote, the disk drive sat in my office at NPS for a year. I'd look at it every once in a while. That didn't seem to make it work any better. End quote. Kildall was a programmer, not a hardware person. For those down the field, it may seem that a soldering iron and a keyboard are close cousins, but nothing could be further from the truth. Hardware development is an entirely different discipline, one that Kildall was unfamiliar with.

What makes this worse is that hardware and software, well, they have to work together. So even if he had the hardware side of things working, he would still need software to tell it what to do. After a few failed attempts to make a controller that could interface the floppy drive to his computer, all he got was frustration. So he decided to take a different approach, one that would play more into his expertise. He still had access to a mainframe. Over the years, as Intel upgraded Kildall's development hardware, they also passed him new development software. That included an emulator for the 8080 processor, the latest and greatest.

If he couldn't get a hardware controller working, well, he could just emulate one. Kildall already had a fake 8080 computer that he could run inside a mainframe. Adding a fake floppy drive to it wouldn't actually be that hard. After a little tinkering and debugging, he was up and running. And then the ideas started flowing once again. I've already touched on how the hardware was just one side of the equation. The lack of mass storage hardware on microcomputers, well, that severely limited what they could do, and it severely limited what kind of software that they could actually run. If you have to read in a paper tape every time you need to start up a program, or load data for that matter,

then you run into some problems pretty quickly. A floppy drive meant that you could quickly read data, you could swap from one program to another, and you could run larger programs in general. But all that wonderful hardware would be useless without some kind of software to back it up. What Kildall had in mind was to write an operating system. Now, operating systems had existed for quite some time on mainframes and minicomputers. In short, an OS is a full suite of software. It manages the computer's actual hardware while presenting some type of usable interface for programmers. On the high end of things, you have systems like Unix, a frequent topic on the show and one of the cornerstones of computing ever since 1969.

Unix is massive. It can handle multiple users, can run simultaneous processes, and access an arbitrary number of disk drives. It's powerful, flexible, and flat out some of the best software ever written. There are a slate of technical reasons why Unix, or any OS from a big computer for that matter, couldn't work on an early microcomputer. They were just built for different types of processors. They used a lot more memory than a small machine could handle. I could keep going. But let's disregard all of the technical suppositions for a second.

From where Kildall was sitting, Unix would actually really suck on a microcomputer. A personal computer had different uses than a mainframe. You really aren't going to be sharing resources on a microcomputer. In general, everything is just scaled down, so Kildall needed a scaled down operating system. Unix and its friends were just too much software for a microcomputer, at least at this point. And with little to no software written for microcomputers, Kildall would have to create his own OS from scratch. Over the next year or so, the code started to come together, and Control Program for Microcomputers, or CPM, was born. What makes CPM so significant is that it was the first full operating system designed for microcomputers. Everything about it was tailored for this new type of machine.

Kildall was influenced by his experience working on mainframes, sure, but the core of CPM was purpose-built for a more personal type of computer. So, just like its target hardware, built for a more personal type of computer. So, just like its target hardware, CPM was stripped down to the bare essentials. Specifically, Kildall was targeting a system that had an Intel 8080 processor, a little bit of RAM, at least one floppy drive, and a terminal. It was his vision of a baseline useful personal computer. And with a few changes, PCs have followed that pattern for decades now. Kildall's big focus on these early years of development was adding a disk drive to home computers, so it should be no surprise that the core of CPM is really just a file manager.

Once booted up, it offers a simple command line input. With a few keystrokes, you can get a listing of all files on a floppy disk, view or edit the contents of a file, and even load and run entire programs. It's simple, but deceptively so. Let's take getting a file listing, for instance. The command for that in CPM is just DIR, for directory. Hit enter and you get a list of all the files on the current disk. Easy.

But under the hood, CPM has to call out to the disk controller. It has to spin up the drive, read a header sector off the disk, decode that header, and then format an output. It's a lot of little things to manage, too much for a person to reliably do with a pile of paper tape and a bank of switches. Now, listing files is cool and all, but CPM could do a lot more. The most complicated feat that it pulled off, and the most powerful, was loading and running programs from a disk. We do this casually every day. Any program you run is stored on some

kind of disk somewhere. Mainframes had already been doing this for years. But Kildall was the first to bring this functionality to the smaller side of things. Once again, from the user's viewpoint, this was all really simple. You type the name of the program, and then it just runs. Done. To make the magic happen, CPM goes out to the disk controller, finds where the file is located on the disk, loads all of that file into memory, and then tells the processor to start running that new program. It's not rocket science type of stuff, but it's something that opens up a whole host of possibilities. Once a program's up and running, it can still use parts of CPM to access the disk.

Put that all together and you can have a much larger piece of software running. They can create and keep their own data on disk, and you can then pass that data around and those programs around to other users. And perhaps most importantly, this meant that you could write code and compile code on a microcomputer. For a microcomputer. By just adding a floppy drive and some clever software, Kildall was able to reimagine how a microcomputer could be used. The dream of a personal computer was already a hot topic, and Kildall was able to reimagine how a microcomputer could be used. The dream of a

personal computer was already a hot topic, and Kildall was starting to fill in the details. He was finally sitting down at a system that could be totally separated from a mainframe. But he still wasn't quite at that promised future. At least not yet. Up to this point, CPM was still running inside an emulator. You can't really just point at a mainframe and say, see, there's a PC in there, just gotta look a little bit. It's a big step, but it's not a finished job. Kildall would have to break out of his beloved software land to get something working.

So in 1974, he decided to phone a friend. Kildall got back in touch with John Tirode, a colleague who had went to the same PhD program back in Washington. But while Kildall had graduated as a programmer, Tirode graduated as an electrical engineer. John ended up taking the bait. It sounded like an interesting project after all. And soon, CPM would come into the world of hardware. After a few months of work, Tarod had a rough prototype up and running. It was the moment of truth. Quoting from Kildall again, quote, we loaded my CPM program from paper tape to the disket and booted CPM from that disket,

and up came the prompt, asterisk. This may have been one of the most exciting days of my life. asterisk. This may have been one of the most exciting days of my life. End quote. That asterisk on the screen was the sign that CPM was waiting for input. And just like that, Kildall and Tirod were face-to-face with the most advanced microcomputer ever built. And they were one step closer to attaining Kildall's vision. Now, part of the story should sound familiar, at least to long-time listeners. Just a year later, a very similar event would play out. Microsoft's first product, Altair Basic, was developed using an emulator. It was targeted at the Altair 8800, a computer that didn't actually exist yet. It would take a lot of work, but eventually Gates and Allen got the chance to

demo their program on a working Altair. That would be the first test of their program on real hardware. It ended up working, and the two just about exploded with excitement. I bring this up for two big reasons. Firstly, programmers kinda tend to think alike. We know software, but not really hardware. When backed into a corner, most programmers will come up with pretty similar solutions. But also, there's a strange symmetry going on here. In the coming years, Gates and Kildall would have a lot of dealings with each other. So I find it interesting that Gates' big break was made in a very similar way to Kildall's. Just some food for thought down the line.

Anyway, before 1974 was out, CPM had become a reality, at least on Intel's reference hardware equipped with Tirod's controller and a very well-worn floppy drive. Kildall's great idea had borne fruit, and like a lot of great ideas, it was bound to spread. This process started in part thanks to Kildall's job as a professor. You see, school doesn't run year-round, so during the summer, Kildall's job as a professor. You see, school doesn't run year round, so during the summer, Kildall had a lot of extra time on his hands. To rake in some easy cash, and probably to keep himself occupied, he'd do a little bit of contracting work during these months. And invariably, his co-workers would hear about CPM. Sometime in the summer of 1975,

one of those fellow contractors suggested that Kildall should start selling his own software. By this point, there was actually a market, if a small one. Hobbyists and early adopters were very likely to kill for some good software. And Kildall really liked the idea. After all, CPM was basically completed. Turning his personal project into a sellable product would just be a matter of sending out disks and tapes. At the recommendation of Dorothy Kildall, his wife, Gary started a new company to deal with selling and distributing that software. So in 1976, Digital Research Inc.,

or just DRI, was formed. Co-founded by both the Kildalls, Dorothy would handle the business and admin side of things, while Gary's job would just be to churn out code. From there, CPM would make its way out into the wider world. I can't find if the software was being sold directly to consumers at this point. I suspect the Kildall was probably selling copies on the side, but I can't find concrete sourcing for that. Most of DRI's business was in licensing CPM, and that model ended up working very well for the company.

Computer manufacturers are always looking for the next big thing to give them an edge, and in the 1970s, CPM fit that bill exactly. It was the only operating system on the market for microcomputers, and it was really the only way to get much use out of the then state-of-the-art floppy disk drives. So companies flocked to DRI for licensing rights to the newest code on the block. In general, these arrangements worked out such that the licensee would pay a per-unit shipped fee, so Kildall and Kildall could just sit back and watch the checks roll in. However, there was a little bit of upfront work, at least in the beginning.

At this point, we're still dealing with 8-inch floppy disk drives, and those didn't really have a standard interface yet. At least not in the realm of home computers. A lot of DRI's early clients also needed disk controllers. So usually the arrangement worked out such that Tirod would provide the designs for a disk controller, and then Kildall would need to make a slight customization to CPM for the client's specific hardware. Each computer was a little bit different, so the actual code for handling disk and I.O. would have to be a little bit different. And like I said, this arrangement worked out pretty well. CPM got big,

and it got big really quick. It was during this phase of expansion that Kildall made one other important decision that I want to touch on. At this point, for each new customer, Kildall had to personally rewrite the basic input-output routines in CPM. It wasn't a huge lift, but after a while, he just got sick of doing it. So he decided to do something about it. To quote from Kildall, I'd already done this so many times that the tips of my fingers were wearing thin. So I designed a general interface, which I called the BIOS, Basic Input Output System, that a good programmer could change on the spot for their hardware.

This little BIOS arrangement was the secret to success of CPM. End quote. So yeah, there you have it. Kildall invented the idea of the BIOS. This is a term that's stuck around the PC world for literal decades, and it all came from Kildall trying to offload a little bit of work. While the original intent of the CPM BIOS was to free up some time, it ended up cementing CPM's foothold in the microcomputer market.

Going forward, when a client licensed CPM, they got the base system, and they got the source code and the documentation for the BIOS. Then one of the client's programmers could just rewrite the relatively small BIOS code, and boom, CPM was now up and running on a totally new platform. In this way, DRI was able to ship out copies of CPM with little to no work, and it became very easy to adapt CPM for a totally new computer. There was a total lack of standardization in the industry at this point. But that didn't matter for CPM. It could adapt to any situation. Kildall's brainchild and DRI's first product became a massive success.

By the end of the 1970s, just about every major home computer could run it. From the Altair 8800 to the IMSAE. Even the Apple II and the Commodore 64 could be coerced into running the software. say. Even the Apple II and the Commodore 64 could be coerced into running the software. And it was during this expansion that Kildall met someone we all are very familiar with. This brings us around, finally, to IBM. In 1980, a strange project had started at IBM, codenamed Project Chess. By this point, Big Blue was, well, a really big deal in the world of computers. At least when it came to mainframes and bigger computers, IBM was a juggernaut.

They'd made passes at the home computing market before, but they just couldn't keep a foothold. Project Chess was their latest attempt to turn that around by designing a cheap and reasonably powerful home computer. Today, we know that system as the IBM 5150, or better put, the IBM PC. The overall design of the PC was simple, and it took a lot of cues from other early home computers. Encased in a single metal box, you had two floppy disk drives, a microprocessor, some RAM and ROM, and a slate of ports for expansions and peripherals. processor, some RAM and ROM, and a slate of ports for expansions and peripherals. Kildall's predictions for future home computers had totally come true. The PC wasn't the first to take this approach, but it was yet another system that conformed to this line of thinking. But there were some differences and peculiarities in IBM's design.

The PC was a 16-bit machine, at least roughly speaking. The driving power behind the computer was the Intel 8088 microprocessor, one of Intel's latest and greatest chips. It was essentially the next generation up from the 8080 chip that Kildall had been familiar with. The two processors are roughly compatible. You can get 8080 code to run on an 8088 with a little bit of work, but the processor was just one part of IBM's creation. The PC was a totally new computer. The motherboard was a new design. It had its own floppy disk controller. It had its own video circuitry. So even if you were to migrate some old code to the machine, it wouldn't really work that well.

And this put IBM in a bit of a bind. Project Chess was operating on a pretty fast timeline, so they didn't have the luxury of writing all their own software for the new computer. Instead, the plan was to license out software from third parties. But getting everything in line would prove to be a bit of an error-prone process. There were two main programs that IBM was after. The first was a basic interpreter. At this time, it was pretty standard for a home computer to boot up to a basic prompt, and the PC was slated to follow that convention. The other program was a disk operating system, something that could handle more complex tasks and interface with the built-in floppy

drives. And in 1980, the choice for both of those programs was pretty clear. Microsoft provided the best version of BASIC that money could buy, and DRI's CPM was the only show in town when it came to microcomputer operating systems. Before the year was out, a delegation from IBM hopped on a plane with the intent to strike a deal. But here's where things get complicated. IBM was a mainframe company, first and foremost. The corporate titan didn't really know all that much about tiny computers, so some mistakes were made and they were made early and often. Instead of visiting Gates to get a deal for BASIC and then Kildall to get a license for CPM,

they only went to Bill Gates. The IBM team had it in their head that Microsoft could license both BASIC and CPM. But that just wasn't the case. Those were two products from two different companies. It sounds like a dumb slip-up, but there was a possible reason for IBM to be confused. By the time 1980 rolled around, Gates and Kildall had a pretty strong working relationship, and their products kept finding a way to ship together. This connection started all the way back with the Altair 8800. Bill Gates and Paul Allen got their first real success licensing BASIC for the Altair,

but the machine ran more than just BASIC. Once disk drive expansions became available, Kildall would license out copies of CPM for the Altair computer. Kildall had already met the young duo behind Microsoft. They ran in similar tech circles, but the Altair was their first time that they indirectly worked with each other. And, perhaps even more importantly, it was in this period that Gates and Kildall became close personal friends. They each sold a very similar product, but CPM and Basic were different enough that they weren't exactly in competition. But that's not to say that they had a totally synergistic relationship. Kildall described

it something like this, quote, Our conversations were friendly, but for some reason I've always felt uneasy around Bill. I always keep one hand on my wallet and the other on my program listings, But Bill was always nice and eager to talk business. Eventually, this led to more direct cooperation between Microsoft and DRI. The biggest result to come of this cooperation was the Apple II soft card. Now, the story behind this device is probably deserving of its own episode, so I'll try to be a little brief here. In short, the soft card was an expansion card that Microsoft developed for the Apple II computer. It added a Z80 processor to the Apple machine, and all the ancillary chips to run that processor.

The main purpose was to give early Apple II users a way to run Microsoft BASIC and CPM. The Apple II would eventually ship with MS Basic, but that's still a few years out at this point. To make the whole thing work, Gates had struck up a licensing deal with Kildall so Microsoft could sell copies of CPM along with the soft card. DRI and Microsoft were pretty close, and IBM had no experience in the microcomputer niche, so it was easy for them to get a little bit mixed up. This is where the comedy of errors kicks into high gear. In 1980, a small delegation of lawyers, managers, and developers from IBM showed up at Microsoft.

They wanted to speak with Gates. As was their practice, the IBM crew refused to say anything until Gates signed a non-disclosure agreement. As Bill Gates put it in an interview for PBS, quote, IBM didn't make it easy. You had to sign all these funny agreements that sort of said I, IBM, could do whatever they wanted,

whenever they wanted, and could use your secrets however they felt. So it took a little bit of faith, end quote. There is a pretty important clause hidden away in that stack of paper. By signing, Gates agreed not to tell anyone on the outside that IBM had paid them a visit. Their conversation, right down to its very existence, had to be kept a secret for the time being. He knew this kind of opportunity wouldn't come again, so Gates signed on the

dotted line and got down to business. The basic part of the deal was no problem. Microsoft could crank out that part with ease. But when the topic of CPM came up, well, that didn't go so well. Gates couldn't sell them someone else's product. But he could point them in the right direction. He suggested that they get in touch with Kildall, gave them an address for the DRI offices, and even phoned ahead to let Gary know that IBM was on their way. But here's the thing. Thanks to the NDA, Gates couldn't actually say, hey buddy, some folk from IBM are going to visit. They want a licensed CPM. According to Steve Ballmer, it went more like this. And so Bill, right there with them in the room, called Gary Kildall at Digital Research and said,

Gary, I'm sending some guys down. They're going to be on the phone. Treat them right. They're important guys. End quote. So to Gary, it must have just sounded like business as usual. He and Gates were close, so it's easy to imagine that this kind of call had been placed before. Kildall had no idea that one of the biggest computer manufacturers in the world was about to pay him a visit. What happened next? Well, there's actually really conflicting reports on this. We already heard the most fanciful telling at the start of this episode. Kildall flew circles around the IBM execs while they fumed in their boots. But that story is definitely fictitious. But the truth of the matter is a little convoluted. What makes things hard to pin down is that each side has their own story, and they've stuck to it.

Jack Sams was a member of the IBM delegation during this ordeal. He was the principal engineer behind the PC, and was present at the Microsoft and DRI meetings for these events. In Sam's telling of the story, he showed up at DRI's offices and was greeted by Dorothy Kildall. She was handling business affairs at the time, so she was the exact right person to contact with a business deal. But first, the all-important non-disclosure agreement had to be signed. When presented with the paperwork, Dorothy downright refused to sign. IBM was insistent that they do, so Dorothy called a lawyer. Sam's recalled, quote, We tried to get past the point of signing this non-disclosure agreement so that we could talk about what we came down to talk about.

It was 3 o'clock in the afternoon before they finally got around to the point of signing an agreement that said we had been there and they would not disclose it. I was completely frustrated. We went back to Seattle the next day and I told Bill we'd been unsuccessful in trying to deal with Gary." If Sam's is to be believed, then DRI never even knew what the deal was. He would never even meet Gary Kildall and wouldn't have even seen him flying a plane overhead. The story gives a relatively simple answer. IBM came knocking, but DRI didn't want to deal with them. So Sam's and his crew turned right around and went back to Microsoft. There's an extra detail that after this failed trip, Sam's called up Kildall directly to try again. According to Sam's, Kildall remained insistent that he didn't want to work with IBM.

But that's just one side of the story. Gary Kildall has a totally different version of events, and this one actually involves planes. Two of them, if you believe it. According to Kildall, he was out flying when the secret IBM crew arrived. But he wasn't doing laps for fun. Kildall had been an airplane enthusiast going way back. At this point, he had been a licensed pilot for years. He wasn't out for a joyride, he was on a business trip. DRI's office at the time was located in Santa Clara, just south of San Francisco. That part of the world has always had pretty congested roads, so flying was just a faster way for Kildall to get around and visit

a client. If you look a little further, then Kildall's recollection starts to contradict Sam's account at every point. According to Gary, he showed up late for the meeting with IBM, but he did show up. What's more, Kildall claims that he actually signed on the NDA and got as far as talking business with IBM. But this gets even further from the IBM line. Kildall goes on to recall that Sams and his crew left with the CPM deal basically in the bag. All was well with DRI, and with a major contract closed, there was reason to celebrate. Now, we get to play number two in Gary's story. Apparently, IBM had arrived just in the nick of time. The Kildalls were about to leave for a Caribbean vacation.

The very same day, probably a matter of hours after Sam's left the office, Gary and Dorothy headed to the airport to catch a flight out to Miami. In a strange twist of luck, one of the members from that IBM delegation was on the same flight. They were heading back to their office in Boca Raton, Florida. So, the conversation about CPM and the PC continued throughout the five-hour flight. Gary must have gotten off the plane in high spirits. CPM was about to get on the biggest platform of the decade. But even better, Kildall was going to be part of the next big step in personal computing. He was seeing his dream of a practical microcomputer come true, and he was becoming an important gear in that machine. But it wasn't to be. Even in Kildall's telling of events, the deal falls through. After a few weeks on the Caribbean retreat,

Dorothy and Gary returned to the DRI offices in Santa Clara. Eager to get to work, Kildall tried to call up Sams over at IBM, but he couldn't get a hold of him. No matter what Kildall tried, he just couldn't get in touch. And it wouldn't be long until the news was out that IBM had partnered with Microsoft. The PC would ship with this new thing called MS-DOS, and CPM would become a thing of the past. That does it for our look into CPM and Gary Kildall. Early on in his career, Kildall became enamored with the idea of a personal computer. Through tireless work and a good deal of trickery, he was able to help the field advance considerably. CPM was the first operating

system to run on early microcomputers, and for a good deal of time, it was the best option out there. If you wanted to get any serious work done at home, you needed a computer. But to get the most out of that hardware, you needed CPM. With IBM's development of the PC drawing to a close, CPM was positioned to get even bigger. But at the last juncture, something went wrong. So what about the legend? Did Kildall fly away his best business opportunities? Definitely not. The actual event has conflicting stories.

Sam's and Kildall both give almost entirely different accounts of how the IBM deal fell apart. But the broad strokes are pretty clear. IBM was a big company, and they were used to getting what they wanted. When they ran into even a little bit of resistance from DRI, they just lost interest. Gates had said yes to everything IBM wanted, so they took their business back to Microsoft. But how did the rest of that business go? In 1980, Microsoft didn't have a sellable operating system. In fact, they didn't even have one in development. So how did the PC ship with MS-DOS just a year later?

Next episode, we'll be looking at the other side of the story. We're going to take a dive into DOS, how Microsoft closed the biggest deal in their history up to that point, and get into the complicated story of how Bill Gates set the land speed record for turning around someone else's software. If you want to learn more about this whole story, then I have some great sources you can check out. The first, and what proved to be the most important to me, is a bit of a strange one. Kildall actually wrote an autobiography. Or at least a lot of one. It was never completed and

never published, but you can find a good chunk of the text online. It's a little rough around the edges, but it's a wonderful primary source. The book is called Computer Connections. The Computer History Museum has a great article covering it with a link to the text. The other major sources I used were Hard Drive by James Wallace and the PBS documentary Triumph of the Nerds. Both do a great job of recounting the PC deal from the IBM and Microsoft sides. Thanks for listening to Advent of Computing. I'll be back in two weeks time with another piece of the story of computer. Next time, we're getting deep into DOS. And hey, if you like the show, then there are now a few ways you can support it. If you know someone else

who would like the show, then why not take a minute to share it with them? You can also rate and review the podcast on Apple Podcasts. And if you want to be a superfan, then you can now support the show through Advent of Computing merch or signing up as a patron on Patreon. For as little as $1 a month, you get access to early episodes, polls for the direction of the show, and other assorted perks. You can find links to everything on my website, adventofcomputing.com. If you have any comments or suggestions for a future episode, then go ahead and shoot me a tweet. I'm at adventofcomp on Twitter. And as always, have a great rest of your day.