A Platform Poetics

Computational Art, Material and Formal Specificities, and 101 BASIC Poems (2013–)

Nick Montfort

I’m a computational artist, meaning that computation itself is my main artistic medium. Certainly, I work with language a great deal, and also consider myself to be a poet. I have been working creatively with computers for almost as long as I have been a literary artist of any sort. My work these days draws on my experience not only with language and literature, but also as a visualist programming in performance and accompanying livecoding musicians. My projects manifest themselves online and in book form, but also in gallery settings, where they are identified as artworks. I do work at the edges of the demoscene, a community of practice where audiovisual spectacle is prized.1

It’s important to me (in almost every case) that each of my artworks has at least one manifestation as functioning computation. The computer-generated books that have been a major component of my recent work generally include the computer programs that generated them. When my work has been shown in galleries on screens, the code has typically been made available—even, in one case, on cards that visitors could take home with them. I am interested in giving away the goose, not just selling the golden eggs. And while it’s not the topic of this article, I do give my code away as free/libre/open source software, so that everyone is free to share, study, and modify it.

To explain the type of artistic engagement I have with computation, I need to make a few distinctions, or at least identify different emphases in artistic practice. First, I’ll explain how there are some artists who are more digital (working in digital media) and not as computational (using computation itself as their medium). Second, I’ll turn to how some computational artists consider the output from a process to be their work, while others are goose givers like me, offering a working program as the core artwork. Finally, I’ll describe how some artists strive to factor out the particular computational platforms they use, while others (myself included) embrace the constraints and affordances of these hardware and software systems. During this discussion, I’ll mention some other artists’ practices and discuss one of my projects in detail: 101 BASIC Poems, an ongoing project I began in 2015.

After all of this, I hope you’ll see why I consider myself a computational artist, one who produces software art, and one who has a platform-specific artistic practice. I hope the typology into which I place myself is of general use in the digital and computational arts, too, and situates artists in eight categories—albeit more radial categories, with soft boundaries between them.

Digital Art versus Computational Art

Digital art is unique to the medium of digital computers, but it is more involved with data than computation. For instance, a digital image of any format is a digital artwork. A program, whether in Processing, p5.js, Python, BASIC, or machine language, is computational, and can be executed to make the computer do something, something that might be more open-ended than the display or playing of data. Of course, such a program is also digital, but it would be quite unwieldy to write “non-computational digital art” all the time, so I’ll reserve the term “digital art” for those artworks that exist in digital formats but aren’t programs.

A digital artwork is more often made with a “tool” or application, although it can be produced by low-level interventions as well. In the case of visual art, these tools would include illustration and photo-editing software. Computer programs aren’t produced with the same sort of tools. The programs themselves can simply be written with text editors, but they are ultimately made using interpreters, compilers, and assemblers, tools of a different sort that a programmer often accesses through an Integrated Development Environment (IDE). Sometimes a series of such programs is called a toolchain, and it’s not uncommon to refer to software development tools. But these metaprograms aren’t media-editing applications. They allow other programs to be written, including not only interactive sketches and text generators, but also additional software development tools.

This distinction may seem to relate to one in Christiane Paul’s Digital Art, a book with the first of its three chapters about “Digital Technologies as a Tool” and the second about “Digital Technologies as a Medium.” However, Paul’s partition of digital art relates more to the next distinction in my typology, that of output versus software. What I am trying to distinguish as particularly computational is along the lines of what Paul discusses as “software art” on a single page of her chapter 2.2

My project 101 BASIC Poems3 is an initiative to develop just more than a hundred computational artworks, each one not simply a digital text but also a computer program that can and should be run. On the computational end of things, a major inspiration is 101 BASIC Computer Games,4 a collection of BASIC programs that fired the imaginations and scaffolded the programming ability of many people in the late 1970s and early 1980s. My BASIC poems are shorter than the programs in this book, in part because attention spans are shorter these days. They are also inspired by specific work by particular poets, artists, and other creative people. I’ll begin by presenting a very simple one of these BASIC poems:

File Not Found

a BASIC Poem for Ron Padgett

10 PRINT "Nothing in that drawer."
20 FOR I = 0 TO 999
40 GOTO 10

