Notes for Montfort et al. 10 PRINT CHR$(205.5*RND(1)); : GOTO 10

Key concepts: assembly language, code, critical code studies, demoscene, generate and test, graphic logic, hermeneutic probes, imperative programming language, machine language, maze, randomness, opcode, operand, platform studies, popular programming, software studies, weird languages.

Related theorists: Bob Albrecht, Paul Allen, Dennis Allison, Charles Babbage, Paul Baran, Roger Caillois, Edsger Dijkstra, George Dyson, Galloway, Bill Gates, Karl Gerstner, Kenneth Iverson, John Kemeny, Kittler, Thomas Kurtz, Ada Lovelace, Thomas Malaby, Louis Menabrea, Claude Shannon, Richard Stallman.

Whether intended or not, these first chapters are not valid lines of program code that way 15 REM is, though 10 is correct binary designation of second section: compare to design of various Derrida works.



Asserts value of engaging in working code/software from earlier eras like the Commodore 64 personal computer of the 1980s as I do for pinball platforms, alluding to its coextensivity with engagement in state of the art working code/software such as pmrek; close reading of single line of code complements digital humanities trends like distant reading and cultural analytics.

(3) Like a diary from the forgotten past, computer code is embedded with stories of a program's making, its purpose, its assumptions, and more. Every symbol within a program can help to illuminate these stories and open historical and critical lines of inquiry. . . . The source code of contemporary software is a point of entry in these fields into much larger discussions about technology and culture. It is quite possible, however, that the code with the most potential to incite critical interest from programmers, students, and scholars is that from earlier eras.


Studies of individual works abound in the humanities; try close study of one-line BASIC program as cultural artifact.

(4) Studies of individual, unique works abound in the humanities. . . . While such literary texts, paintings, and consumer electronics may seem significantly more complex than a one-line BASIC program, undertaking a close study of 10 PRINT as a cultural artifact can be as fruitful as close readings of other telling cultural artifacts have been.

Close study of single line of code opposes current digital humanities trends focusing on big data.

(4) In many way, this extremely intense consideration of a single line of code stands opposed to current trends in the digital humanities, which have been dominated by what has been variously called distant reading (Moretti 2007), cultural analytics (Manovich 2009), or culturomics (Michel et al. 2010).

Critical focus on single line of code highlights multiple extant versions for learning, modification, extension; compare to how a single line from a poem inspires volumes of literary and philosophical work, such as Holderlin for Heidegger.

(5) Focusing on a particular single-line program foregrounds aspects of computer programs that humanistic inquiry has overlooked. Specifically, the one-line program highlights that computer programs typically exist in different versions that serve for learning, modification, and extension.
(5) The book also considers how the program engages with the cultural imagination of the maze, provides a history of regular repetition and randomness in computing, tells the story of the BASIC programming language, and reflects on the specific design of the Commodore 64.


Programming should be part of humanities scholarship, although this focus on code retains reader spectator position where its critics have not been missed that it befits one to become like the dead.

(5) First, to understand code in a critical, humanistic way, the practice of scholarship should include programming: modifications, variations, elaborations, and ports of the original program, for instance.

Component disciplines to critical programming are CCS, to which this work claims allegiance and gives good description, SS and PS.

Book format uses annoying side sections that replaces a footnote and glossary.

(6-7) [blue print section CRITICAL CODE STUDIES, SOFTWARE STUDIES, PLATFORM STUDIES]. CCS is a set of methodologies for the exegesis of code. Working together with platform studies, software studies, and media archeology and forensics, critical code studies uses the source code as a means of entering into discussion about the technological objects in its fullest context. CCS considers authorship, design process, function, funding, circulation of the code, programming languages and paradigms, and coding conventions.
(7) [blue print section CRITICAL CODE STUDIES, SOFTWARE STUDIES, PLATFORM STUDIES]. While software studies can include the consideration and reading of code, it generally emphasizes the investigation of processes, focusing on function, form, and cultural context at a higher level of abstraction than any particular code. Platform studies conversely focuses on the lower computational levels, the platforms (hardware systems, operating system, virtual machines) on which code runs.

Recognize relationship between formal workings of code and cultural implications, both in design as emphasized by Golumbia and Rosenberg, and reception; compare to cultural circuit.

(6) Second, there is a fundamental relationship between the formal workings of code and the cultural implications and reception of that code.

Code treated as Berry does source code distinguished from software; epistemological transparency of code due to its ultimate materiality, same as for protocol?

(7) Third, code is ultimately understandable. Programs cause a computer to operate in a particular way, and there is some reason for this operation that is grounded in the design and material reality of the computer, the programming language, and the particular program.

Code as cultural resource, text with machine and human meanings.

(8) Finally, code is a cultural resource, not trivial and only instrumental, but bound up in social change, aesthetic projects, and the relationship of people to computers. Instead of being dismissed as cryptic and irrelevant to human concerns such as art and user experience, code should be valued as text with machine and human meanings, something produced and operating within culture.

10 PRINT CHR$(205.5*RND(1)); : GOTO 10

Goes through the line of code a single token at a time.

(8) Before going through different perspectives on this program, it is useful to consider not only the output but also the specifics of the code—what exactly it is, a single token at at time.

(9) For a one-line program that loops forever, it is perhaps appealing to number that line 8, the endlessly looping shape of an infinity symbol turned upon its side.

Interactive editing abilities based on line numbers characteristic of BASIC from Dartmouth TSS onward: deliberate interactive affordance as well as organizational scheme.

(10) The interactive editing abilities that were based on line numbers were well represented even in very early versions of BASIC, including the first version of the BASIC that ran on the Dartmouth Time-Sharing System. Line numbers thus represent not just an organizational scheme, but also an interactive affordance developed in a particular context.


Use of spaces and canonical keywords facilitates human reading and modification, acknowledging that code is more than fodder for machine translation.

(10) Spaces acknowledge that the code is both something to be automatically translated to machine instructions and something to be read, understood, and potentially modified and built upon by human programmers. The same acknowledgment is seen in the way that the keywords are presented in their canonical form.


Keyword PRINT skeumorph of early scrolling paper print output.

(11) Video displays replaced scrolls of paper with printed output, but they keyword PRINT remained.


Character graphics a textual system built on top of bitmapped graphic display.

