Advent of Computing - Episode 37 - The Rise of DOS

Episode Date: August 23, 2020

Is there a more iconic duo than the IBM PC and MS-DOS? Microsoft's Disk Operating System would be the final success that turned the company into what we know today. But here's a dirty little secret: DOS didn't start out at Microsoft. So how did Gates and Allen get hold of a winning program? Today we look at how Tim Paterson, an engineer at a long forgotten company, created the first x86 computer and the original version of DOS. Important dates: 1979 - Tim Paterson builds first 8086 Computer 1980 - Microsoft licenses DOS from Seattle Computer Products 1981 - DOS ships with the IBM PC 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

MS-DOS, or Microsoft's Disk Operating System, may be one of the company's more important and more long-lived products. First shipping alongside the IBM PC in 1981, DOS would solidify Microsoft's hold on the software market, and in doing so, open the door for the megacorporation that we know today. DOS powered the spread of the PC all the way up to the year 2000. The final version was actually bundled deep inside Windows ME. For countless people, DOS was their introduction to computing. Sure, a consumer was buying an IBM or a Compaq, but the hardware was really just a means to an end. Day to day, you saw DOS, not so much the computer tucked away at your desk. The software has become iconic, and rightly so, I think. It served a very specific purpose very well for a very long time. The flip side is that DOS also made Microsoft a whole lot of money. By the end

of the 1980s, the scrappy team that had formed around their Redmond office had transformed into a cadre of millionaires and a few billionaires. That transformation wouldn't have happened without DOS, and without the doors that that software opened for the company. But I'm going to let you in on a dirty little secret. Microsoft didn't actually create DOS. Instead, they acquired it for around $75,000. The original software was written by Tim Patterson, a programmer at the little-known Seattle Computer Products. That return on investment is, frankly, insane. But however good that deal was, it should seem pretty strange.

Microsoft's a software company, it's right there in the name. So why were they driven to outside sources for one of their biggest and most important products? It turns out that this is just one more bizarre story that was instigated by the birth of the IBM PC. Welcome back to Advent of Computing. I'm your host, Sean Haas, and this is episode 37, The Rise of DOS. Now, last episode, we looked at CPM, its creation and rise to prominence, as we approached a critical event. That event being IBM's hunt for software to ship with their upcoming PC. When it came to picking an operating system, IBM really wanted to use CPM. But through a series of mistakes and miscommunications, that deal didn't work out.

Today we're going to look at the Microsoft side of the story, and follow the path to the birth of Microsoft DOS. Well, maybe a better term is actually rebirth. You see, DOS did not come out of Microsoft. It came from a much less well-known company, but crunched for time and willing to do just about anything to please IBM, Bill Gates would go to some pretty drastic measures. In the end, Microsoft got the contract they wanted, and DOS would ship with the IBM PC. But the path it took to get there is a pretty

strange one. So let's dive into the story of DOS and see how IBM ended up almost getting everything they ever wanted. Ostensibly, this is a Microsoft episode. However, it doesn't start at Microsoft. The story starts in the mid-70s with Tim Patterson. Now, last episode I spent a lot of words explaining how folk in the computer industry either specialize in hardware or software development. And they work pretty hard to stay in their lanes. Well, Patterson is the exception that proves the rule. Patterson's father was an electrical engineer, so throughout his childhood he had a healthy exposure to the hardware side of life.

But when it came to an education, he ended up taking a complementary path, enrolling in the computer science program at the University of Washington in 1974. Already, we can see a kind of strange connection growing here. Gary Kildall, the programmer behind CPM, graduated from the PhD program at the same school just a few years earlier. While Patterson was only in undergraduate studies, I think it's pretty likely that the two had some of the same professors and probably took some of the same classes in the same classrooms.

This mix of early exposure to hardware and more formal education in software development gave Patterson a very well-rounded skill set. It's one that's rarely seen in the industry, even today. After graduation, Patterson was hired as an engineer for Seattle Computer Products, a pretty small company operating just outside of Seattle. SCP was this strange type of company that we don't really see anymore. They were a small-time computer hardware manufacturer. At this point in development, computers weren't really built on assembly lines, at least not microcomputers.

This made the barrier for getting into the hardware industry pretty low. Companies like SCP could run a pretty simple operation without much upfront cost. Design was all done in-house. Circuit boards were etched in-house. And assembly was done in-house. In the coming decades, everything about computer manufacturing would be outsourced, but for a while, it was viable to just have an office full of terminals and soldering irons and just churn out some new computers. Getting more specific, SCP dealt in expansion boards for S-100 bus computers. Now, this is where we get into some interesting territory.