This poem is based on a sonnet by Padgett consisting of fourteen repetitions of “Nothing in that drawer.”5 Each line of Padgett’s sonnet is lexically identical to all the others, but each one (the way that I read it) means something different because it refers a different drawer of some empty flat file or Wunderkammer. The word “that” is a deictic that points outside the poem, presumably to some drawer, and to a different one each time it is read or said. People find humor in Padgett’s sonnet, but it’s also a sad poem, isn’t it? The speaker seems to be searching through the house of a dead parent, looking for drawing or mementos, items that could supply meaning. But there’s nothing. Does that make my endlessly looping extended remix of the poem infinitely sad?

I need to elaborate on how digital art isn’t truly “just digital” or entirely computational. When an artwork has some computational aspect to it, it can incorporate more or less data and can actually function more or less extensively. The most relevant discussion here is Noah Wardrip-Fruin’s extension6 of Chris Crawford’s concept7 of “process intensity.” To get into this concept, we need to grasp that distinction between data and processing, with processing being what code actually accomplishes as it runs: The operation of the computer, as opposed to the storage of information.

The sidebar offers some concrete (and perhaps overly detailed) explanation of a point that Wardrip-Fruin discusses. The literal “crunch per bit,” how much processing the computer is doing, is not really what anyone in the computational arts should be concerned with when it comes to process intensity. Instead, Wardrip-Fruin focuses on a quality called “behavioral process intensity,” where the processing being done is considered not simply from a raw computer architecture standpoint, but from the standpoint of how systems function, generatively and interactively. By his standards, increasing the resolution of graphics doesn’t mean diminishing something’s process intensity. The important comparison to be made is between computational artworks that function or operate less and those that function or operate more.

But in looking at my own practice, I see another puzzling aspect of process intensity that leads me to question even this notion. There can be computational artworks that run quite intensively but are non-interactive and deterministic. So, from the beholder’s perspective, they might as well be made entirely of data. Demos from the demoscene provide one example.8 They are programmed with great skill to run in real time but, when actually executed, look like animations. Few of them have any interactive aspects. As the demos get smaller and smaller (as with those written by “sizecoders”9 to fit strict length limits), programmers are forced to rely more and more on what computational processing, as opposed to pre-built assets such as 3D models and textures, can accomplish.

Several of my literary projects have been inspired by sizecoding practices in the demoscene, although I typically have used high-level languages. The Truelist10 is a book-length poem with twenty sections, each of forty-six quatrains, all of it generated by a single page of stand-alone Python code which is presented at the end of the book. The code is deterministic: Each time it is run, the same twenty sections result in the same order. In a way, it makes as much sense to think of the stanzas being encoded or compressed by the program as it does to think of the program as generating the stanzas. So, in a way, all I did was write a sort of fancy zipfile with an unzipping utility built in.

Given that it’s possible to trade off between data and computation in this way, is there any point in even making a distinction?

I certainly think that there is. But in cases like these, we need to look beyond the art object. In my composition of The Truelist, as with the development of a demo in the demoscene, it is ultimately the artistic practice is computational—whether you end up with a book or with an animation-like screening at the end of the process. The art is shaped by the possibilities of code and processing. By sharing the program (just as those in the demoscene share the executable, machine language code for their work), I “demo” the computational nature of my practice. I also invite others to study and intervene in the code I wrote, partaking of a computational practice themselves.

Now, even when there is a sharp digital/computational distinction to be made, I don’t mean to judge those who work on the other side of this divide. More than “crunch per bit,” and more than “behavioral process intensity,” digital artists of all sorts seek to develop work that resonates with others individually and provides cultural crunch. Some, even those who are not on the process-intensive end of the computational spectrum, present software artwork work in format-specific ways, because this is the digital art analog of doing platform-specific computational work. To explain why that is, I’ll need to make the next two distinctions.

Output Artworks versus Software Artworks

An artist can run a piece of computational art and produce “output artwork” which might take a fairly traditional form—that of a chromogenic print, for instance, or a film. Or, the artist can present the program itself as an artwork.

There are some complexities here, too. The Truelist as published by Counterpath is a book, so you might imagine that it’s a simple case of output artwork. But it also is a printed storage medium for the program, the computational work itself. You can flip to the end of the book and type the program in, if you like. So, in fact, it’s a software artwork that manifests in print form, as was the case with programs that appeared in computer magazines of the 1980s and in books such as 101 BASIC Computer Games. The book The Truelist is a means of storing the program just as much as a USB stick would be, just as much as my Web server is.