(12) Character graphics exist as special tiles that are more graphical than typographical, more like elements of a mosaic than like pieces of type to be composed on a press. . . . But these special tiles do exist in a typographical framework: a textual system, built on top of a bitmapped graphic display, is reused for graphical purposes.



Commodore BASIC does all math in floating point numbers, whereas other languages fundamental numeric data structure is integer.

(12) All math in Commodore BASIC is done on floating point numbers (numbers with decimal places).


Curious that typographical symbols borrowed from textual uses as mathematical symbols for various arithmetic operations.

(13) Given the computer's development as a machine for the manipulation of numbers, it is curious that typographical symbols have to be borrowed from their textual uses (“*” indicates a footnote, “/” a line break or a juxtaposition of terms) and pressed into service as mathematical symbols.


Contrast Commodore predictable, deterministic random number generator to that of Bally AS 2518 pinball platform.

(14) While the sequence of numbers generated has no easily discernible pattern and is hard for a person to predict, it is actually the same sequence each time.


Illusion of randomness actually programmed.

(14) When RND is given any positive value (such as this 1) as an argument, it produces a number using the current seed. This means that when RND(1) is invoked immediately after startup, or before any other invocation of RND, it will always produce the same result: 0.185564016.


Semicolon introduced as minor update to version 2 of Dartmouth BASIC, demonstrating changes in programming languages; argue against Ong sense that they are cast once and for all ahead of time rather than emerging like natural languages.

(15) Although this use of the semicolon for output formatting was not original to BASIC, the semicolon was introduced very early on at Dartmouth, in version 2, a minor update that had only one other change. The semicolon here is enough to show that not only short computer programs like this one, but also the languages in which they are written, change over time.


Microsoft added colon to BASIC to pack more code onto home computers.

(15) The colon separates two BASIC statements that could have been placed on different lines. In a program like this on the original Dartmouth version of BASIC, each statement would have to be on its own line, since, to keep programs clear and uncluttered, only a single statement per line is allowed. The colon was introduced by Microsoft, the leading developer of microcomputer BASIC interpreters, as one of several moves to allow more code to be packed onto home computers.


GOTO not original to BASIC but strongly associated with it; famously discussed denunciation prompted move to structured high-level languages.

(15) GOTO, although not original to BASIC, came to be very strongly associated with BASIC. A denunciation of GOTO is possibly the most-discussed document in the history of programming languages; this letter (discussed in the “Regularity” chapter) plays an important part in the move from unstructured high-level languages such as BASICD to structured languages such as ALGOL, Pascal, Ada, and today's object-oriented programming languages, which incorporate the control structures and principles of these languages.


RUN is essential token though not part of program, connecting machine to its environment where it is used by same agency in which the program is entered into it, not quite part of stored program specification; compare to exhortation to reader at beginning of texts, or even invocation to Muses starting up Iliad.

(16) RUN is therefore an essential token yet is not itself part of the program. RUN is what is needed to actualize the program.


A rhetorical aim of the book is to renew interest in learning programming via, and critical code studies of, early personal computers.

(17) One line of code gives rise here to an assemblage of readings by ten authors, offering a hint of what the future could hold—should personal computers once again invite novice programmers to RUN.

(20) Writing code can be a method of reading it more closely, as was recognized decades ago.

(21) In 1983, a Commodore 64 could be purchased for $600. Today, for those who already have Internet-connected computers, it costs nothing to download and use an emulator.

Consider emulator as an edition.

(21) When developers produce a program, such as the free software emulator VICE, that operates like a Commodore 64, it can be considered as a software edition of the Commodore 64. . . . Instead of dismissing the emulator as useless because it isn't the original hardware, it makes more sense to consider how it works and what it affords, to look at what sort of edition it is.









Variations of the Commodore 64 program demonstrate different visual patterns from code tweaks, as well as platform affordances and constraints such as working with graphical over musical elements.

(29) This program shows how much easier it is for Commodore 64 BASIC to work on graphic, rather than musical, elements.

(32) It is easy to overlook the cultural resonance and historical depth of the maze, which could be seen as nothing more than a flat, empty, puzzle-book diversion. The same dismissal can be leveled against short, recreational BASIC programs, which can seem trivial and of no importance.


Reading code changes once its execution is witnessed or read by an experienced programmer; compare to interpretation by deformation in Ramsay.

(34) The 10 PRINT program itself (not its output) can be seen as a unicursal maze. . . . Once the code has been typed and executed and the programmer witnesses the maze, there is no returning to a naïve view of this line of code—it is impossible to read the line without imagining the output.


Mazes involve myth, ritual and allegory, as does learning to program.

(37) Church mazes are usually meant to be walked or crawled on the path to penance.
(39) 10 PRINT taps into the mazelike mystery that visual symbols and glyphs evoke: to type in a program from a manual is to follow the twisted line from code to output and back again. The programmer follows the single path of the code from ignorance to knowledge, a pilgrim's path.

(41) In 1959, one of the earliest computer programs written for fun—an example of “recreational computing”--depicted an experimenter's maze.


Shannon mechanical mouse paradigm for simple maze traversal algorithms declared by Dyson to have inspired Baran adaptive message block switching.

(43) In the early 1950s the mathematician and engineer Claude Shannon designed a mechanical mouse that appears to solve the same kind of maze a real mouse might be expected to navigate in one of Watson's behavioral experiments. . . . The first time through a maze, Theseus blunders randomly, propelled by its magnet, flipping the relays underneath whenever it encountered a passage. The next time, Theseus navigates the maze perfectly, thanks to the relays underneath, which record the correct route.
(43) This means of negotiating the twisting passages of Shannon's maze was not mere novelty. As
Time explained in 1952, Theseus is “useful in studying telephone switching systems, which are very like labyrinths.” Indeed, George Dyson argues that Theseus inspired the RAND Corporation engineer Paul Baran's “adaptive message block switching”--the precursor to what is now known as packet switching, the protocol that defines the way data flows on the Internet.
(44) Although 3D mazes with some more exploratory aspects were offered in the
Ultima, Wizardry, and Bard's Tale series, the maze is more a frightening site for combat than a playful place of discovery in many first-person games.
(45) Many of the earliest computer-presented mazes are not visual; they are described textually, narrated to the player from a second-person perspective.

(49) Considering 10 PRINT in light of the cultural history of mazes situates the program's output in a space of symbolic meanings and design principles—the many ways in which something can be seen as mazelike or designed to be mazelike.

