Altair 8800 — Volume 7 — Altair BASIC: Gates, Allen, and the Birth of Micro-Soft

About This Volume

Volume 5 showed how punishing the bare Altair was: no keyboard, no screen, no storage, no software — just sixteen switches and a wall of red lamps, and a program spelled into memory one hand-toggled byte at a time, evaporating the instant the power went off. Volume 6 began to lift that burden by bolting real machinery onto the bus: a serial interface board, an ASR-33 Teletype to give the machine a keyboard and a printer, and a paper-tape reader so that a program, once entered, could be punched onto a roll of paper and read back in without ever being toggled again. Those volumes are the prerequisites for this one. A Teletype and a paper-tape reader are what make it possible to load forty thousand bytes of software into an Altair in a few minutes. This volume is about the software that did exactly that — and about why it mattered far beyond the machine.

The story of Altair BASIC is one of the most consequential in the history of computing, and it is told here on three levels at once. On the first level it is a technical feat that still impresses: two young men wrote a complete, working BASIC interpreter for a microprocessor they had no access to, developing and testing it on a borrowed mainframe through a simulator of a computer that sat fifteen hundred miles away, and it ran correctly the first time it touched real hardware. On the second level it is the founding act of a company — “Micro-Soft,” hyphen and all, set up in Albuquerque in 1975 — that would, within two decades, become the most valuable software firm on earth. And on the third level it is the origin of an argument that the hobbyist culture of the mid-1970s had never had to have before: the argument, opened by Bill Gates’s furious “Open Letter to Hobbyists” in February 1976, over whether software was a thing you shared or a thing you bought. That argument runs straight into Volume 8 and the Homebrew Computer Club, the very people Gates was writing to. We begin where they began: with a magazine on a newsstand in the cold of a Cambridge winter.

Two readers of a magazine cover

In December 1974 and the first days of 1975, the January 1975 issue of Popular Electronics reached newsstands across the United States carrying the cover that Volumes 1 and 3 have already made famous: the blue-and-grey box of the MITS Altair 8800, billed as the “World’s First Minicomputer Kit to Rival Commercial Models,” available for under four hundred dollars. Two readers in Cambridge, Massachusetts, saw it and understood it differently from almost everyone else who picked it up.

Paul Allen, then twenty-two and working as a programmer at Honeywell, bought the issue at a newsstand in Harvard Square and carried it through the slush to the Harvard dormitory room of his friend Bill Gates, nineteen and a sophomore. The two had known each other since their teenage years at the Lakeside School in Seattle, where they had taught themselves to program on time-shared terminals and had already gone into business together once, with a traffic-data company called Traf-O-Data built around the Intel 8008 microprocessor. They knew microprocessors. And where most readers saw a hobbyist’s curiosity, Gates and Allen saw the thing they had been waiting for: a real, affordable computer built on a real microprocessor, the Intel 8080, which meant that the cheap personal machine they had long believed was coming had actually arrived. It also meant a problem and an opportunity in the same breath. The Altair, as Volume 5 made painfully clear, could do nothing out of the box but blink. What it needed — what would make it usable by ordinary people rather than only by those willing to toggle octal — was a programming language. And the obvious language for a beginner’s machine was BASIC, the friendly, English-like interpreted language that Gates and Allen had both grown up writing on minicomputers.

So they did something audacious. They telephoned MITS in Albuquerque, asked for its founder Ed Roberts, and told him they had a BASIC interpreter for the Altair that was nearly finished and that they would like to come and demonstrate it. This was, at the moment they said it, not true. They had no interpreter. They had not written a single line of it. They did not even own an Altair, and could not have bought one quickly if they had wanted to, given the months-long backlog MITS was buried under. What they had was the confidence that they could write it, and the shrewd understanding that Roberts — besieged by other people making the same claim — would give the deal to whoever actually showed up with working code first. Roberts, who had heard a great many promises, told them in effect to stop talking and bring it. He agreed to a demonstration a few weeks out, in the late winter of 1975. Gates and Allen now had to make the thing they had just claimed already existed.

Writing a program for a computer they had never seen

The central, almost unbelievable fact of Altair BASIC is that it was written for the 8080 without an 8080 — without, in fact, any Altair hardware at all. The machine the demo would run on lived in New Mexico. Gates and Allen were in Massachusetts, and they had roughly eight weeks. Their solution was the same trick that had served them at Traf-O-Data, scaled up: they would not write for the real processor; they would write for a software model of it.