S100 was an early bus standard that was used in home computers, essentially an outgrowth of the Altair 8800's design. One of the keys to the Altair's success was that it was expandable, but that expansion capability was built in, well, kind of the most simple, ham-fisted way possible. was built in, well, kind of the most simple, ham-fisted way possible. Internally, the Altair was built around a backplane, a long circuit board studded with 100-pin connectors. Each connector just wired each pin up to the other one. So pin 1 on connector 1 was hooked into pin 1 on connector 2 and on down the line.

The actual guts of the computer were held on cards that plugged into this backplane. You got your CPU card that held the processor, a memory card, and then various interface cards. It's a pretty simple design, but it means that for a savvy hardware designer, adding functionality to the Altair was really easy. And those savvy hardware designers really liked the 100-pin bus, so much so that it started to appear in other computers. After a while, it became a standard across a multitude of systems, both hobby and commercial. This was possibly one of the first examples of a standard in home computing in any sense. And companies like SCP were pretty quick to pick up on this. like SCP were pretty quick to pick up on this. By designing S-100 bus compatible expansion cards,

SCP was able to market the same hardware to a lot of different computers. It's a pretty efficient business model, one that Patterson was evidently eager to be part of. But the fact was that SCP was a very small firm, and like so many similar companies, they were prepared to follow whatever leads came across the desk. So while Patterson did work on S-100 bus cards, he also got pulled into some contract-based projects. One of those was, strangely enough, a little something that I mentioned last episode, and honestly, I'm starting to think there might be some kind of conspiracy around it. there might be some kind of conspiracy around it. Now, the next series of events is a little confusing. Sometime in either late 1979 or early 1980, Microsoft came knocking at SCP. It seems that Bill Gates and Paul Allen had a bit of a hardware problem on their hands. They wanted SCP to develop a new expansion card for the Apple II, one that would add an entire Z80 processor to the computer. This product would eventually be called the SoftCard, and it made it possible to

run CPM and Microsoft Basic on Apple's flagship computer. But here's where things get a little bit dubious. The confusion comes down to Microsoft's intent, and a little bit of the timeline, but we'll get into that later. According to Fire in the Valley by Paul Friedberg, Gates wanted to get Microsoft BASIC running on one of the bigger platforms of the era, either the Apple II, the Tandy TRS-80, or the Commodore PET. Their particular breed of BASIC was programmed to run on the Intel 8080 processor. But two of the three computers in the market, the Apple II and the PET, used a MOS6502. This meant that BASIC would have to be rewritten to work on those platforms. According to the book Fire in the Valley, the reason for the softcard was that Gates didn't want to bother porting BASIC to the 6502. But I'm pretty sure that that's flat out wrong. Chronology matters a lot here.

In 1977, the Commodore PET released with a version of Microsoft BASIC. And then in the latter half of 1977, Apple and Microsoft were worked together to create an Apple II specific version of BASIC. By the time the softcard was being developed, there were already two versions of Microsoft BASIC. By the time the softcard was being developed, there were already two versions of Microsoft BASIC on the 6502. Most of Microsoft's catalog was written for Intel-like processors, so there was the draw from that. But Gates not wanting to port BASIC is a pretty weak argument. I have no idea why Freiberg says otherwise, and his book doesn't have sources listed, so I can't really hunt down where the story came from. Normally, I wouldn't really care about a mistake like this, but Fire in the Valley is cited by Wikipedia, and overall it's a pretty good read. So I guess

what I'm getting at is just be careful out there, and make sure to double check your sources. Anyway, BASIC wasn't the main draw for the softcard. The bigger reason for the softcard to exist was to get CPM running on the Apple II. For the time, CPM was the only serious operating system for serious computer users, and most of the big office software of the time was written for CPM. The sticking point was that CPM was made for the 8080 or Z80 processors. It flat out couldn't run on an Apple computer. At least not under normal circumstances.

Microsoft didn't have any experience with hardware development. They were a software house after all. So they brought the project to someone who did. SCP was already a player in the market for S100 expansion cards. So diversifying into the world of Apple expansion cards wasn't really that big of a leap. Once the project was at SCP, Tim Patterson was assigned to build the prototype for the softcard. This assignment would not only flex his skills, but it also gave him some crucial experience and connections for what was to come.