(52-53) Just as the variations of 10 PRINT in the previous remark illustrate the consequences of choosing one particular set of parameters among the many that were possible on the Commodore 64, ports of 10 PRINT can highlight the constraints and affordances of individual platforms


Tandy Color Computer eccentric cousin of C64.

(55) If the Apple II was the Commodore 64's sibling, raised by another corporation, then the Color Computer, with the Motorola 6809 and a different version of Microsoft BASIC, was the eccentric cousin.


(58) These “weird languages” (sometimes called “esoteric languages”) test the limits of programming language design and comment on programming languages themselves. One of them is the unusual-looking language called PATH.
(59) PATH is a weird language that borrows from the conventions of Brainfuck and Befunge, offering a syntactically constrained language whose control flow takes place in two-dimensional space.
(59) Given PATH's strong typographical similarity to the output of 10 PRINT, it is possible to implement a port of 10 PRINT in PATH—a program that generates labyrinths by endlessly walking a labyrinth.

Programs are texts, and may accept programs as input and produce programs as output, for example in weird languages like Brainfuck, Befunge or PATH.

(59-61) The output of 10 PRINT in PATH is itself a PATH program. This new program doesn't do anything very interesting; it simply moves the program counter around without producing any output. Still, it demonstrates a general idea: that programs are texts, and there is nothing to keep people from writing programs (such as the much less perverse compilers and interpreters that are in continual use) that accept programs as input and produce programs as output.


Ports clarify original source; compare to translations of literary texts.

(61) Inhabiting the native ecosystem of its platform, articulated in the mother tongue of its language, ports clarify the original source by showing the many ways it might have been other than what it is. Notably, many of these insights are not available through token-by-token analysis of code. They require closely considered reading, writing, and execution of code.
(62) These explorations all interrogate the canonical 10 PRINT program, asking what it means to try to write the same program differently or to try to make a program on another platform the same.

(66) In all of its newfangled (for the 1980s) sophistication, 10 PRINT ties the computer to the homespun tradition of handicraft: stitching, sewing, and weaving.

(67) The grid provides a framework within which human intuition and invention can operate and that it can subvert.

Truchet Tiles

Textiles and Craft
(76-78) 10 PRINT can be imagined as the complete method of craft programmed into the computer—as it was not fully programmed into the loom. The loop offers a way for the weavers of the computer screen to shift their emphasis from a fixed template, traversed once, to a more intricate model of process.

(79) While the 10 PRINT program came out of the computer culture and not the art world, it has an uncanny visual resemblance to prior works of twentieth-century art. Paul Klee, a Bauhaus professor and highly influential artist (1879-1940), produced works in the 1920s that seemed to resume Truchet's and Douat's experiments.
(84) During the era of our 10 PRINT program, in wake of the Vietnam war and social movements of the late 1960s and early 1970s, the larger emphases within visual arts communities had moved away from minimalism and constructivism (and their variants) to focus back on expressive and realistic painting and the emerging acceptance of photography. The visual work created for early home computers and games systems like the Atari VCS and Commodore 64, however, were highly constrained by the technical limitations of the hardware and therefore had more in common with the visual art of prior decades.
(84-85) A chief explanation for these uncanny similarities is the grid itself. . . . [Karl]
Gerstner's encounters with the computer led him to theorize the regulated space as a program itself.


(88) Process and the appearance of motion are essential to 10 PRINT.
(89) Simultaneously with the exploration of repetition in film, a host of composers based musical works on repetition.


Regularity of the machine learned like perspective and reading, implying cultural biases embedded programming languages.

(90) Even more than in the Ford factory, regularity becomes a paradigm of the computational age, to be explored and resisted because it is the central logic for even the most basic computational literacy. While the assembly line might put many goods in the hands of twentieth-century consumers, families did not need to contemplate assembly lines to consume these goods. Even for workers actually in a factory, the flow of the factory would be defined elsewhere. However, to write even the most rudimentary program, a person must understand and engage the regularity of the machine.
(90) In any
imperative programming language, commands are processed in a particular order that relates to the left-to-right then top-to-bottom path that Western readers' eyes take along a page.

Conditional and Unconditional Branching

The Harmfulness of GOTO
(94) Although
Dijkstra objected to the way BASIC was designed, he, like the original designers of BASIC, worked strenuously to describe how high-level languages, useful for thinking about computation, could work in machine-independent ways.

Bounded and Unbounded Loops
(96-97 BASIC CONSIDERED HARMFUL) Dijkstra simply wrote a dismissive sentence about the article, saying it “gave a striking example of superficiality” by comparing computer languages to natural languages.
(97 BASIC CONSIDERED HARMFUL) The risk of learning programming via one-liners is that one learns tricks and particular methods instead of gaining an understanding of programming methodologies.

Looping and Iterating

(103) As a pedagogical example in the
techne of programming, 10 PRINT is both a product of and a demonstration of the force of computational regularity.


Processing a language bridging programming and visual arts.

(106) Essentially, Processing is an image-making programming language that builds on knowledge of geometry, photography, typography, animation, and interaction. . . . Because Processing is situated between programming and the visual arts, it serves as a bridge between two professional cultures.
(107) While many elements and aspects of the original program can be modified in BASIC on the Commodore 64, some are more firmly fixed. Primarily, the 40 x 25 character screen that defines the resolution of the grid is fundamental to the computer's video system and defines the number of units that make up the maze.

(120) This randomness comes by way of RND, a standard function in BASIC. RND has been part of the BASIC lexicon since the language's early days at Dartmouth. What the function does is easily characterized, yet behind those three letters lie decades, even centuries, of a history bound up in mathematics, art, and less abstract realms of culture.
(120) In centuries past, before the philosophers and mathematicians in the Age of Enlightenment sought to rationalize chance, randomness was a nightmare.
(120) Only recently have the meanings of the word “random” coalesced around science and statistics.

(121) Games of chance are one of the four fundamental categories of games that all humans play, according to the French cultural historian Roger

The Appeal of the Random

Forms of Randomness
(123) [Thomas]
Malaby presents a useful framework for understanding indeterminacy based on four categories.
(123-124) Privileging the stochastic principles of formal determinacy means that players, scholars, and even programmers dismiss social and performative indeterminacies altogether.


Chance Operations

A Million Random Digits
(128) Like so many other advances in computing, randomness, it turns out, is intimately linked to Cold War military strategies.