Allen sat down at Harvard’s DEC PDP-10 — a large, time-shared mainframe in the university’s Aiken Computation Laboratory — and wrote a program that simulated the Intel 8080. He had done this once before, building an 8008 emulator for the Traf-O-Data business, and he adapted that experience to the newer, more capable 8080, working from Intel’s published programming manual and the documentation MITS supplied for the Altair. The simulator was a piece of software that pretended, on the big PDP-10, to be the little microprocessor in Albuquerque: it understood the 8080’s instruction set, kept a model of its registers and its sixty-four-kilobyte memory, and would obediently execute 8080 machine code one instruction at a time, exactly as the real chip would. On top of that Allen built development tools — an assembler and a loader environment — so that code written for the 8080 could be assembled, loaded into the simulated memory, and run, all on a mainframe that had never seen an Altair. It is the same idea that underlies every cross-development environment and every emulator since: when you cannot get at the target machine, you build a faithful model of it on a machine you can get at, and develop against the model.

With the simulator in place, the interpreter itself could be written, and here a third person enters the story whose contribution is often forgotten. The labour divided roughly three ways. Gates took on the core of the interpreter — the runtime, the part that actually evaluates a BASIC program: the code that parses a line, manages variables, and executes statements as the program runs. Allen wrote much of the surrounding non-runtime machinery that makes the interpreter a usable environment. And a third Harvard student, Monte Davidoff, supplied something neither of them initially planned to include. Davidoff, overhearing Gates and Allen debating how to handle numbers, argued that a serious BASIC needed proper floating-point arithmetic — the ability to handle fractions and very large and very small numbers — rather than only the whole-number integer math of the earliest sketches, and he insisted he could write a floating-point math package that would still squeeze into the tiny memory available. They hired him, and he wrote it. That math package, written by a college student in a few weeks, was good enough that versions of it would live on inside Microsoft’s BASIC products for years. The work was done at a sprint through the late winter and spring of 1975, in marathon sessions on the PDP-10, with the deadline of the Albuquerque demonstration bearing down the whole time.

The constraint that shaped every line was memory. The smallest, cheapest Altair worth buying had four kilobytes of RAM, and Gates and Allen were determined that their BASIC should run on such a machine and still leave room for a user’s program. Four kilobytes — 4,096 bytes — to hold an entire programming language and the program written in it is an almost cruel budget, and meeting it required relentless, ingenious compression of the code: hand-optimising the 8080 assembly, sharing routines, shaving bytes wherever a byte could be shaved. The discipline this imposed became part of the company’s character. The first version they aimed at the demo was the 4K BASIC; larger and more capable versions — 8K BASIC, with more features and Davidoff’s fuller math, and later Extended BASIC for machines with still more memory — followed once the smallest one had proved the concept.

The loader on the plane, and a demo that worked

When the time for the demonstration came, in the late winter of 1975, it was Allen who flew to Albuquerque while Gates stayed behind. The interpreter had been finished in a final overnight push; the working code was punched onto a roll of paper tape, the storage medium Volume 6 introduced, ready to be fed into the Altair’s tape reader. And then, on the airplane, Allen realised they had forgotten something fundamental.

They had built and tested the whole interpreter inside the comfort of the PDP-10 simulator, where loading a program into “memory” was something the development tools did for them automatically. Nobody had written the small piece of code that the real Altair would need in order to read the BASIC tape into its memory in the first place — a bootstrap loader, the few dozen bytes of 8080 machine code that, once toggled in by hand on the front panel, would drive the paper-tape reader and pull the rest of the program in. Without it, the tape was useless: there would be no way to get BASIC off the paper and into the machine. Allen recounts realising this somewhere over the descent into Albuquerque, taking out a pad of paper, and writing the loader by hand, in 8080 machine language, in the minutes before the plane touched down — the last and most nerve-wracking piece of the entire project, composed in the air.

At the MITS office the next day, with Ed Roberts and his chief engineer watching, Allen toggled his hand-written loader into the front panel of an assembled Altair — the switch-by-switch ritual of Volume 5 — set the paper tape running through the reader, and watched the lamps as BASIC clattered in. The interpreter started. It printed its prompt and asked, as the 8K version would, how much memory the machine had. Allen answered, and was given the BASIC ready prompt. He typed a first command — by the most-repeated account, the deliberately simple PRINT 2+2 — and the Teletype hammered back the answer: 4. It worked. Software written over eight weeks for a computer its authors had never touched, developed entirely against a simulation of that computer, ran correctly the very first time it met the real thing. Allen himself called it the best demo of his life, and was at least as astonished as Roberts that nothing went wrong.