The softcard itself is pretty close to a single-board computer. Like I mentioned earlier, it was built around the Z80 processor, basically an improved version of Intel's 8080. It plugged into the Apple II's expansion bus, and from there it took control of most parts of the computer. It used the Apple II's pre-existing RAM, I.O. hardware, and power supply, but all the execution is offloaded to the new Z80. Hooked into a decked-out Apple II, the softcard could load up into CPM and run anything an Altair 8800 could.

Overall, it's a really cool piece of hardware. And in developing the softcard, Patterson was basically designing a whole new computer. Sure, it shared a lot of the hardware with the Apple II, but it wasn't exactly a plug-and-play kind of project. Once Patterson was done prototyping the board, Microsoft gathered up his designs, put on a little spit and polish, and by the summer of 1980, the soft card was shipping out to consumers. But the soft card wouldn't be Patterson's only project. And, well, this is where the timeline gets a little bit crossed. I was cagey about when the softcard project actually started, and that was because I haven't been able to find a definitive start date for that project at SCP,

just the Microsoft release date. Probably concurrent to the softcard project, or maybe just prior, Patterson got involved with a much more ambitious production. In 1978, the newest processor on the block was Intel's 8086. The chip would one day become the most popular computing platform in the world. It's usually just called the x86 platform in general. But in 1978, it was just the latest and greatest from Intel. It was a big upgrade over the 8080. It was faster, more sophisticated, and it was 16-bit.

In the summer of 78, Patterson was invited to a seminar at Intel, and he came face-to-face with their latest and greatest product. Up to this point, he had been working with Intel 8080s and Zilog Z80s, but quickly became a convert to the new 16-bit microprocessor world. When Patterson got back to his office at SCP, he set about convincing his co-workers that the 8086 was going to be the future, and that SCP really needed to hop on that wagon as soon as possible. At this point, the only computer using the 8086 was an Intel development system. For completeness sake, the Xerox Notetaker was finished in 78 and it used this processor, but that computer was really only ever seen within Xerox itself, so let's just not count that for

now. The 8086 was the latest and greatest chip around for the time, but it was still in the very early stages of its life. SCP had the chance to be the first company to offer a computer that was built around the chip. If executed correctly, that could be huge. But for Patterson, it sounded more like he just wanted to work with the new processor. The business aspect mattered less than the fun of blazing a new trail. And luckily, his boss at SCP, Rod Brock, was totally on board. So in short order, Patterson started development of the first x86 computer. Remember that SCP was all about expansion cards, and they were most experienced with S100 expansion cards. So then it should come as no surprise that Patterson chose to build his new computer on an S100 processor board. The design was smart for a lot of reasons.

It played into his experience and the manufacturing know-how at SCP. But at the time, it was pretty business savvy. By creating a processor card for a popular standard, this new system could be offered as an upgrade path. S100 computers already kept their processors relegated to an expansion card. So if you wanted to get up to speed with a new processor, a user would only have to swap out their old card for Patterson's new card. But just because it was a good idea doesn't mean it was fast or easy to develop. There were two big issues that Patterson faced. The first was that the S100 bus was designed for 8-bit processors. The 8086 was 16-bit, so it wanted to use a 16-bit bus to connect up memory and I.O. devices. If you want to get a

little nitpicky, the actual memory bus for the 8086 is 20 bits wide. But the point is, the S100 bus wasn't designed with these newer chips in mind. So Patterson had to find a way to fit a square peg into a pretty round hole. The finished board ended up being able to switch between 8 and 16-bit address modes during operation. This made it possible for Patterson to coerce an existing S100 computer to play nice with the 16-bit chip. Now, there are a lot of technical details, but that's the big one. He found a way to get a new technology operating on an aging platform. Prototyping was finished in May, and boards would start selling in November of 1979.

Now, this is where I get to my bit of speculation. Like I said earlier, the timeline in this period is a little bit dubious. The 8086 expansion card was more complicated than the soft card. That's pretty clear from schematics. So I'd wager that Patterson developed the soft card first, or at least developed the soft card before he finished the 8086 board. Conjecture aside, by the latter part of 1979, Patterson had made the first 8086 computer on the market, and SCP started selling boards. He had also completed a big contract for Microsoft. Now, I said there were two outstanding problems with the new 8086