Here’s another of the 101 poems that is useful in discussing this output versus software distinction:


an Applesoft BASIC Poem for Caroline Bergvall

10 FOR I = 0 TO 9
20 READ A$(I)
40 FOR J = 0 TO 999
70 PRINT A$(RND(1) * 10)
80 GOTO 40
90 DATA "Gone sing 'bout"
120 DATA "Remind us, Muse"
130 DATA "Sing in me, Muse"
140 DATA "Sing to me"
160 DATA "Tell me, Muse"
180 DATA "Tell me"

“File Not Found” has 23 characters (23 bytes) of textual data in it—no doubt about it. But the amount of BASIC code it has, or the amount of processing it does, depends on how we count. If we’re looking to count characters of BASIC code, we’d better write the program as compactly as possible in order to be fair. Otherwise, we could throw in as many comments as we wanted (using the REM statement) to inflate the length of the code. As it happens, the minimal length differs slightly depending on the dialect of BASIC we use. For the following example I’ll use Applesoft BASIC, the version of the language most often used on Apple II computers:

0?"Nothing in that drawer.":FORI=0TO999:NEXT:GOTO

The whole program is 49 characters (bytes) long, and 23 of these are data, so 26 are code. This makes for a 26/23 ratio of code to data. However, BASIC code is actually tokenized when it is stored in memory, so it’s not clear that this is or will be the right way to count the length of code in a BASIC program. In fact, when the program is listed it has a different surface form. Using the Apple II’s machine language monitor to look underneath the hood and see how the program is represented in memory reveals that it is 44 bytes long.

Ultimately, any program causes a computer to function in a particular way. For every program of any sort, there is a corresponding machine language program that accomplishes the exact same thing. In fact, for compiled programs (for instance, ones written in C), as for those written in assembly, when the toolchain has done its work that exact program is produced. That’s the while idea of compiling programs: The original high-level, human-readable program is made into a machine-language program that can be run. Even in an interpreted language, it’s still possible to trace though and see what processing is happening. In this case, Applesoft BASIC’s PRINT routine is called and goes through the 23-character string, peeling off one character at a time and sending that to another routine that writes this character to screen memory, each time checking to see if it’s necessary to scroll up by a line. It isn’t, but when PRINT is finished with this string it does scroll the display up a line.

Then, we have a FOR loop that serves to introduce a slight but noticeable delay. On a modern-day computer, this loop would proceed so rapidly as to be imperceptible. But on the Apple II it results in a pause. After the FOR and the NEXT statement, there’s an unconditional branch (corresponding to the GOTO) that sets the program counter so that it points to the beginning of this code—causing the program to begin again.

I could count up the number of machine cycles used for all of these operations. Instead, as they say, I will leave that as an exercise. The important thing to note is that this also wouldn’t correspond directly to the amount of BASIC code, whether we use the “surface” or deeper measure of how much BASIC code there is.

Furthermore, there are many cases in which our computer might be “processing” very intensively in ways that have little obvious result. The processing may even be invisible. Our computer could be mining Bitcoin but never reporting when the task of finding a nonce is complete. This would be a curious type of computation, a good bit more conceptual (and environmentally damaging!) than what I’m doing in 101 BASIC Poems. In a small-scale way, however, when the FOR loop in “File Not Found” runs before the printing of the next line, there is some invisible processing happening that results in a delay.

Beyond all of this, when we try to quantify process intensity we run into other problems. For the sake of comparison—although I don’t endorse this one!—let’s imagine a different program/poem:

10 PRINT "That particular drawer seems completely empty."
20 FOR I = 0 TO 999
40 GOTO 10

This one has twice as much data. Is it really any less process intensive, by any measure, than “File Not Found”?

The functioning of this program can be described pretty easily. It displays one of the ten lines represented in 90–180 at random, pauses briefly, and then does that again … limitlessly. This program/poem is based on Bergvall’s magnificent “Via,”11 a work that consists of 48 opening tercets from Dante’s Inferno, in 48 different English translations, arranged in alphabetical order.

