BASIC

10 PRINT is a computer program that operates in a particular way; it does so, in part, because it is written in a particular programming language, BASIC. This "Beginner's All-purpose Symbolic Instruction Code" has an interesting cultural and technical history. BASIC was developed by John Kemeny and Thomas Kurtz, two professors at Dartmouth College; it became operational in 1964 and was freely shared by its creators, leading to its widespread use in education, at the high school as well as college level. By that time, general-purpose computers had been programmed for about two decades and high-level languages had been in widespread use for a decade. While BASIC has important, distinguishing features, it also continues the history of high-level languages, building on what FORTRAN, Algol, and other languages accomplished.

BASIC's invention in an educational context is significant. The language was developed for an important early time-sharing environment, the Dartmouth Time-Sharing System. This sort of setup was revolutionary in allowing many programmers to use a single system interactively at the same time. The configuration of such a system, with many terminals connected to a mainframe or minicomputer, was very different from that of the personally owned, relatively inexpensive, single-user computers of the microcomputer era. It was also very different from the batch processing of stacks of punched cards, though. Time-sharing allowed people to engage with and explore computation in significant new ways; BASIC was an important part of this computing revolution.

The story of BASIC became even more interesting as microcomputers came to market and into people's homes. In 1975, the MITS Altair 8800 computer, widely acclaimed as the first home computer, became available. Perhaps the most significant piece of software for this system was Altair BASIC, an interpreter for the BASIC programming language that was the first product of a new company, Microsoft. The alternative Tiny BASIC, developed outside of corporate structures, exemplified the way that recreational programs such as 10 PRINT would be created and distributed. Thanks in large part to Microsoft, BASIC became the lingua franca of home computing. Microsoft's versions of the language were standard on many popular microcomputers and were provided in ROM so that the computer could be turned on and immediately programmed. BASIC reigned in the late 1970s and through the early 1980s, when 10 PRINT circulated on paper and was being keyed in by numerous users. It was obvious at the time that BASIC was the canonical language -- so obvious that some books of BASIC programs do not even find it necessary to mention "BASIC" on their cover.

Despite or because of its popularity, BASIC joins COBOL as one of the major whipping boys among programming languages. Inextricably associated with Microsoft and that bane of structured programmers, GOTO, the language is said to encourage the writing of spaghetti code, to be unbearably slow, and to be suitable only for children and amateurs. Yet many programmers in the early 21st century remember BASIC fondly. The language was a popular success, worked well for small programs that let people explore the possibilities of computing, and fostered creativity and innovation by new categories of computer users.

There is plenty of dispute about who the first computer programmer is, but many have awarded this designation to Ada Byron, Lady Lovelace. She was brought up by her mother and educated extensively in mathematics and logic so that she might avoid becoming a poet like her father, Lord Byron. (The struggle to keep computation apart from poetics and aesthetics, instead of allowing them to mingle, as they do in 10 PRINT, has a long history.) Her contributions as an early "programmer" are found in her translation of and notes to an Italian article about Charles Babbage's Analytical Engine by Louis Menebrea. In this work, completed in 1843, she envisioned the Analytical Engine as a general-purpose computer and described an algorithm that could be used to output Bernoulli numbers. Although the computer Lovelace programmed was never built, and there is evidence that the algorithm in question was originally written by Babbage, Lovelace's project was important to the modern idea of the computer program. This earliest concept of such a program was of an algorithm specified in mathematical notation.