computer, but I've only explained one so far. So what about problem number two? Sales for Patterson's new S100 board were pretty slow in the first few months after its release. It was the first x86 computer that money could buy, but not many people actually wanted to buy the thing. Like with a lot of new technology, the problem comes down to software. The 8086 was a really new chip at this point, so there just wasn't much code being written for the thing. A home computer user in 1980 could program just fine, and they could have made their own software for the chip, but that was a lot of work. Instead, you could just stay on your older 8-bit computer decked out with CPM, fancy text editors, compilers, and even games. There wasn't a real draw to upgrade, at least not yet.

SCP did have one killer app in the bag, and that was Microsoft Basic. A few months before the 8086 board went on sale, SCP started getting calls. They were the first to get a computer built around this new processor up and running, so software vendors were eager to get a slice of the action. Supposedly, DRI contacted the company to talk over a possible CPM port, but I've only seen scant mention of that. Another interested party was Microsoft, who was very eager to get a version of BASIC ported over to the new 8086 computer. At the time, any microcomputer worth its salt was running a version of Microsoft BASIC, so it made sense for SCP to pursue this opportunity.

In May of 79, Patterson grabbed a prototype board and headed over to Microsoft's office to help with the port. Specifically, Patterson and his new Microsoft friends were porting Disk Basic to the 8086. Following its MO in those days, Microsoft had already moved the bulk of BASIC to the new processor using an emulator, but getting it up and running on real hardware required just a little bit of extra work. Patterson's skill set and experience made him a huge asset for this project. This was the very same variety of BASIC that ran on the recently completed softcard, so Patterson was already pretty familiar with the software. That, and he was probably one of the few people outside Intel who was familiar with the 8086 processor. By the time SCP's computer went on sale, 86BASIC was ready to roll. It would be

the first commercial software written for the x86 platform. Now, there's something special about 86 Basic that I've been glossing over. Most 8-bit computers that ran Basic kept their code on a ROM chip inside the computer, but this newer Basic was a little bit different. 86 Basic came on a floppy disk, so a user had to actually put in the Basic disk and then load up the interpreter before they could get to work. This wasn't the first time Microsoft had packaged their interpreter on a disk. The softcard also used a similar build of Basic. But it has some interesting implications here. A ROM is just, well, a ROM. You load it up with binary data and when the computer turns on, it has your program already mapped into memory.

But a disk is a little bit different. You need a way of finding your program on the disk and then loading it up. You need some kind of system for storing files on the disk. To switch words around a bit, you need a file system. Microsoft already had a file system developed and in use at this point. It was called File Allocation Table, or just FAT. This was actually developed by Microsoft a few years prior, and it's pretty simple to work with.

At the start of the floppy disk, you have the File Allocation Table, which lists all the files on the disk and where their associated data is stored on that disk. Think of it like a table of contents, but each entry points to a tiny chunk of data instead of a page. The point here is that 86Basic already had some of the hallmarks of a full operating system like CPM. It had a way to manage a floppy disk, and during the porting process, Patterson would become familiar with FAT. For the first quarter after release, SCP managed to move a few of their boards. But even with 86 basic, it was still slow going. Sure, they had some software, but there

still wasn't enough to convince users to upgrade. There was some talk of CPM-86 on the horizon, but DRI had yet to deliver on that. After six or so months, Patterson got tired of waiting. So, he started scheming a plan of last resort. That plan would one day turn into DOS. As Patterson put it in a blog post, We knew digital research was working on a 16-bit OS, CPM86. At one point, we were expecting it to be available at the end of 1979. Had it made its debut at any time before DOS was working, the DOS project would have been dropped. SCP wanted to be a hardware company, not a software company. End quote.

Work on this new operating system started in early 1980. Patterson took to calling it Quick and Dirty Operating System, or QDOS, because, well, it had to be put together pretty quick. One of the cores of QDOS was compatibility with CPM. By having rough compatibility, it would be possible to port over existing CPM software, thus tapping into a ready-made catalog of popular programs. Of course, CPM and QDOS ran on different processors, but there was a rough kind of portability at play. While Intel's 8080 and 8086 processors weren't fully compatible,

it was possible to translate older 8-bit code to run on the newer 16-bit chip. So one of the first things that Patterson wrote to go with QDOS was a source code translator. That went a long way to making an upgrade path for existing computer users. But Patterson took it a step further. One of the features of CPM that made it a success was that it offered something called an Application Programming Interface, or API.