My “Polytropon” takes only the very beginning of ten translations, or versions, of the Odyssey, before Odysseus is mentioned. Although the Odyssey has some of its own problems, I find it an immensely refreshing poem when compared to the Commedia, which dogmatically and formally asserts a great chain of being with its extensive, hierarchical subjugation. Whereas Bergvall used every translation available in the British Library to compose her work, mine is a pandemic poem. I used every translation of the Odyssey in my house. I included versions that seemed to follow or render the basic story closely—for instance, Derek Walcott’s The Odyssey: A Play—but not works that are more loosely inspired, such as Walcott’s Homeros and Joyce’s Ulysses. Odysseus is a many-turning, multi-modal (“πολύτροπον”) man, his mind always teeming, and to reflect his turns and shifts my poem presents its texts in an ever-changing pseudorandom order rather than alphabetically.

Figure 1: “Polytropon” is running on the Apple IIc on the right, where it is being displayed on a small green-on-black monochrome CRT monitor. The Commodore 64 on the left (this edition is an Ultimate 64 Elite) is running “Zip,” a BASIC poem dedicaetd to Barnett Newman, which is being displayed on the even smaller color flat-panel display.

However, it’s important that the ten short texts are encoded in the BASIC source code in a canonical, alphabetical way. This provides one more connection to Bergvall’s inspiring set of stanzas. This is one of several reasons that viewing the source—even typing it in—gives the beholder a better appreciation of this poem. The reader should be a reader of code, ideally a typist of it, and should understand the process that generates this output. The reader should, at the very least, type RUN to command the process to begin and watch it proceed with its different turns.

Even when the digital art in question is non-computational, there is an analogous distinction between output artworks and software artworks. A digital artist who has created an animation in a digital format can present the original digital file as the artwork or can record it on video. The creator of a digital image can present the file itself as an artwork or print it out.

A prime example of an artist who has done the former is Olia Lialina,12 whose GIF 89a animations are some of the most iconic artworks native to the early Web. Her artworks are the GIF 89a files, not videos of these files, which could only document them. Since Lialina offered these for people to use freely, I include one here.13

Figure 2: This embedded image, hulaol.gif, is itself an actual artwork by Olia Lialina — it is not documentation of one of her works.

With their transparent backgrounds and distinctive style, they are more than low-res looping videos. They are GIFs of extreme GIFness. Those who know what GIF 89a animations are will recognize these as being in this format immediately. Those who have no idea will be educated. This is not because Lialina simply captured the GIF zeitgeist, but also because her artwork helped to define what GIFs could be.

Indeed, Lialina’s GIFs are probably more format-specific than my BASIC poems are platform-specific. I can easily write a Perl script that does the same thing as the BASIC “File Not Found,” albeit much more rapidly:

{print "Nothing in that drawer.\n";redo}

Similarly, there’s no impediment to writing a program that works like “File Not Found,” or “Polytropon,” in a language that is commonly used today, such as Python. And I could cause each line to be output slowly, as in the BASIC program.

I should point out, however, than many people—millions of us—first learned how to write programs like these using BASIC, so it is culturally and historically sensible for these to be programs in that language. Beyond that, I am composing a range of poems; Some are less and some more specific to BASIC and to the particularities of the Apple II and the Commodore 64, and we’ll get to some of those next.

Computational Genericity versus Platform Specificity

Computational art and literature are sometimes characterized as “algorithmic,” which emphasizes their nature as abstract processes that can be enacted by any general-purpose computer. Indeed, computers can emulate one another—they are not only metamedia system, but metamachines. However, some computational works are created to engage with specific computational platforms, to particularly take advantage of what they afford or encourage. These are platform-specific computational artworks, some examples of which I present below.


an Applesoft BASIC Poem for Vanessa Place

10 FOR A = 0 TO 239
20 V = PEEK(53856+A)
40 IF (V>127) THEN PRINT
60 GOTO 10

“Complaint” has purely textual output. It endlessly outputs the error messages that are stored in the Apple II’s Read Only Memory, producing a litany that begins:


Its writing process involves appropriating existing text, as Place often does. It produces a sort of endless complaint, not exactly the sort common in legal discourse (Place works as a public defender) or the sort that has frequently been leveled against Place (a controversial figure in poetry14), but a complaint nonetheless. A similar (but not identical) program can be written for other home computers, including the Commodore 64. The one shown here produces output that is specific to the Apple II, and to Applesoft BASIC, by reaching into this particular computer’s ROM.