The computer programs that followed in the electromechanical and early electronic age of computing were quite a bit less intelligible, with a much less direct relationship to familiar symbols. The ENIAC, a fully electronic computer which was built at the University of Pennsylvania from 1943 to 1945, was programmed initially by plugging in an elaborate set of cables. [http://www.columbia.edu/acis/history/eniac.html] To run particular calculations, constants were then set using dials. The next step in programming was the use of machine language. A program in machine language is simply a sequence of numbers. On the ENIAC, these were decimal (base 10) numbers, but different bases were used on other significant early systems. The EDVAC used binary; the ORDVAC, octal; and the BRLESC, sexadecimal. [Fifty years of Army computing by U.S. Army Research Laboratory, p. 62] In all of these cases, programmers needed to arduously determine the sequence of numbers that would constitute a program, writing something that did not look remotely human language at all. Each operation the computer was to perform corresponded to a number, while the operands, if there were any, were provided as similar numbers. For instance, to jump unconditionally to a particular absolute address, an opcode such as "76" (in base 10) is used, followed by two bytes specifying the address. In fact, this is the opcode used for an unconditional branch to an absolute address on the Commodore 64.

The first step toward more legible code was seen in the second generation programming languages, assembly languages. Assembly allows the use of mnemonics for operators such as LDA ("load accumulator"), JMP ("jump"), and INC ("increment memory") to stand in for the less easily read underlying numbers. On the Commodore 64, the letters JMP followed by an absolute address are converted by the assembler to "76" in a machine language program. The first assembler ran on Cambridge University's EDSAC, the first stored-program computer, in 1949. [http://liveforsinging.com/categoryA/language_history/assembly_language_history.html] Although cryptic compared to a high-level language such as BASIC, an assembler program is nevertheless much more comprehensible to a human than a machine language program is. While assembly is still used today in, for instance, programming firmware and in the demoscene, there are usually significant disadvantages to programming at this level. Programming in assembly highlights technical details of platforms and the transfer of values between memory locations and registers. Higher-level languages allow the programmer to concentrate on other matters, such as solving mathematical and scientific problems or mapping programs to business processes.

During the first decade of electronic computing, programming was still crawling toward the ideal of Lovelace's "programs" that specified algorithms in high-level, human-readable form. To reach a level of programming more appropriate for mathematical and scientific tasks, FORTRAN (Formula Translation) was specified in 1954 and first implemented in 1957. This language, and particularly the next version of it (FORTRAN II, which appeared in 1958), was a very strong influence on BASIC. Programming languages were developed for other purposes as well. To address business uses, COBOL was specified in 1959 and implemented in 1960. FORTRAN and COBOL both allowed for more intelligible code, improving on assembly, but both were also developed for the context of batch processing, for use with stacks of punched cards. Specifically, they were developed for what became known as simply "the IBM card," IBM's 1928 punched card that had 80 columns. (As explained in the chapter "Regularity," the Commodore 64's 80-column logical line, which appears as two 40-column lines on the screen, is one legacy of this early material medium for computing.) Programs written in early versions of COBOL and FORTRAN were specific to the punched card in certain ways: COBOL reserved columns 1-6 for the line number and column 7 for a continuation mark if the card's code ran on from the previous one. FORTRAN was similar, with columns 1-5 indicating the statement number. "Comments" (usually the program name) went in columns 73-80 in both languages; a "C" in the first column indicated that the whole FORTRAN card was to be considered a comment. Unless a programmer wrote a one-liner -- which in this case means writing a program that fits on a single card -- a COBOL or FORTRAN program would manifest itself as a stack, often a massive one, of punched cards. These had to be punched on a keypunch machine and fed into a card reader by an operator. Line numbers were of great importance in one particular situation: if someone dropped the stack of cards and they needed to be sorted into order.

The creators of BASIC were seeking to develop a programming language for the next computing revolution, one that would go beyond punched cards and batch processing to allow numerous users interactive access to a system simultaneously. This revolution was time-sharing.

To reach millions, Kemeny and Kurtz would clearly have to significantly lower the existing barriers to programming, barriers which were related not only to the nature of programming languages but to the material nature of programming. The two began development of DTSS, the Dartmouth Timesharing System, and with it the BASIC programming language. They considered developing a subset of FORTRAN or Algol, but found this unsuitable and instead set to work, with a team of undergraduates, at developing a new language (Masterminds of Programming p. 79). They saw the value of an interactive time-sharing system for allowing users to quickly correct minor errors rather than coming back 24 hours later with a new stack of punched cards for their next scheduled batch job. They also relaxed some of the specific requirements that were tied to using keypunch machines and cards. Kurtz told an interviewer, "we wanted ... to get away from the requirements that punched cards imposed on users, which was that things had to be on certain columns on the card." (Masterminds of Programming p. 81) Oddly enough, BASIC was so relaxed that spaces between tokens were optional in Dartmouth's versions of the language. Spaces were ignored, as Kurtz explains, because "some people, especially faculty members, couldn't type very well." (MoP p. 81) This aspect of Dartmouth BASIC was carried over onto the Commodore 64, as mentioned in the introduction.

While BASIC didn't require that programmers put things in certain columns, there was a requirement that something be put at the beginning of each line: a line number, such as "10." This facilitated branching, of course; the GOTO and GOSUB statements refer to the line numbers where program flow should continue. BASIC did not actually need line numbers for this purpose, however. Labels, such as those used in assembly, would have sufficed, and indeed they do suffice in later versions BASIC that do not use line numbers. The line number's real value is seen on a Teletype or other print terminal, or in any environment where full-screen editing is not an option. Line numbers made it easy in those cases to delete existing lines; simply type the line number without any further instructions, and the line disappears. To correct a single existing line, it's possible to simply retype the line with the same line number. To see what a particular line, say line 50, currently is, "LIST 50" will do the trick -- although if one had written the line recently, one could also look up to where the line had been printed out on the roll of paper.

While BASIC was a significant project at Dartmouth, it was only one part of the push to expand access to computing that resulted in DTSS, allowed sites all around the East Coast to connect to Dartmouth's computers, and fostered a more productive and creative relationship to computing. In his book 1972 ''Man and the Computer,'' Kemeny defends programming and playing games and other "recreational" uses of the computer as important, writing that such actrivities are relaxing and help people to overcome their fear of computers (p. 35). Kemeny also describes some of the context in which BASIC programming was done at Dartmouth: "The computation center is run in a manner analogous to Dartmouth's million-volume open-stack library. Just as any student may go in and browse the library or check out any book he wishes without asking for persmission or explaining why he wants that particular book, he may use the computation center without asking permission or explaining why he is running a particular program." (Man and the Computer p. 33) It was not only the BASIC programming language, but also the development of this permissive attitude toward computing that allowed for programs with no obvious military, business, or scientific purpose -- such as 10 PRINT -- to come about.

Of course, the origin of the Teletype in the United States is another important reason that the dollar sign was on Typetypes and was later used in computing and in BASIC. The original, North American Commodore 64 keyboard also sported a pound sterling sign (£), absent from other U.S. computers of the time. The seemed to be a clear indicator of Commodore's plans to sell the computer in the United Kingdom, although it had a precedent in Murray Code, which also features a pound sterling sign.

The computing revolution that followed time-sharing would change industry and reshape everyday interactions with computing. It was the beginning of the home computer or minicomputer era. The face that launched a thousand ships was a panel of switches and LEDs on the cover of the January 1975 ''Popular Electronics.'' The image was of the Altair 8800. This $395 machine ($495 assembled) was described consistently on the cover and throughout the magazine as a "minicomputer," rather than a "microcomputer." The article about this device also describes the many virtues of a useful computer for individuals and the headline of the editorial on page 4 clearly proclaims "THE HOME COMPUTER IS HERE!" ''Popular Electronics'' was hardly a novelty by the time this issue came out; the magazine was founded in 1954 by Ziff-Davis Publications and was a well-known, widely-distributed magazine by 1975. The year did mark an inflection point for home computing and for the magazine, which came to focus increasingly on computing. In November 1982, the magazine would be renamed ''Computers & Electronics.''

The two major successful efforts to develop a BASIC interpreter for the Altair are important and intriguing. While this tale of two BASICs doesn't clearly show the best of BASIC and the worst of BASIC, they do show two extremes in software development: one commercial, closely coordinated with hardware manufacturers, and highly tied to licensing and cost structures; the other community-based, non-profit, and "copyleft." The BASICs that led in these directions were Microsoft's Altair BASIC, the official BASIC for the platform, licensed to the manufacturer of the system, MITS; and Tiny BASIC, which originated at the People's Computer Company or PCC. The Commodore 64's BASIC is directly descended from Microsoft's Altair BASIC -- it is, although this is not visible on the startup screen, a Microsoft product. At the same time, the 10 PRINT program participated in a context of BASIC sharing and exploration that was strongly influenced by the People's Computer Company.

By 1975, Gates was at Harvard University and he and Allen were ready to envision a project with broader reach. They devised the idea of writing BASIC for the Altair and contacted Ed Roberts' company MITS to ask if they would be interested in a BASIC for their system. As they did in developing their Traf-O-Data system, they initially programmed on a university's computer system, using a simulator. What they were programming at this point was, of course, a modified and minimized version of the original 1964 BASIC. Given how often the success of personal computing software is attributed to entreprenurial and business advances and to Microsoft in particular, it's remarkable that Microsoft's first product was developed using Harvard's computer and was an implementation of Dartmouth's programming language.

Gates and Allen were successful in fitting their BASIC interpreter into an austere 4KB and leaving some room for a BASIC program. Allen flew to visit MITS in Albuquerque, taking the program on paper tape. The demo was a success and was licensed by MITS; Gates and Allen moved to New Mexico to create new versions of BASIC for the Altair and to maintain the original code.

Microsoft's Windows is one example of an (at least) two-sided platform. On one side, computers need an operating system and desktop environment to function. This leads hardware manufacturers such as Dell to purchase licenses to Windows and to include the software with their systems. On the other side, computers are only valuable if there are applications written for them. Microsoft writes some of the applications for Windows, but third-party developers write many. The abundance of software has a network effect that is positive for Microsoft: it encourages users to stay with Windows. And, since Windows is preinstalled on many computers, companies want to write applications for it.

Of course, Windows was not the first two-sided platform, nor even Microsoft's first. By retaining the rights to what IBM called PC-DOS, Microsoft had previously been able to license MS-DOS to other companies, much as they would later sell OEM copies of Windows to them. And before that, there are continuities with the company's first product line, Microsoft BASIC. BASIC was a programming language, not an operating system, but the presence of BASIC allowed for programs to be written on a computer and sometimes sold. There were two sides to BASIC: The computer companies, beginning with MITS, who wanted it on their machines and the computer hobbyists who wanted to write (and in many cases sell) BASIC programs. At Gates and Allen's company, the success of BASIC and the essential business plan used with that family of software products helped to develop the later success of MS-DOS and Windows.

The development of Tiny BASICs continued after this first version. The fourth Tiny BASIC was by Li-Chen Wang and was called Palo Alto Tiny BASIC. It, too, was published initially in ''Dr. Dobb's.'' The source listing for this BASIC interpreter began:

In his very popular book ''Hackers: Heroes of the Computer Revolution,'' Steven Levy describes the early history of home computing and the development of BASICs for the Altair and its immediate successors as a confrontation between an ethic of openness and the sort of corporate powers that were "a foe of the Hacker Ethic." (p. 227)

For one thing, neither Microsoft, Gates, or Allen is the party fingered in Levy's book as the "foe." That moniker is attached to Ed Roberts, the head of MITS, who was running a business with dozens of employees, many of whom would be around furiously working at any given hour to fulfill computer hobbyist's orders (and their dreams of computer ownership). "Micro-Soft" (the spelling had not been regularized by the time of the first letter) was at the beginning of 1976 simply two partners, both recent college drop-outs, one a teenager and other only slightly older. The company had hired other people, such as BASIC contributor Monte Davidoff, to work on projects, but it would not gets its first official employee until April 1976.

While many early books about BASIC are about pursuing hobbies (and games in particular), it would be remiss not to mention the types of books that help people organize their lives and keep their small businesses afloat. Charles D. Sternberg’s ''BASIC Computer Programs for the Home'' (1980) is one such book, whose specific aim was to satisfy “the practical requirements of the home.” The author wishes to address the user's desire not to “rely upon the availability of tape or disk-storage devices or any other features that may not be easily come by" and encourages the “modification of these programs to utilize features of your particular machine should present few difficulties." The author offers many reassurances of the ease with which programs can be entered, run, used, and even changed. Besides providing home financial programs, for example, and such “kitchen helpmates” as programs to convert recipe quantities, to plan meals according to various diets, to inventory the freezer’s contents, etc., this book provides descriptions of the purpose and functions of each program as well as some details about data entry, outputs, and other commentary. In the introduction the author explains that he eschews “highly efficient routines” in favor of increased “clarity” and a “modularity” which lends itself to easier alteration.

It is hard enough these days to remember programs being transmitted on physical media such as floppy disks and cassette tapes. The notion that programs would routinely be published in print and typed by users is even more alien, but we do have material evidence that programs were transmitted in this way, and people are still invited to key in code snippets of different sorts from books on programming.