That demonstration sealed a deal. On 22 July 1975, MITS signed a licensing contract for Altair BASIC with Gates and Allen: a payment at signing, a per-copy royalty on each version of BASIC sold, and — a detail that would matter enormously two years later — a cap of $180,000 on the total royalties, in exchange for which MITS received an exclusive worldwide license to the software for ten years and the right to sub-license it to others. MITS would market Altair BASIC as the language for its machine; Gates and Allen would supply and maintain the code. Allen, in fact, took a job as MITS’s Director of Software and moved to Albuquerque; Gates soon followed, and before long took a formal leave from Harvard — a leave that became permanent — to work on the software full time. They had turned a bluff on the telephone into a real product and a real contract in the space of about half a year.

Micro-Soft

The two needed a name for the partnership that now held the BASIC. Allen supplied it: Micro-Soft, a contraction of “microcomputer” and “software” — the software, that is, for the new class of micro-computers the Altair had inaugurated. The hyphenated form is genuine and not a later embellishment; “Micro-Soft” appears in the partners’ early correspondence of 1975, and the company itself dates its founding to 4 April 1975, in Albuquerque, the city where its first and only customer sat. The hyphen did not last: when the trade name was formally registered with the Secretary of State of New Mexico on 26 November 1976, it was registered as “Microsoft.” But for its first year the company that would one day put a computer on every desk wrote its own name with a dash in the middle.

For that first year and more, Micro-Soft and MITS were bound tightly together — too tightly, as it turned out. Micro-Soft had one product and essentially one customer; MITS had the language that made its machine usable and a contractual lock on it. But the interests of the two firms were not the same. Gates and Allen wanted Altair BASIC on as many machines as possible, including the flood of S-100 competitors and clones that Volume 9 will describe; MITS, naturally, wanted BASIC to be a reason to buy a MITS Altair rather than someone else’s box. The friction came to a head after MITS was acquired by a larger company, Pertec, at the end of 1976. Pertec, viewing BASIC as an asset it had bought along with MITS, was reluctant to let Gates and Allen license the interpreter freely to other manufacturers — precisely the “best efforts” to commercialise it that the original contract had required. The dispute went to binding arbitration, as the contract specified, and in September 1977 the arbitrator ruled in Micro-Soft’s favour: MITS could keep using BASIC on its own machines, but it lost the exclusive license, and Gates and Allen were free to license their software to anyone they pleased and to keep the royalties. It is hard to overstate how important that ruling was. It freed Microsoft from dependence on a single, failing hardware company and established the pattern that would make its fortune — software licensed across the whole industry, independent of any one maker’s hardware. Within two years the young company had left Albuquerque entirely, relocating on the first day of 1979 to the Seattle area its founders had come from.

Tapes that wanted to be copied

To understand the conflict that produced Gates’s famous letter, you have to understand the physical form in which Altair BASIC was sold, and how naturally that form lent itself to copying. BASIC came, like most Altair software of the era, as a roll of punched paper tape — the 4K version, the larger 8K version, and the still larger Extended BASIC, each a ribbon of paper perforated with the holes that encoded its bytes, to be fed through the Teletype’s reader and loaded by the bootstrap method described above. MITS priced them as real products — 8K BASIC listed around two hundred dollars on its own, the 4K version less and Extended more — but heavily discounted them, to as little as seventy-five dollars for 8K, for customers who also bought MITS memory and I/O boards, deliberately tying the software’s affordability to the purchase of MITS hardware.

Here was the difficulty. A paper tape is trivial to duplicate. Feed it through a Teletype’s paper-tape reader while a paper-tape punch runs in parallel, and out comes a perfect second copy, byte for byte, at the cost of a few cents of paper. There is no copy protection on a row of holes. And the early Altair owners were not, by and large, corporate purchasing departments; they were hobbyists — members of clubs like the Homebrew Computer Club of Volume 8 — for whom sharing was the entire ethos of the movement. They swapped schematics, traded subroutines, helped each other debug, and passed hardware tips around freely, in a gift culture inherited from ham radio and the university computer labs. To such a community, a paper tape that someone had bought was not obviously different from any other piece of knowledge to be shared, and the most-told origin story of the copying is emblematic: a tape of Altair BASIC, by one widely repeated account “liberated” from a MITS promotional event in mid-1975, was duplicated and handed around at a Homebrew meeting, and from there copied and re-copied until it had propagated through the hobbyist world far faster than MITS could sell it. By the end of 1975 the arithmetic had become stark. MITS was shipping something like a thousand Altairs a month, yet paid-for copies of BASIC were selling only in the low hundreds. The great majority of the people running Micro-Soft’s software had never paid Micro-Soft a cent for it.

An Open Letter to Hobbyists