Although “Polytropon” can clearly be implemented in other programming languages and on other computers, my particular project, “Polytropon” is also actually specific to the Apple II. I impose a constraint on myself as I develop these poems: I must be able to write them as one-liners. When written as such, they may be very hard to read and understand—which is why I expand them into a clearer format for their eventual, canonical presentation. So long as they can be written in single line when originally composed, however, I consider them fit to print. Because the Commodore 64 only allows 80-character BASIC lines, it is impossible to encode “Polytropon,” even using that system’s keyword abbreviation, as a one-line program. The program requires the more capacious BASIC line of the Apple II, which can accommodate 240 characters.

The Apple II15 and the Commodore 6416 are extremely similar in many ways—US-made computers, based on the 6502 chip,17 on the market at the same time—they also have significant differences, some of them very literally visible because of different graphics capabilities. The next two poems showcase these differences.


an Applesoft BASIC poem in memoriam Georg Nees

10 HGR2
20 HCOLOR = 7
30 X = RND(1) * 280
40 Y = RND(1) * 192
60 I = X
70 FOR A = 0 TO 10
80 J = RND(1) * 192
100 I = RND(1) * 280
120 NEXT A
140 FOR P = 0 TO 999
150 NEXT P
160 GOTO 10

Figure 3: One sketch has been completed by “Sketches.” After a moment, this one disappears and the program begins drawing another.

What we have here is a recreation of the process behind generating each element in the grid of Nees’s 1964 23-Ecke (23-Gon, or Polygon with 23 Vertices), plotter drawings that were among the first works of computer-generated art.18 “Sketches” uses one of the high-resolution graphics modes of the Apple II, and does its sketching using BASIC commands to plot lines. These commands are not available on the Commodore 64.


a Commodore 64 BASIC v2 poem for Jasper Johns

10 PRINT CHR$(18)CHR$(28);
20 FOR I = 0 TO 39
30 PRINT CHR$(32 + RND(1) * 9);
40 IF I > 8 GOTO 70
50 POKE 55696 + 2 * I, 1
60 POKE 1440 + 2 * I, 42
90 GOTO 10

Figure 4: “Flag” on a color CRT display. At this moment, all of the stars have been drawn. The stripe at the bottom of the screen has yet to be completed.

“Flag” uses both fundamental methods of placing characters on the screen: PRINT (used in many previous program/poems) and POKE, which can set screen memory directly. BASIC originated at Dartmouth College in the mid-1960s and was first implemented on a time-sharing system, where it would have been completely unsuitable for users to directly change the contents of memory, as that would allow them to crash other people’s processes. On microcomputers, however, this ability was quite expedient. So, the first microcomputer BASIC, by Bill Gates, Paul Allen and Monte Davidoff of Microsoft, included the POKE command, to update a byte of memory directly, along with the corresponding PEEK command, which let a user’s program “see” a particular byte.

Using these two commands, “Flag” generates a Commodore 64 BASIC version of the prototypical Johns flag painting,19 producing typographical characters to recall his use of newspapers. There were forty-eight states in the United States when Johns did his first painting, so the program also places the correct number of stars on the screen. Because the stripes are continually drawn as the stars are refreshed, the flag ever waves. The Apple II does not allow individual characters to have different background and foreground colors, a special ability of the Commodore 64 that is used here and is essential to the effect of this poem.

The early flag paintings are remarkable to me for several reasons. I’m compelled by one of the formal and motivations behind the paintings: Johns did them because the flag was already there, “readymade” as a design. I appreciate not just the innovative results of his encaustic and collage technique, but also the use of cheap, available bedsheets rather than canvas. The work is also significant for raising the question of whether it is a representation of a flag or an actual flag. Perhaps there is an analogous question to ask of “Sketches.” Does the BASIC poem generate representations of sketches, or does it actually sketch?

Now that I’ve discussed how my project explores two different computers, seeking to do different things that are afforded by the two systems, I’ll turn to another computational system, and another artist’s practice, to try to further illuminate the idea of platform-specific computational art. The system is the Atari VCS (a.k.a. Atari 2600), and the artist is Yucef Merhi.20