To make a pretty complex topic short, an API gives programmers a collection of functions to use. It saves a programmer from having to reinvent the wheel. In the case of CPM, these functions gave programmers an easy way to access the disk, print a screen, get keyboard input, and a host of other hardware controls. Implementation-wise, each of these CPM functions was accessed by a call number. For instance, if you wanted to get a character from a terminal keyboard, you'd just call up function 1. This made CPM a great platform for programmers. You didn't have to waste time writing

a bunch of code to handle simple tasks. This also meant that any program written for CPM was very dependent on these function calls. The only way to be compatible with CPM was to create something akin to this programming interface. But at the same time, CPM was nearing obsolescence. Patterson had to find a way to keep QDOS's programming interface somewhat compatible with CPM while not being held back by the older technology. The solution was pretty simple, but effective. Just make two different programming interfaces. One would be compatible with CPM,

and one would be totally new and take advantage of the 16-bit hardware. Armed with a copy of CPM's programming documents, Patterson set to work creating his lookalike interface, copying each function into QDOS. At the same time, he built up the more native interface. Now, these two parts of QDOS weren't really independent. They were running on the same computer, after all. One of the bigger bleed-over points was how data was handled. Some CPM functions send back data or accept data, and that's a little bit hard to

translate around. So a lot of the data structures in QDOS ended up being the same as their counterparts in CPM. Things like file descriptors were unchanged. That way, an older CPM program could speak the same language as the new interface with minimal changes. By August, Patterson's quick and dirty programming was all coming together. QDOS was running perfectly on his 8086 computer, and his translator was working pretty well too. Patterson even got some use out of the translator, quoting from his blog again, quote, I myself took advantage of the translation compatibility. The development tools I had written, such as the assembler, were originally 8-bit programs that ran under CPM. But not everything in QDOS was old news.

I already mentioned that Patterson constructed a second interface that was a little bit more 16-bit oriented. That was only part of the new system. The other big hit was the new file system, one called FATS-12. Patterson had already worked with Microsoft's earlier FAT file system, and he liked the rough idea. It was fast, simple, and it worked well for floppy disks. However, there was room for improvement. Now, if you'll excuse me for a second, I need to digress into just how floppy disks worked in this era. On a hardware level, a floppy disk is broken up into a series of clusters, each able to hold a small chunk of data. These clusters are each addressable, most commonly just by some incremental number. In a FAT-like file system, each file has a list of sectors that belong to it.

So to reconstruct it from disk, you just need to read those sectors into memory in the given order. Originally, FAT used 8-bit numbers to index clusters. Now, that's fine. It works well for 8-bit processors, and it doesn't take up much space on disk. However, an 8-bit number has an upper value of 255. So using FAT8, you can only have a disk with 255 clusters. And that's just not much space. But QDOS wasn't on an 8-bit platform, so it could stretch its legs, at least a little.

Patterson's FAT12 upped the descriptor size to, well, 12 bits wide. That meant that he could address up to 4096 clusters. That's a massive improvement. And this improvement was made possible since Patterson had left the realm of 8-bit behind. Once QDOS hit market, it was renamed as 86DOS, with the D changed from dirty to disk. I guess quick and dirty operating system wouldn't have really inspired confidence in customers. 86DOS was the first operating system to run on the x86 family of chips. SCP had beaten everyone to the punch. And even better, they offered a compelling upgrade path for existing computer users. Patterson's translator was a great idea.

In theory, 86 DOS had access to CPM's entire software catalog. SCP wasn't breaking new ground, not strictly speaking, but they were living on the exact cutting edge. This brings us comfortably back to the end of last episode. A team from IBM was trying to find an operating system to go along with their new x86-based personal computer. Specifically, they wanted the long-fabled CPM86. The first stop was Microsoft, but when they realized they couldn't license CPM from the Seattle-based company, Gates redirected them to Gary Kildall.

Through a series of miscommunications, fumblings, and non-disclosure agreements, IBM failed to work out a deal. Frustrated, the team went back to Microsoft to see if Gates could spin up a solution for them. But this led to a near-repeat of the first visit to Microsoft. And this is where the timeline starts to matter a whole lot once again. The PC was set to launch in August of 1981. IBM was a professional outfit, so the launch had to live up to their professional expectations. From release day, the PC had to have a software library. A user had to be able to buy the new computer and get it up