Gates, twenty years old and watching his company’s only product spread for free, responded in the most direct way available to him: he wrote a letter and had it published where the people copying the tapes would read it. “An Open Letter to Hobbyists,” dated 3 February 1976, appeared first in the Homebrew Computer Club Newsletter and then in the MITS user publication Computer Notes in February 1976, and was sent on to other hobbyist magazines around the country. It is short, blunt, and — for the culture it was addressed to — incendiary.

Gates’s argument was an argument about labour and value. Good software, he wrote, takes serious professional effort, and that effort deserves payment; copying the tapes meant that the people who did the work were not being paid, which guaranteed that little good software would be written for these machines. The lines that detonated were these, addressed squarely at his readers:

“As the majority of hobbyists must be aware, most of you steal your software. Hardware must be paid for, but software is something to share. Who cares if the people who worked on it get paid?”

And the rhetorical question that became the letter’s thesis:

“Who can afford to do professional work for nothing?”

He backed the accusation with figures. The value of the computer time used to develop BASIC, he wrote, exceeded forty thousand dollars; and when he divided the royalties Micro-Soft had actually received by the hours he, Allen, and Davidoff had poured into the interpreter and its ongoing support, the rate came to less than two dollars an hour. He noted, pointedly, that by his estimate fewer than ten percent of the people running Altair BASIC had paid for it. The implication was clear and deliberately stinging: the hobbyists’ own much-celebrated ethic of sharing was, in this case, simply theft, and it was strangling the supply of the very software they wanted.

The reaction was loud and divided. Many hobbyists were affronted — both by being called thieves and by the underlying claim that software, the malleable stuff they had always traded as freely as conversation, was property to be bought rather than knowledge to be shared. Some disputed Gates’s framing directly, arguing that the price was too high, that MITS’s bundling games had muddied who owed what, or that copying a tape one could not otherwise afford deprived no one of anything physical. Others, including future founders of software businesses, found that the letter named a real problem they could not unsee. What is not in dispute is the letter’s historical weight. “An Open Letter to Hobbyists” is the moment the commercial software industry’s central premise — that a program is a product, with an owner, sold under a license, and not to be copied without paying — was stated out loud, in public, to the very community that had assumed the opposite. The argument it opened has never really closed; it runs forward through the entire history of software licensing, copy protection, shareware, free and open-source software, and software piracy, all of which are in some sense replies to the question a twenty-year-old posed in February 1976. And it sets the stage directly for Volume 8, because the people Gates was lecturing were the Homebrew Computer Club, whose freewheeling, share-everything culture is the subject of that volume — and whose collision with Gates’s letter is one of the defining tensions of the early personal-computer age.

Why this mattered

Step back from the dates and the contracts and the quarrel, and three things make this volume a hinge in the whole series.

The first is what BASIC did to the Altair. Volume 5 left the machine as a thing you commanded one bit at a time, in octal, through a wall of switches — magnificent, but usable only by people willing to think like the processor. Altair BASIC changed that completely. With the interpreter loaded, you no longer toggled opcodes; you typed, in something close to English — PRINT, FOR, GOTO, IF ... THEN — and the machine understood you. The front panel and the paper-tape loader of Volumes 5 and 6 still got you in the door, but once BASIC was running, the Altair became a computer you could converse with and write real programs on without first mastering machine code. That transformation — from an engineer’s toggle box into something a curious teenager could sit down and use — did more than anything to turn the Altair from a kit for hardware obsessives into the seed of a mass medium. The software, as much as the hardware, is what made the personal computer personal.

The second is the demonstration of a new kind of company. Gates and Allen owned no factory, no chips, no boards, and sold no hardware. Their entire asset was code — a few tens of kilobytes of cleverly compressed 8080 instructions — licensed to whoever made the machines. In 1975 that was a strange and almost untested idea; the money in computing had always been in iron. The 1977 arbitration victory over MITS, by freeing that code from any single manufacturer, proved the model could stand on its own, and Microsoft became the template for an industry of firms that made nothing you could hold and grew larger than the hardware companies they supplied. The little hyphenated partnership in Albuquerque is where that template was cut.

The third is the argument the tapes provoked. The very ease of copying a paper tape — the openness the hobbyist culture treasured — collided, in Altair BASIC, with the first serious commercial software written for a personal computer, forcing into the open a question the field had never had to answer: is software a gift or a good? Gates’s letter answered “a good,” loudly, and built a company and eventually an industry on that answer. The hobbyists who answered “a gift” did not vanish; their conviction flowed into the free-software and open-source movements that would one day power most of the internet. Both answers were born in the same months, out of the same rolls of punched paper, around the same blue machine. By being a computer ordinary people could finally talk to — and by being run on software those people could finally copy — the Altair did not only start the personal-computer industry; it started the arguments the industry has been having ever since.