Merhi is a conceptual artist who deals incisively with digital and computational media. There have been some intriguing Atari 2600 artworks over the years, not only demoscene productions but also the large-scale [giantJoystick] that requires collaborative play (Mary Flanagan, 2006) and A Slow Year, a 4KB cartridge with four unconventional, haiku-like games (Ian Bogost, 2010). Merhi, however, is likely the first person to have used the Atari 2600 as an artistic medium, with his first works dating from 1985. His practice is a computational one, and includes writing assembly-language code for the Atari 2600 game system—a system also based on the 6502 processor, having it run in installations of different sorts—some non-interactive, some interactive.

One project from 2003 includes nineteen televisions, each with the text “JUSTICIA,” one TV for each of the people killed in the protests against Hugo Chavez on April 11, 2002.21 One of those killed was Merhi’s cousin, and his cousin’s Atari 2600 Jr. is used, in combination with a cartridge programmed by Merhi, to produce the video signal.22 Other projects include an interactive, combinatorial poetry machine (Super Atari Poetry, 2005) that uses a trio of Ataris (with their emblematic joysticks), each connected to a TV.23 As with other Atari poetry projects of Merhi’s, this one subverts the expectation that the Atari 2600 is a visual game system rather than a verbal poetic one.

The effect of Justicia, for instance, would be very different (and much less) if Merhi had used standard Intel-based computers, or Macs, instead of his cousin’s beloved game system. It would also not be as surprising to see a poetry machine made from contemporary computers, which we know to have text-processing capabilities. Creating a looping video and putting an inert Atari VCS in front of the display would probably have been even more unsatisfying. His selection of platform, and his having the platform actually generate the art directly before the viewer, has been essential to the way he engages with culture through this computational work.

Personal Identity and the Expression of Cultural Experience

Having introduced my sort of platform poetics, I’m compelled to address another dimension of my 101 BASIC Poems project, namely, that each poem is directly occasioned by the creative work of a particular poet or artist.

The people to whom I refer are not all people I know or have known personally, but they are all people who have been influential in my own practice in some way. 101 BASIC Poems will not end up as a complete catalog of those influential to my work, because I will work through the importance of other practices—such as David Ferry’s—in different projects. But I hope it provides an interesting perspective on the work that has been important to mine.

I’m influenced by people who are quite different from me in terms of background, experience, and identity—isn’t everyone?

Sometimes I may choose to base a poem on a text by someone who (seemingly) is more like me. “File Not Found” is based on a poem of fourteen identical lines by Ron Padgett, a white guy. I could have written a similar infinitely looping poem based on “Sonnet” by Terrance Hayes, which is a fourteen-fold repetition of the line “We sliced the watermelon into smiles.”24 Now, in some ways Hayes is actually much more similar to me than is Padgett: He and I are almost the same age, for instance. Hayes’s poem, unlike Padgett’s, is in iambic pentameter, which appeals to my formalist tendencies. I think his poem is more complex than Padgett’s, because (in my reading) it manages to capture the continual “We Wear the Mask” pressure to smile in the face of African-American stereotypes while also evoking the genuine pleasure of recurring family picnics and barbecues, all in only six unique words. It, too, has a deictic word, pointing outside the poem: “we.” This “we” doesn’t include me. This “we,” like “that” in Padgett’s poem, may not have exactly the same meaning each time. Perhaps “we,” in this sonnet, not only endure, but also connect and grow. My reading could be overly optimistic, but even those who disagree will have to admit that the poem provides a tremendous amount to think about.

So, what about this hypothetical BASIC poem dedicated to Hayes that I didn’t write? Essentially, I didn’t think that extending what Hayes did fourteen times in an ever-looping BASIC verse made for a good poem. “File Not Found” obviously refers to the computer’s ability to (inanely, incessantly) look for something and not find it, which plays on the humor of Padgett’s original poem. But I wasn’t sure what title I could give to the other, hypothetical poem, or what an endless stream of Hayes’s line would really mean to me or anyone else. Not only would the endless extension not be meaningful from my perspective, it would also break one very compelling property of the original poem—that it is a formally valid sonnet, schematically rhyming (using rime riche) and of the right length, like Padgett’s, but also properly metrical.