and running right away. And a new user should also be able to do anything that they could do on an older system on their brand new PC. Microsoft had already agreed to license BASIC to IBM, as well as a slate of other software. The pinnacle of this release day was going to be an operating system. But that's where the problems started. IBM didn't have time to finish the hardware side of the PC and make their own operating system. Gates would have loved to sell them a solution, but Microsoft didn't have an operating system of their own, and it would take longer than 12 months to write one from scratch. But there was a glimmer of hope, albeit from a strange direction.

one from scratch. But there was a glimmer of hope, albeit from a strange direction. Soon after Tim Patterson had completed 86DOS, SCP started shopping around their software. They were doing some direct-to-consumer sales and selling their new operating system bundled with their other hardware, but they wanted to expand their market. SCP was looking for manufacturers that would be interested in licensing out 86DOS, and they were also looking for software houses that would be interested in porting programs over to 86DOS. One of the stops on the licensing tour was none other than Microsoft. So while Gates didn't have his own software to sell, he knew where he could get some. 86DOS was a really good fit for the PC, and it also didn't hurt that it was the only option out there.

And as talks with IBM slowed, Gates brought up the possibility of 86-DOS, and it turned out that IBM really liked that idea. But there wasn't going to be another referral like with CPM. Jack Sams, an engineer from IBM, told Gates to handle getting the software himself. IBM had initially wanted to only deal with a single software supplier, so they didn't want to go to SCP directly. This was the kind of deal that Gates couldn't say no to. He agreed, and once IBM left, he set about the task of bringing 86-DOS into the Microsoft fold. Gates may have signed off on the deal, but he didn't approach SCP himself.

Pretty soon, Paul Allen would make his way down to the SCP office and negotiate a licensing agreement. Now, this is where we get back to the little issue of IBM's non-disclosure agreement. In order to talk business with IBM, Microsoft had to sign off on an NDA that, among other things, meant that Microsoft couldn't tell anyone outside about their dealings with IBM. So officially, Paul Allen wasn't looking for software on IBM's behalf. He was just shopping around. That gave Allen a little bit of extra leverage to help find a bargain. Negotiations were simple. SCP had been looking for a manufacturer to license 86-DOS-2. Alan came in saying that he had a manufacturer lined up.

But that manufacturer was only willing to deal through Microsoft. And no, they could not give the name of that manufacturer. A little strange, but not unheard of. Computer companies like their secrecy. No reason to ignore a good sale. So at the tail end of 1980, Allen secured a pretty good licensing agreement. Microsoft would only pay a one-time flat fee of $25,000. In exchange, they got non-exclusive rights to 86 DOS and, most importantly, its source code.

As Patterson put it, quote, We came to an agreement fairly easily. We even called digital research to see what they sold their stuff for. We got a feel for what the prices were like, end quote. In other words, both sides of the agreement may have had a slightly different level of experience and knowledge when it came to this deal. But just like that, 86 DOS became, well, a lot more complicated. The soon-to-be IBM version was initially known, 86 DOS became, well, a lot more complicated. The soon-to-be IBM version was initially known as PC DOS,

but it would later be remembered as Microsoft DOS. Why was IBM so keen to get their hands on 86 DOS for the PC anyway? Well, time was one factor, but there was another big reason. Remember that IBM really wanted CPM, and as Big Blue, they were used to getting whatever they wanted. 86DOS was a good replacement because it looked, felt, and most importantly, acted really close to CPM. IBM wanted to court first-time computer users, but they also needed to pull in existing computer enthusiasts and programmers. Anyone who'd used CPM would be instantly familiar with DOS,

and anyone who programmed for CPM could just as easily program for DOS. Sure, it wasn't 100% compatible, but it was close enough that the fine details weren't that important. 86 DOS let IBM get their way and tap into an existing market, but at the same time, it introduced a level of legacy code that would stay around for decades. But it wasn't just as simple as buying 86 DOS, putting a different label on it, and then slapping it on some disks. Even with a pre-built solution, Microsoft still had their work cut out for them. Even with a pre-built solution, Microsoft still had their work cut out for them. The fact was that SCP's 8086 computer was a little bit different than the IBM PC.

This is where we get into some more technical details. The PC actually runs using an 8088 processor. It's a really similar chip to the 8086, but there's one key difference. The 8088 uses an 8-bit data bus. Besides that, they're basically the same chip, but that small change has some big ramifications. IBM went with the 8-bit bus version for the same reason that they wanted CPM. There was already a lot of hardware built up for 8-bit computers, but not much on the 16-bit side of things. To the external hardware, the 8088 looked just like any other 8-bit microprocessor, even though it really wasn't all that 8-bit on the inside.