Sources

• Fire in the Valley: The Making of the Personal Computer (Freiberger and Swaine). The standard narrative history of this period; the source for Gates and Allen seeing the January 1975 Popular Electronics Altair cover in Cambridge, telephoning Ed Roberts to claim a nearly-finished BASIC they had not yet written, developing the interpreter on Harvard’s PDP-10 against Allen’s 8080 simulator, the Albuquerque demonstration, and the founding of Micro-Soft. https://en.wikipedia.org/wiki/Fire_in_the_Valley_(book)
• Paul Allen, Idea Man: A Memoir by the Cofounder of Microsoft (2011). Allen’s first-person account, used here for the detail that he wrote the paper-tape bootstrap loader by hand in 8080 machine language on the airplane during final approach to Albuquerque, having realised the team had never written one because all development had been done inside the PDP-10 simulator; and for the demo itself running correctly the first time on real hardware. https://en.wikipedia.org/wiki/Idea_Man
• Wikipedia, “Altair BASIC.” Confirms: Gates and Allen read of the Altair in the January 1975 Popular Electronics and contacted MITS, with Roberts agreeing to a demonstration in (about) March 1975; Allen adapted an earlier Intel 8008 emulator (from the Traf-O-Data venture) into an 8080 development environment on a PDP-10; the interpreter was developed and tested on Harvard’s PDP-10 without any Altair hardware; Monte Davidoff was hired to write the floating-point math package after arguing the language needed floating-point rather than integer arithmetic; and 4K, 8K, and Extended versions were distributed on paper tape (and cassette). https://en.wikipedia.org/wiki/Altair_BASIC
• Wikipedia, “An Open Letter to Hobbyists.” Source for the letter’s date (3 February 1976), its publication in the Homebrew Computer Club Newsletter and in Computer Notes (February 1976) and onward to other publications, and the copying statistics — by the end of 1975 MITS was shipping roughly a thousand Altairs a month while paid copies of BASIC sold only in the low hundreds. The quoted passages (“most of you steal your software… Who cares if the people who worked on it get paid?” and “Who can afford to do professional work for nothing?”) and the figures Gates cited (computer time exceeding $40,000; royalties working out to less than $2 an hour) are drawn from the letter as reproduced and described there. https://en.wikipedia.org/wiki/An_Open_Letter_to_Hobbyists
• Wikipedia, “Micro Instrumentation and Telemetry Systems” (MITS) and “History of Microsoft.” Source for the MITS licensing contract signed 22 July 1975 (payment at signing, per-copy royalty, a $180,000 cap, a ten-year exclusive worldwide license with sub-licensing rights and a “best efforts” obligation); for the name “Micro-Soft” as Allen’s portmanteau of “microcomputer” and “software,” the company’s 4 April 1975 founding date in Albuquerque, and the dropping of the hyphen when “Microsoft” was registered with the New Mexico Secretary of State on 26 November 1976; and for the Pertec acquisition of MITS (late 1976) and the September 1977 binding-arbitration ruling that ended MITS’s exclusive license and freed Microsoft to license BASIC to anyone. https://en.wikipedia.org/wiki/History_of_Microsoft · https://en.wikipedia.org/wiki/Micro_Instrumentation_and_Telemetry_Systems
• Computer History Museum and Microsoft official history materials, for corroboration of the development timeline (a roughly eight-week sprint in early 1975), the division of labour (Gates on the runtime, Allen on the surrounding tooling, Davidoff on floating-point math), and the 4K/8K/Extended product line. https://computerhistory.org/blog/microsoft-basic-the-story-of-microsoft-altair-basic/
• Figure: “Altair BASIC Paper Tape” by Michael Holley (Swtpc6800), public domain, via Wikimedia Commons — an original MITS 8K Altair BASIC paper tape labelled “BASIC 8K without cassette,” dated 2 July 1975, on display at the New Mexico Museum of Natural History and Science. Used to illustrate the physical form of the first Microsoft product and the ease with which a punched tape could be duplicated. https://commons.wikimedia.org/wiki/File:Altair_BASIC_Paper_Tape.jpg
• Figure: “DEC PDP-10 (DECsystem 10) mainframe computer system at Living Computer Museum” by Joe Mabel, CC BY-SA 3.0, via Wikimedia Commons — a restored PDP-10, the class of time-shared mainframe on which Altair BASIC was written and tested through Allen’s 8080 simulator. https://commons.wikimedia.org/wiki/File:DEC_PDP-10_(DECsystem_10)_mainframe_computer_system_at_Living_Computer_Museum_(strongly_edited_image).jpg