I don’t rule out writing any BASIC poems because of my ethnoracial standing, however. One of my poems does deal with African-American experience, by reflecting on and reworking a particular artwork that I greatly admire: Glenn Ligon’s painting Untitled (I Am a Man).25 This is a representation of one of the uniformly printed signs held by Black sanitation workers in Memphis during a historically important 1968 strike. The painting is typographically authentic (as my poem is not) and has its own fine material aspects that are not reflected in my poem.26 My Commodore 64 BASIC poem presents an endless upward march of the text “I AM A MAN,” in the default, monospace font, with “AM” underlined. I hope my poem does something important to memorialize this event, to keep it animated in memory—something I think is the responsibility of citizens, history writers and teachers, and poets and artists of all races. The output of “I AM A MAN” consists of texts that are digitally identical, but each begins on a random column of the screen and so the procession of texts has different indentation. In this way, I’ve attempted to join the uniformity of message to the individuality of those who marched.

Platform Deniers

By now, I hope you have a sense of how my own artistic and literary practice is not just a computational one, not just one in which I share the software as art, but also one specific to particular computer platforms. I don’t undertake this work as a nostalgia trip (at least, not one that is restorative27). My work is a way of reflecting on these systems, not mainly as components of my individual past and the home from which I came, but as culturally significant developments, intentionally made to widen access to computing.

Because I have focused on my work while discussing that of Lialina and Merhi, you might imagine that everyone working in all sorts of digital and computational art ends up powerfully and profoundly grappling with their chosen formats and platform. That’s not actually the case. The different impulses of demosceners and videogame developers go a long way toward explaining why platform practices aren’t the only sort.

In the demoscene, the categories of competition divide along platform lines. There are even demoparties specific to platforms, including the Commodore 64, or a particular company’s computers, such as Atari’s. Those who develop demos (coders, musicians, and graphicians) specialize in particular platforms. The awareness of platform flows out into the technically adept audience at demoparties. Productions are judged not on how great they are as pure audiovisual spectacles, but on how they exceed people’s expectations regarding what a particular computer platform can do.

Modern game development is an almost opposite case. The rise of engines such as Unity allows developers to write a “generic” 3D game and simply output it so that it can be run and played across platforms. Most contemporary game developers, however indie, seek to factor out the platform.

So, the demoscene is inclined toward platform specificity and game developers, those platform deniers, toward computational genericity. This doesn’t mean that the former group of computational artists address more challenging themes or that this community is more aesthetically sophisticated. One can and should find exceptional work done by sceners and game developers. While doing so, it’s important to understand how some engagements with the specifics of computer hardware design, and with the history of popular computing, and the particular domain of platform-specific artists.