(131) John von Neumann was the first to propose the idea of harnessing a computer to generate random numbers (Knuth 1969, 3).


Early Experiments in Computational Art

Acceptance and Resistance


(148) One-liners, as single-line programs such as 10 PRINT are known, predate home computing, the exchange of BASIC code in magazines, and even the BASIC programming language itself.
(148) While not everyone involved with computing shares an enthusiasm for one-liners, or for [Kenneth
Iverson's] APL, the exchange and academic publication of APL one-liners does demonstrate that interest in this form of program was not limited to amateurs or newcomers to computing.
(148) In the early 1980s, magazines published one-line programs, sometimes regularly, to fascinate and intrigue home computer users and to help them explore programming. In the Commodore-specific magazine
RUN, they appeared in a section near the front of the magazine entitled “Magic,” which contained “Hints and tricks that will let you perform computing wizardry.”
(149) This printing of the “BURROW” program, already declared an antique, also shows an awareness of computing history and a willingness to rediscover older programs so they can be enjoyed by a new generation of programmers and users.
(151) By the late 1980s, although the “Magic” section continued in
RUN (through the magazine's last issue), it was handed off to other editors and filled with utility programs, in BASIC and assembly, that were significantly longer—often around twenty lines.
(152) This practice continues in the contemporary practice of programming tutorials; one example is Peteris Krumins's “Perl One-Liners Explained.”
(153) The transfer of knowledge from platform to platform is a key part of the practice of programming; another key part is learning the differences among platforms. Sometimes knowing just a few details about a new system enables one to leverage a great deal of previous experience into competency of the new system.

Learning programming facilitated by short programs in print media since they were not immediately executable like software applications.

(153) While commercial software empowered users within the realm of their applications, short programs in books and magazines illustrated how to make the computer do impressive things and empowered readers to program.
(154) Understanding the general pace or speed at which a platform executes code is useful information to programmers.


Compare cultural and technical history of BASIC to learned Latin: free sharing led to widespread adoption in educational institutions, computing revolution includes changing interaction from batch to real time communication habits with synaptogenetic outcomes, perhaps affecting digital immigrants and natives in different ways but definitely having a profound influence (Hayles).

BASIC created in 1964 by Kemeny and Kurtz at Dartmouth, explicitly leveraging time-sharing; widespread adoption at high school and college level.

(158) This “Beginner's All-purpose Symbolic Instruction Code” has a fabled cultural and technical history. BASIC was developed by John Kemeny and Thomas Kurtz, two professors at Dartmouth College. In 1964 its creators freely shared a working version of the language, leading to its widespread adoption at the high school and college level.

The shifting capability of immediate programming, ready at hand versus ready through much cost or effort: whereas programming was the technical and epistemological challenge, the history of computing through the personal computer era introduced social and economic factors that, combined with ease of use at the level of complex interfaces, a particular type of programming declined as an everyday practice; note emphasis on apparent realization of creativity longed for by Ramsay today.

(158) Time-sharing allowed people to engage with and explore computation in significant new ways, with what felt like “real time” processing; BASIC was an important part of this computing revolution.
(159) Thanks in large part to Microsoft, BASIC became the lingua franca of home computing. BASIC resided in the ROM of these computers, meaning a user could turn on the computer and immediately begin programming.
(159) The language was a popular success, worked well for small programs that let home users explore computing, and fostered creativity in several generations of computer users and programmers.


Materiality of code throughout history of computing from Ada Lovelace onward.

(159) Ada Lovelace's contributions as an early programmer are most evident in her translation of and notes to an Italian article by Louis Menabrea about Charles Babbage's Analytical Engine.
(160) The computer programs that followed in the electromechanical and early electronic age of computing were less intelligible than Lovelace's algorithm, bearing little relationship to any kind of written word. . . . Historically, even as programming continued to expand away from direct hardware manipulation and into progressively higher levels of abstraction, these operators were inventing both computation and the act of programming as embodied, materially engaged activities and vocations.

Machine Language and Assembly Language

Machine language and assembly language first move beyond cables and dials.

(160) The move beyond cables and dials was accomplished with machine language. A program in machine language is simply a sequence of numbers that causes the computer to operate but can be understood by humans. . . . The numbers specify what operations the computer is to carry out and consist of opcodes (indicating low-level commands) that may be followed by operands (giving one or more parameters to those commands).
(161) A more legible form of code arose in the second generation of programming languages, called
assembly languages. Assembly allows mnemoics for operators such as lda (load accumulator), jmp (jump), and inc (increment memory) to stand in for the more esoteric numerical codes. . . . The first assembler ran on Cambridge University's EDSAC in 1949. EDSAC was, incidentally, the first computer capable of storing programs, a feature modern computer users have taken for granted for decades.

High-Level Languages

Advance in intelligibility (readability, naturalness) from hard wiring to stored program, machine language, assembly language, batch processing based high level languages (FORTRAN, COBOL), reaching time-sharing based high level languages (BASIC).

(162) FORTRAN and COBOL both allowed for more intelligible code, improving on assembly. But both were also developed in the context of batch processing, for use with stacks of punched cards that would be processed by the machine one at a time.
(163) BASIC was a language specifically designed 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.

Dartmouth BASIC and Time-Sharing Minicomputers

BASIC designed for ease of learning with revolutionary intent; difference between computer revolution of Kemeny and Kurtz and present age is ubiquitous access to computers far outpacing programming knowledge.

(163) Kemeny and Kurtz aimed for nothing less than a computing revolution, radically increasing access to computers and to computer programming.
(163) To reach millions, Kemeny and Kurtz would have to lower the existing barriers to programming, barriers that were related not only to the esoteric aspects of programming languages, but also to the physical limits and material nature of computing at the time.
(164) BASIC was designed in other ways to help new programmers, with “error messages that were clear and friendly” and default options that would satisfy most users' needs (Kemeny and Kurtz 1985, 9).

Freedom zero on Dartmouth system, in addition to ease of learning BASIC, fostered creativity based on play and abundance of resources, a synergetic feature extended with proliferation of personal computers.

(165) DTSS and the versions of BASIC that ran on it served almost all of the students at Dartmouth; by 1971, 90 percent of the seven most recent classes of freshmen had received computer training. . . . There was a downside to this, however: the very permissiveness that led to BASIC's widespread adoption and adaptation meant that the language, as actually implemented, wasn't as independent of particular hardware as Kemeny and Kurtz had planned.
(165-166) In addition to BASIC and the DTSS, there is yet another legacy from Dartmouth that has powerfully swayed the direction of modern computing: the almost evangelical mission to foster a more productive and creative relationship to computing. In his 1972 book Man and the Computer, Kemeny defends programming and playing games and other “recreational” uses of the computer as important, writing that such activities are relaxing and help people to overcome their fear of computers (35). . . . Computers were for everyone (at least within the campus community) and for any purpose. BASIC was the embodiment of this openness, which allowed for programs with no obvious military, business, or scientific purpose—programs such as 10 PRINT—to come about.


(167) The computer had already become more welcoming and accessible thanks to innovations on university and college compuses, but it wasn't until the computer moved into the home that the true revolution began.

Altair BASIC and Microsoft
(169) Given how often the success of personal computing is attributed to entrepreneurial and business advances and to Microsoft in particular, it's remarkable that Microsoft's first product was developed by borrowing time on Harvard's computer and was (as Microsoft always acknowledged) an implementation of a freely available programming language from Dartmouth.

Gates and Allen adding POKE and PEEK to BASIC provides affordances not suited for time-sharing, multiple user systems; also beyond contemporary inline assembler in C, which reflect hegemony of protected mode multiprocessing.

(171) Altair BASIC included alterations to Dartmouth BASIC, many of which would have made no sense on earlier time-sharing systems but which were helpful, even crucial, on home computers. While none of Microsoft's changes to BASIC were critical to the functioning of 10 PRINT, Gates and Allen did create the POKE and PEEK statements, which have been widely used in microcomputer BASIC and in programs found throughout this book.

Tiny BASIC and Copyleft

Importance of publishing octal machine code so humans could share BASIC.

(173) In 1975, volunteer programmers and the nonprofit People's Computer Company (PCC) developed an alternative BASIC for the Altair 8800. . . . In a collaborative hobbyist spirit, [Dennis] Allison's documents were published in three parts by [Bob] Albrecht in issues of the PCC newsletter, a serial that had been running since October 1972. At the conclusion of this series of specifications, Allison called for programmers to send in their implementations and offered to circulate them to anyone who sent a self-addresssed, stamped envelope.

Sharing and copying prevalent in crucial to dissemination of BASIC.

(173-174) The first interpreter written in response to this call was by Dick Whipple and John Arnold and was developed in December 1975. To disseminate it, Albrecht and Allison started a new serial, initially photocopied and originally intended to just run for a few weeks. This was Dr. Dobb's Journal of Tiny BASIC Calisthenics and Orthodontia; it printed the code for the interpreter in octal machine language, ready for hobbyists to toggle in or, even better, key in on their Teletypes. . . . In 1985, Dr. Dobb's further participated in the culture of sharing and openness by publishing Richard Stallman's “GNU Manifesto,” a foundational document for the free software movement.
(174) Because [Li-Chen] Wang chose to disclaim copyright and reserve only the “wrongs” of the program, Palo Alto Tiny BASIC was able to serve as the basis for a commercial BASIC: Level I BASIC for the TRS-80, the influential microcomputer that came on the market in late 1978.

The Ethics vs. The Corporation
(175) Did Microsoft's rise to the height of corporate ruthlessness begin with this letter to hobbyists?

Current comparable benefit of line numbers in debugging, such as gdb, useful for referencing source code, hard not to say it, lines (statements) without point and click affordance like GUI IDEs.

(176) [LINE NUMBERS AND COLONS: RESPONSES TO CHANGING HARDWARE]. The line number's real value is seen on a Teletype or other print terminal, or in any environment where full-screen, nonlinear editing is not an option.

Argument that ideas of free software movement first published in responses to Gates famous letter to hobbyists.

(178) An argument has been made that, even though the discussions of this period have been overlooked, some of the ideas important to the free software movement were first publicly stated in the columns of magazines and newsletters in response to Gates's letter (Driscoll 2011).

We have the mechanism for code sharing to freely circulate, but seem to lack a critical mass of hackers popularize big humanities projects; is the fault the manufacturers no longer advertise or encourage hacking?

(179) Ultimately, BASIC became what it was in 1982 thanks to the institution of higher education where it was first developed, the corporation that implemented and licensed it for use on home computers (including the Commodore 64), and, significantly, the hacker ethic of code sharing that allowed BASIC programs—such as 10 PRINT—to circulate freely.

(180) It was very easy for home computer users to type in or modify a BASIC program, and the fact that the manufacturers encouraged such behavior in mass media advertising primed users to partake of programming once they'd purchased a machine.


Early code studies is human legible print based because that was how programs were initially disseminated. Invitation to resume earlier study of material specificity of manuals and secondary documentation such as magazines and long-form books.

(182) From the first years of the language, BASIC programs circulated as ink on paper. In 1964 and for many years afterward, there was no Web or even Internet to allow for the digital exchange of programs, and it was often impractical to distribute software on computer-readable media such as paper tape. From the mid-1970s through the early 1980s, BASIC was known in print not only through manuals and textbooks that explicitly taught programming, but also through collections of programs that appeared in magazines and computer club newsletters. The printed materials that remain today reveal insights into the practices of BASIC users and the culture that developed among them.

Programs in Print

Print dissemination of legible code created new reading forms, such as intuiting program execution, and on account of ergodic transmission, encouraging revision and rework; even possible to consider memorization of short programs and memory of features of large programs that professionals who work on large projects may experience.

(183) While magazines were ready and regular sources of BASIC programs, many enthusiasts also discovered code in long-form books.
(184) Given the growing popularity of BASIC and computers among hobbyists, it is not surprising to see books of BASIC that go beyond games.
(186) While programs in machine language occasionally circulated in print, published BASIC programs such as 10 PRINT were a different beast altogether. BASIC was legible code. It could be read straight from the page and some sense of the program's nature was evident before the program was ever executed. . . . The transmission of BASIC programs in print wasn't a flawless, smooth system, but it did encourage engagement with code, an awareness of how code functioned, and a realization that code could be revised and reworked, the raw material of a programmer's vision.

BASIC in Human Memory

Like memorizing other natural languages, situated context is important in memorizing programs; however, built in affordances of IDE and availability of samples may help.

(187) For many programmers, however, memorizing one-liners (not an entire massive codebase) is both possible and useful—and pleasing, much as memorizing a poem might be.
(187) In addition to being able to show off and seem elite, there are some strictly utilitarian reasons to memorize a short program.
(190) Programmers who use such Perl one-liners do not seem to remember them in exactly the way one memorizes lines from a play or a song. . . . In other words it is knowing Perl, not just the memorization of a string of symbols, that is important to most uses of Perl one-liners. . . . Many common one-liners are not programmed “from scratch” each time they are used.


History of late BASICs under Microsoft hegemony.

(191) The most direct lineage continues Microsoft's history of building tools to support the BASIC language. Compilers and development environments supporting BASIC, including QuickBasic and Qbasic, shipped with every Microsoft operating system until Windows 2000 finally broke the chain by moving away from an MS-DOS base.
(191) On the less professional end, Microsoft's most recent BASICX probably has the strongest relationship to 10 PRINT and to how that program was used, modified, shared, and explored. This version of the language is Microsoft Small BASIC, released in 2008 and available free of charge. This is a Microsoft .NET language that is clearly aimed at students and other beginners.

HTML is the new BASIC; compare to McGann.

(192) A more radical interpretation of BASIC's legacy might include languages that have taken over its role of inviting ordinary users to become programmers and creators. Following the release of graphical web browsers like NCSA Mosaic, Netscape Navigator, and Microsoft Internet Explorer between 1993 and 1995, that role might be assigned to HTML.
(192) BASIC's role as a language that introduced users to programming by necessity in the 1980s is now being fulfilled by languages designed specifically for education, some of which are so abstracted from traditional programming practices that they use entirely different metaphors.

Was BASIC unique to its historicity as emerging from time-sharing and basking in personal computing before widespread distribution of executable software?

(193) Because BASIC was a hit at a unique time in the history of computing—when microcomputers were becoming mainstream but before executable software distribution became widespread—there may never be another language quite like it.

(196) Due to its intended use, the requirement that the system sell for a low price, and the high costs of silicon components, the Atari VCS was designed in a very unusual way. . . . The TIA supported five “high resolution” movable objects: two player sprites (movable objects that can be created once and moved around freely), two missiles (one for each player), and a ball. . . . The TIA also enabled a low-resolution playfield and a changeable background color, along with a variety of methods to vary the appearance of each of these objects.
(196) Unlike the Apple II and the PET, the Atari had no on-board ROM and no operating system, and only a fraction of the RAM of those other 1977 computers. As a result, Atari programmers had to write code that manipulated the TIA's registers not merely on a screen-by-screen basis, but on every single scanline of the television display.

(200) Once a particular line or group of lines is complete, the programmer can “reuse” the sprite registers later in the same screen, for a different purpose.



(207) The difficulty of creating a 10 PRINT pattern on the Atari VCS is a reminder that computers with similar components from similar eras were designed to do very different things. . . . But the simplest version of the program on the Atari VCS requires 360 bytes, largely because the program has to perform “from scratch” so many functions that in the Commodore 64 are part of the ROM.

Good statement of why platform matters and materiality of code and coding practices, discerned by repeating 10 PRINT exercise on different but contemporaneous platform, even using the same processor; consider Floridi identifying differences in information structure architectures.

(207-208) The very idea of creating a program like 10 PRINT depends on aspects of the platform and the platform's facility for such a program—the presence of BASIC and RND in ROM, the existence of PETSCII, the cultural context of shared programming techniques, and of course the ability to program the computer in the first place, something owners of an Atari 2600 did not truly have. Reimplementing the program on the Atari VCS, a platform both contemporaneous with the Commodore 64 and highly incompatible with the program that is this book's subject, helps to show all of the things the Commodore 64 programmer takes for granted.


Commodore 64 best selling single model computer; lives on in emulations, which have been likened to versions of literary works, and faithfulness of material and platform specificity can be an evaluation parameter of such emulations.

(212) The Commodore 64 has been hailed by Guiness World Records as the best-selling single model of computer ever. People associated with Commodore have estimated, officially and unofficially, that 22 million or 17 million units were sold. A detailed study of Commodore 64 serial numbers has provided a better estimate, that 12.5 million Commodore 64s where sold (Steil 2011), which is still enough to earn the computer this distinction.
(212) Although production ended in 1994, this computer system remains functioning and part of the popular consciousness in many ways.
(212) The original Commodore 64 computer has particular features—the PETSCII character set, built-in BASIC, and the specific appearance of the screen—that determine how 10 PRINT runs.


Social context of use in populations and marketing like Manovich cultural factors joining technical factors of BASIC implementation on particular platforms.

(213-215) Gender appears to have been less of a factor in computer use than race or socioeconomic status was. . . . A more statistically significant descrepancy appears in computer ownership by household income.
(215) These socioeconomic, racial, and gender disparities are part of the context of 10 PRINT, as much as the history of textured patterns or BASIC is.
(215) The family indicates a carefully targeted market. . . .Though the statistics suggest more gender balance in access to computers, the advertisement reinforces a narrative of home computers as the realm of boys.
(216) In the world of computing since the inundation of PC clones, it is difficult to imagine the aura produced around individual machines.

Platform-specific stratification, including formation of user groups, affecting home experience (lines of flight, smooth and striated surfaces).

(216) The experience of home computing was in many ways stratified by platform.
(216) Computer owners also created and joined user groups that were specific to platforms and that met in person.

Argument that learning one-liners fit availability of resources invites asking about current age of over abundance, FLOSS proliferation creating the kind of saturation discussed with respect to textual analysis by Ramsay through Derrida.

(218) With limited time and particularly in the context of a school or retail store, where the available software might be limited or nonexistent, it would not have been a had idea for a visitor to the Commodore 64 to learn about and modify one-liners such as 10 PRINT.

(218) Personal computers were hardly a natural progression or simple next step from typewriters, but their prominent keyboards, their use as office equipment, and their use for typewriter-like word processing tasks all demonstrate they had affinities with earlier devices.

Inappropriateness of intended design of MOS 6502 for general purpose computer.

(219) Yet MOS Technology never intended the [6502] chip to be used in computers or videogame systems. The 6502 was designed as a single chip replacement for the two- or three-chip processors found in cash registers, appliances, and industrial machines.

Compare history of Commodore to Stern pinball.

(219) With an eye on vertical integration and the 6502 microprocessor, Jack Tramiel bought MOS Technology in September 1976, but not in the most straightforward fashion.

(221) The PET's name is a sign of the times; [Andre] Sousan came up with this name to capitalize on the pet rock craze of the late 1970s, and only afterward did [Chuck] Peddle suggest “Personal Electronic Transactor” as a “backronym” that would explain the PET's name logically (Freiberger 1982, 13).

Platform affordance of PETSCII for early computer games; for 10 PRINT specifically, its graphic character set, video chip, and KERNAL operating system.

(221) As discussed in the BASIC chapter, the PET was the first of Commodore's computers to include BASIC in ROM, making the PET ready for programming the moment the computer was booted up. . . . While the graphical character set of PETSCII, which features the four suits of cards, shaded patterns, and various brackets and lines, could hardly be said to be an innovation, it made possible early computer games in BASIC without the need to program sprites of other animated figures.

The VIC-20
(222) There is much to say about the Commodore 64 as one of the most popular home computers of all time, but for the sake of clarity it is important to focus on those elements of the Commodore 64 that come into play in 10 PRINT, namely, its unique graphical character set, the VIC-II chip that implements the computer's graphic capabilities, and the ROM-based operating system, or KERNAL.

(223) The facts of PETSCII are simple: it is an extension of the 128-character ASCII (American Standard Code for Information Interchange) set; in addition to letters, numbers, and punctuation, it contains color codes (to turn text white, for example), screen control codes (such as RETURN or CLR), and graphical characters (lines, curves, arrows, boxes, and shaded patterns).

The Order of PETSCII
(225) Why is the order of graphical characters in the PETSCII table so seemingly haphazard? The answer is that arrangement was dictated by the PET keyboard design, a hardware-driven decision.
(225) Not coincidentally, 10 PRINT uses the NM pair—because it is visible on the interface, because it is elegant and concise in the code, and because the output is surprising, given the context of mazelike computer graphics at the time.

Easy for interpreted command prompt interface to serve as documentation and tutorial substitute, such as ASC function; man pages as built in documentation on UNIX-like systems share this feature of time-sharing systems yielding real time response to user input.

(227) Through the ASC function, BASIC became a self-contained pedagogical instrument itself, making outside manuals and guides less necessary.

The Shape of PETSCII

(228) The influence of videogames can clearly be seen in the VIC-II's built-in side and vertical scrolling (by seven pixels at a time) and the VIC-II's handling of sprites.

Text on the VIC-II
(229) While the code for 10 PRINT specifies one of two characters to display on the screen, it says nothing about where on the screen the chosen character should appear.
(229) In addition to wrapping text automatically, the VIC-II also automatically scrolls the contents of the screen when the cursor is on the bottom row and attempts to move down.

Designing New Characters

Pinball platform insight: leveraging I/O feedback of SID chip for number generation has family resemblance to Bally switch matrix; the subject also invites platform comparisons and question of whether and how different platforms may have influenced programming style or other eventualities stemming from use of that platform, for example superior sound capabilities of Commodore over Apple II.

(230) An intriguing feature of the VIC-II is its ability to use RAM-programmable characters instead of the PETSCII characters permanently stored in the character generator ROM.
(231) [THE SID CHIP]. A three-voice synthesizer with variable pitch, amplitude, and harmonic tone control, the SID [Sound Interface Device] made the Commodore 64 a formidable music maker and game machine.
(231) [THE SID CHIP]. What is most interesting about the SID chip for the purposes of 10 PRINT is that the third oscillator—the only of the three oscillators whose output can be fed back into the CPU—can be used for number generation.


Kernel legacy amid changes in design and purpose, now a changeable, modular brain stem: complexity of kernel programs belongs with networking as periods in evolution of control societies, obscuring hardware operations to aggravate retreat of user knowledge.

Compare history of KERNAL name to backronym explanation of PET.

(232) A misspelling of the word “kernel” that has stuck ever since it first appeared on draft documentation for the VIC-20 (Bagnall 2010, 330), the KERNAL controls all input, output, and memory management of the Commodore 64. . . . It is the brainstem of the machine, its core, its always present, unyielding, and unchangeable center.
(232-233) The KERNAL is intended to make machine language coding easier, providing a stable set of instructions and registers a programmer can address. Yet as enabling as the KERNAL may be, it is also structuring and limiting, the basis of the Commodore 64.

A View from Assembly Language

Kittler argument that high-level languages obscure hardware operations, so consider view from assembly .

(233) In fact, Friedrich Kittler (1995) has famously argued that high-level languages essentially obscure the operations of the hardware. . . . In assembly, the programmer need not recall the numerical equivalents of such instructions, but only human-readable mnemonics for them—which are stored in the Commodore 64's KERNAL.

Gives a good example of working assembly code operation (imperative) narration similar to the token by token analysis of 10 PRINT at the beginning of the book, depicting yet another form of narrative.

Many ways to implement the same program in different languages, and it can be debated whether there is any immaterial universal for which all programs are equivalent like the UTM; this fact suggests programming languages may be more like other natural human languages than Ong make think.

(234) No canonical assembly [10 PRINT] program is known to exist. As with literary translation or artistic adaptation, there are multiple ways to recast a computer program from one language into another, even on a relatively simple system like the Commodore 64, and even with a relatively simple program like 10 PRINT. . . . This short program may look arcane, even to someone familiar with BASIC. Yet it can be explained without too much difficulty, step by step, by following each instruction in the order in which it is processed.

*= $1000

lda #$80

sta $d40f
sta $d412

(235) The assembler treats lines that begin with whitespace as instructions and lines that do not as labels, which designate positions in the program.

lda $d41b

and #1

adc #$6d

jsr $ffd2

bne loop

Dependence of emergent elegance of BASIC code on specificity of hardware and operating system confounds immaterial language assumption of other simple programs such as given by Tanaka-Ishii.

(239) While “threadbare” is clearly more esoteric and less human-readable than its BASIC predecessor, its implementation reveals that the abstraction that makes the emergent elegance of 10 PRINT's output possible in such a small set of instructions is not entirely a feature of the BASIC interpreter, but also depends on the underlying hardware and operating system of the Commodore 64.
(239) Though 10 PRINT is an example of a robust one-liner that can be reimplemented in other languages and platforms, it is a program deeply tied to the material specifications of the Commodre 64, a bestselling personal computer that played a pivotal role in establishing a place for computers and programming in certain users' homes.

Demoscene programmer subculture focusing on real-time audiovisual software.

(240) [“THREAD,” A TINY DEMOSCENE PRODUCTION]. The demoscene is a programmer subculture centered on the design and manipulation of real-time audiovisual software. . . . The hallmark of the demoscene is its emphasis on technical achievement and pushing the limits of earlier hardware systems.


Declares a software studies method is writing programs to interpret other programs, to which I argue better fits critical programming; include critique of this extended textbook presentation of working code in codex format versus other forms like cinema or virtual machine dynamic presentation.

Consider reasons for distinguishing writing programs as hermeneutic probes with merely using other software to study software, continuing argument stemming from Kemeny on value of learning by being forced to teach the machine how to solve a problem.

(244) But 10 PRINT can also be interpreted as a maze, a labyrinth with routes and potentially with a solution. One might even wander through the maze, tracing a path with one's eyes, a finger, or some computational procedure.
(244) What would such a computational procedure, and a program that supports its use, look like?
(244) To see the answer, this section uses a software studies approach, writing programs to interpret other programs. It takes this approach to the extreme and builds a large program, using 10 PRINT as the starting point. Just as literary scholars study a text by generating more texts, it is productive to study software by coding new software. In this particular case, it's possible to develop a series of hermeneutic probes in the Commodore BASIC—probes of increasing complexity, programs that transform 10 PRINT's output into a stable, navigable, and testable maze.



Graphic logic example of representational trope for representing virtual spaces, amounting to learned perceptions.

(253) This program sharpens the somewhat vague visual perception of “mazeness” into a highly detailed understanding of the local structure of the maze.
(253) This basic principle of continuously drawing and erasing static snapshots to produce the illusion of movement is a fundamental feature of modern media, seen in everything from the latest Pixar movie to the latest blockbuster Xbox game. The related principle of collision with virtual objects, when combined with the representation of movement, defines graphic logic, a representational trope that underlies the computer's ability to represent virtual spaces.



Generate and test method from computer science can be deployed by critical programming for studying humanities problems; it leverages the ability of simulations to be generated and submitted to testing in ways impossible, unethical, or cost prohibitive in physical correlates.

(257) Computer science offers a general approach to such problems called generate and test.

(262) 10 PRINT has generated far more than a pattern that resembles an unending scrolling maze. It has generated talks, posts, papers, online conversations, demoscene productions, and now this book. But its most important product may be the countless programmers inspired by its concision, enticed by its output, and intrigued by its clever manipulation of two very simple symbols.

Makes points that 10 PRINT is emblematic of deluge of BASIC programming in early 1980s, resonant, and culturally situated, disembarrassing putatively ahistorical code analyses such as found in Floridi and others who wish to couch universal pronouncements in code.

(262) Rather, 10 PRINT is emblematic of the creative deluge of BASIC programming in and around the early 1980s.
(262) Yet, as this book has indicated, 10 PRINT
(262) Reading this one-liner also demonstrates that programming is culturally situated just as computers are culturally situated, which means that the study of code should be no more ahistorical than the study of any cultural text.

Code functions; executability of code differentiates it from other texts and semiotic systems, while sharing personal and cultural significance with other types of texts.

The sensibility of studying short programs extends to studying important parts of larger systems of code, if it is going to far to suggest prolonged study of a large program like an epic poem.

(263) Code is not only a conventional semiotic system. At its essence, code also functions. Code runs. Code does something. Code executes on the computer and has operational semantics. But code means things to people as well, both implicitly and explicitly. . . . We hope this will encourage the detailed analysis of other short programs and suggest that it is worthwhile to focus on important subroutines, functions, and procedures within larger systems of code.
(263) 10 PRINT shows that much can be learned about a program without knowing much of anything about its conditions of creation or intended purpose—or indeed, without it even having an intended purpose.

Access to programming in different form today: no READY prompt.

(264) But the widespread access to programming that was provided by early microcomputers does not exist in the same form today as it did in the 1970s and 1980s. When people turn on today's computers, they do not see a “READY” prompt that allows the user to immediately enter a BASIC program.

Programmability is not a ready at hand gesture made by current computers like the early personal computers that were designed to be immediately programmed, suggesting an early age of popular programming heralded by Kemeny was likely to decline and be supplanted by other habits.

What are consequences of proposition that popular programming peaked in early 1980s?

(264) For popular programming, the early 1980s were certainly a special time.
(264-265) The cultural history of the maze demonstrates that there are more and less obvious associations with this type of structure, some wrapped up with the history of science in the twentieth century and others emerging from computing itself.
(265) Our discussion of 10 PRINT has tried to account for these relevant material qualities while also attending to the formal, computational nature of the code—what it does—and how that interacts with material, historical, and other cultural aspects of the program.
(265) As with the Teletypes that preceded computers like the Commodore 64 and the laptops that eventually replaced them, the physical makeup, cost, contexts of use, and physical form of computers have significant effects on how they are put to use.

Programs and software are not static; period of packaged media preceded by customized products and succeeded by continuously updated ones.

(266) The view of programs as static is even less tenable when one considers the writing, running, and distribution of programs throughout the history of computing. Custom software written for businesses has long been maintained and updated—for half a century. The BASIC programs people keyed in from magazines invited users to modify them. In educational and software development settings programs have typically been converted to other programs by elaboration and modification.

Programming, porting, modifying existing programs as ways to better understand software, platforms, and to learn how computers work, and of course how to program: does foregrounding spending a considerable amount of time working code differential critical programming from critical code and software studies?

(266) This book has tried to establish 10 PRINT not just as a program, but also as part of the process of learning about and developing programs—something that can be said about almost any code.
(266) Since programs are dynamic, and some of them explicitly invite modification, and since modifying programs is a way to better understand them, the platform, and computing generally, why not modify a program as part of a scholarly investigation of the program?
(266) To see what is special about different platforms, and how platforms differ from one another, we have produced ports of 10 PRINT during our investigation of it and the writing of this book.
(267) Analyzing the code by interacting with it, revising it, and porting it is one of the main critical activities this book contributes to critical code studies and related fields in digital media.

75 END




Montfort, Nick et al. 10 PRINT CHR$(205.5*RND(1)); : GOTO 10. Cambridge: MIT Press, 2013. Print.