This choice made the PC less powerful than it otherwise could have been, but it saved IBM time and gave them a ready-made hardware market. Instead of developing new 16-bit graphics hardware or disk controllers, they could just reach for existing options. And just overall, in general, the PC hardware was a little bit different. Changes were needed for 86DOS to be happy on the new platform. This task fell to Bob O'Rear, a programmer working for Microsoft at the time. And Task may be a little bit of a misnomer. This was more of a challenge. As O'Rear put it, quote, From the summer of 1980 until the summer of 1981, I lived and breathed DOS. I didn't do anything

else. I didn't have a social life. I didn't have any kind of life at all. All I had was DOS. I didn't have any kind of life at all. All I had was DOS. End quote. Now, part of that massive challenge was that he had to port DOS in a pretty frustrating environment. The entire project was very tightly controlled by IBM. Big Blue didn't want a breath of the PC slipping out before release, so security measures were very tight. O'Rear had to work in a secure, windowless room, cramped and locked at all times. Cooling was a problem, and computers in the room would often overheat and need to be set out to cool down. Adding to the frustration was the fact that the IBM PC wasn't actually finished yet. O'Rear was working on prototypes, so there were still bugs in the

hardware that needed to be ironed out or worked around. So in addition to a bad working environment, O'Rear had to contend with unreliable and often changing hardware. The other big challenge was that O'Rear had to deal with IBM's PC BIOS. The idea of a basic input-output service wasn't exactly new. Gary Kildall had even created a similar system by the same name for CPM, but how the PC handled things was a little bit different. In CPM, the BIOS is a file on disk that was the first program loaded, but the PC has its own BIOS on a ROM chip on the motherboard. As soon as power is switched on, the BIOS loads up and starts running. The code handles loading an operating system from the disk drive, and gives programmers a low-level hardware interface. A big part of Arira's work was

making sure that DOS could play along with IBM's BIOS. And since 86DOS was developed without any analogous systems, this process would take some doing. Even with Paul Allen stepping in to help out, the conversion of 86DOS would take a lot of time and patience. That should already sound like a pretty complicated and hard project. But, oh, does it get worse. Microsoft kept IBM updated on their progress as much as possible. As anyone who works in the software industry knows, micromanagement can destroy projects and the sanity of programmers. IBM was very particular in how they wanted DOS to work, so they were quick

and eager in offering a little bit of, quote unquote, constructive feedback. With every new build of DOS that Microsoft sent over, IBM found something that needed changing or correcting. This forms a sort of feedback loop that a lot of us are familiar with. Once you complete any changes and send in a new build, you get a letter back with requests for new changes to be made. And with strict timetables, every change had to be a rush order. Microsoft couldn't afford to anger IBM. This all turned into a very painful process. And in this case, there was enough pain

to spread around. Alan and Arir had to get help to keep on a schedule. So they went to the only person familiar with 86 DOS. At the time, Patterson was still working at SCP, but the DOS crew enlisted him to help address IBM's growing mountains of critiques. And there were some pretty specific requests. Just one fun example that I think illustrates this. IBM wanted the command line prompt changed. 86-DOS showed the disk drive letter followed by a colon and then space for you to type in a command. But CPM used a greater than sign instead of a colon. IBM, they needed that fixed right away. They were probably still a little bit mad about the loss of CPM, so anything they could do to make it feel like they were getting that product was a good thing for them. Over the early half of 1981, Patterson would get roped into more and more

work by Allen and O'Rear, but he was working in the dark. IBM's non-disclosure agreement was still in full effect, so Patterson didn't know these changes were coming from IBM. He also didn't have access to the PC prototype that was locked up inside Microsoft's HQ. So he was working blind. While O'Rear and Allen were suffering in a hot room, Patterson was suffering in isolation. After a while, it seems that he got pretty sick of it all. In April of 1981, no doubt while talking over some new updates to DOS, April of 1981, no doubt while talking over some new updates to DOS, Patterson asked Paul Allen if there were any openings at Microsoft. Patterson had grown frustrated working at SCP. He felt boxed in. Even with the amount of energy he put into his work, there really was no way to move up in the company. At the time, SCP had just a handful of employees. The way Patterson saw it, SCP was doomed to slide into