Those of us trying to deeply engaging with specific computer platforms may reach fewer beholders than contemporary game developers do. Though careful consideration of material and formal specifics, however, our explorations can offer unique insights into the relationship between computing, creativity, and people. Thus, I persist in my platform-specific practice.

  1. I describe the range of my practice as a computational poet and artist in Montfort, Nick. “256B on the C64 for 8K.” Proceedings of the 2019 on Creativity and Cognition (C&C ’19). New York: Association for Computing Machinery, pp. 497–501, 2019, doi:10.1145/3325480.3329174↩︎

  2. Paul, Christine. Digital Art. London: Thames & Hudson, 2003. The book is available in three editions. The “Software Art” section is a page long in all of them.↩︎

  3. Some of my work on this project has been documented (Montfort, Nick “Lines of Commodore 64 Poetry.” Convolution 5-7, pp. 201–212, 2019) and published (Montfort, Nick, “Three Commodore 64 Poems,” Notre Dame Review 48, pp. 153–160, Summer/Fall 2019). Two poems and a short essay of mine, “‘Complaint’ and ‘Polytropon’ from 101 BASIC Poems: Poems Stuck in English,” are forthcoming in a special digital literature issue of Text+Kritik.↩︎

  4. Ahl, David, ed. 101 BASIC Computer Games, Maynard, Mass.: Digital Equipment Corporation, July 1973. Many other editions of the book were published without “101” in the title, including ones for microcomputers, for specific microcomputers, and in languages other than English.↩︎

  5. Padgett, Ron, “Nothing in That Drawer,” Great Balls of Fire, Minneapolis: Coffee House Press, p. 5, 1990.↩︎

  6. Wardrip-Fruin, Noah. Expressive Processing: Digital Fictions, Computer Games, and Software Studies. Cambridge, Mass. and London: MIT Press, 2009.↩︎

  7. Crawford, Chris. “Process intensity,” Journal of Computer Game Design 1(5), 1987. Republished online: https://www.erasmatazz.com/library/the-journal-of-computer/jcgd-volume-1/process-intensity.html↩︎

  8. A large repository of such demos: https://pouet.net↩︎

  9. The Sizecoding wiki — http://www.sizecoding.org/wiki/Main_Page — offers practical advice to those writing very tiny demos.↩︎

  10. Montfort, Nick. The Truelist. Denver: Counterpath, 2017. The program that is part of this book, and that generated the first 140 pages, is free software and online: https://nickm.com/code/truelist.py↩︎

  11. The work is a sound installation documented online — https://carolinebergvall.com/work/via-48-dante-variations/Bergvall, Caroline. “Via: 48 Dante Variations.” Fig: Goan Atom 2, Cambridge, UK: Salt Publishing, pp. 63–71, 2005.↩︎

  12. Lialina, Olia, “Olia Lialina’s work (former FIRST REAL NET ART GALLERY),” 2021, http://art.teleportacia.org/↩︎

  13. Lialina, Olia. [Hula Hoop GIF.] 2005. http://art.teleportacia.org/exhibition/AGM/hulaol.gif↩︎

  14. See, for instance, Calder, Kim, “The Denunciation of Vanessa Place,” Los Angeles Review of Books, June 14, 2015, https://lareviewofbooks.org/article/the-denunciation-of-vanessa-place/↩︎

  15. I use an Apple IIc, specifically, when writing my Applesoft BASIC poems for Apple II computers. The original Apple II was introduced in June 1977, while this model was introduced in April 1984. By this time, Apple had released the first model in a different series of computers, that would go on to be quite successful: The Macintosh.↩︎

  16. The Commodore 64 was introduced in August 1982. I have used original “breadbox” Commodore 64s for most of my poem writing so far, although I have recently acquired an Ultimate 64 Elite, a modern-day FPGA reimplementation of Commodore’s “official” computer in hardware, and have made use of this system. I have no problem using this new “hardware edition,” and do consider it to be another, very good, edition of the Commodore 64, as discussed in Fernández-Vara, Clara and Nick Montfort, “Videogame Editions for Play and Study,” Trope Report TROPE-13-02, October, 2013 — https://tropetank.com/reports/TROPE-13-02.pdf↩︎

  17. C64 aficionados will surely note that the computer actually uses the 6510. This is a microprocessor of slightly different design with the same instruction set as the 6502. Some later computers in the Apple II line also used different 6502-compatible chips. For instance, the Apple IIc I use to program my Applesoft BASIC poems has a 65C02 processor.↩︎

  18. Although low-resolution, an image of this work is online — http://dada.compart-bremen.de/item/artwork/639 — as is code: http://dada.compart-bremen.de/item/algorithm/5↩︎

  19. E.g., the one documented online here: https://www.moma.org/collection/works/78805↩︎

  20. Merhi, Yucef. “Yucef Merhi,” http://www.cibernetic.com/↩︎

  21. The project is documented in a video online: https://www.youtube.com/watch?v=BKFfN9jxV2M↩︎

  22. Mawad, Tony Frangie. “Yucef Merhi: ‘Restablecer nuestra memoria cultural será un gran esfuerzo colectivo,’” Cinco8, June 20, 2020, https://www.cinco8.com/perspectivas/yucef-merhi-restablecer-nuestra-memoria-cultural-sera-un-gran-esfuerzo-colectivo/↩︎

  23. See the Atari section of Merhi’s official site for documentation of this and other projects.↩︎

  24. Hayes, Terrance, “Sonnet,” Hip Logic, London: Penguin Books, 2002.↩︎

  25. The painting is documented online: https://www.nga.gov/collection/art-object-page.159784.html↩︎

  26. These and many other aspects of the painting are discussed in detail in Bordowitz, Gregg, Glenn Ligon: Untitled (I Am a Man), London: Afterall Books, 2018.↩︎

  27. Boym, Svetlana. “Nostalgia and its discontents,” The Hedgehog Review 9.2, pp. 7–19, 2007.↩︎