irrelevance, while Microsoft was just starting its ascent. From Allen's perspective, there couldn't have been better news. Patterson could get a lot more work done if he had access to the actual hardware, and Microsoft needed all the extra help they could get. So in May, Patterson officially left SCP and joined the DOS team over at Microsoft. With Patterson now under the non-disclosure umbrella, work on MS-DOS could kick into high gear. Over the next month and some change, the three programmer crew completed the conversion, and IBM finally signed off on a release build. Microsoft cut it close. The 1.0 build was completed just a month before the PC was set to ship. But they made the deadline,

and this led to one final business decision. You see, DOS still technically belonged to Seattle Computer Products. This had worked out fine during the conversion phase of MS-DOS, but with the PC around the corner, things could get, well, a little bit tricky for Microsoft. Once it was out that this secret manufacturer that wanted 86-DOS was, in fact, IBM, there were a lot of things that could go wrong for the company. SCP may just cut out the middleman and start working with IBM directly. There could be lawsuits. Or, at best, some very uncomfortable conversations. The only way around all of this was if Microsoft could outright own DOS. So, at the end of July, Allen and Gates, with help from a lawyer, drafted up an offer. Before the month was out, SCP agreed to sell all of 86 DOS to Microsoft for the one-time sum of $50,000. SCP would get some kickbacks and

still retain a non-exclusive license to DOS and its source code. Essentially, this flipped the prior agreement on its head. Microsoft would be in a much better position once the PC came out. SCP jumped at the deal. After all, the programmer who ran 86DOS had just left, so they couldn't really support the product as well as they should be able to. DOS was now fully part of the Microsoft catalog. And less than a month after the sale went through, the world met the IBM PC, complete with MS-DOS. So, was this a shady business deal? Microsoft had the upper hand in all these negotiations. No one outside the company knew that they were working with IBM. Microsoft's agreement with IBM meant that royalties would come in for each copy of DOS shipped. Every PC sold would mean a steady stream of cash sent

back to Microsoft. On the other end of things, SCP got a grand total of $75,000, accounting for inflation that's just a little bit north of $200,000 today. Over the next few decades, that initial investment would turn Microsoft into the massive corporation that we know today, while SCP just faded into obscurity. Microsoft made the right decision at the right time. But was it underhanded? I mean, at least a little. But on the other hand, no one knew just how big the PC would be. No one could have predicted that the clone market would emerge. And no one could have seen how long DOS would last. Alright, that brings us to the end of this episode. MS-DOS started life outside Microsoft, custom-tailored for an x86 computer built before the PC.

It would only come into the Microsoft fold after the pressuring of IBM. But I think there's still one question that needs to be addressed. Was the rise of DOS really the downfall of CPM? It's tempting to say yes, but I think that's the less interesting answer. After DRI lost the opportunity to work with IBM, the fate of their 8-bit operating system was sealed. Gary Kildall would never get a chance that big again. A version of CPM would ship for the PC soon after launch, but it was too little too late. The damage was already done. So, was DOS the downfall of CPM as a product? Definitely. But in another way, it immortalized Kildall's earlier contributions. When Tim Patterson sat down to create QDOS,

one of his major goals was compatibility with CPM. And while QDOS wasn't strictly a clone of CPM, it did implement a lot of its features and overarching designs. After IBM's concerted meddling in development, the release build of PC-DOS took this to the next level. The software didn't just have a rough compatibility layer. It also looked and felt like CPM. Those core design decisions persisted even after DOS. We can see that DNA in something as far removed as the Windows command line prompt today. CPM died out, but its legacy was spread by DOS. And in a funny way, Kildall would get to see the full realization of his dream of a home computer. The combination of the IBM PC and DOS solidified the design for a personal system. Going forward, there was only one way to make a PC.

It had to have a microprocessor, a floppy drive, and a disk operating system to make the whole thing useful. The outline matches exactly with Kildall's original vision. Thanks for listening to Adren of Computing. I'll be back in two weeks weeks time with another piece of the story of computing's past. And hey, if you like the show, there's now a few ways

you can support it. If you know someone else who'd be interested in this history, then why not take a minute to share the show with them? You can also rate and review on Apple Podcasts. And if you want to be a super fan,

then you can support the show directly through Adren of Computing merch or signing up as a patron on Patreon. Patrons get early access to episodes, polls for the direction support the show directly through Advent of Computing merch or signing up as a patron on Patreon. Patrons get early access to 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 shoot me a tweet. I'm at Advent of Comp on Twitter. And as always, have a great rest of your day.