chapter 1

CHAPTER 1

1983, SPRING

CINCINNATI

I love the way a computer program doesn’t just describe something: it is the thing.

Words between people—normal language—is like a glaze over the realness of action and being. A bubble, not something you can touch or count on. But code is the doing, is the thing: words and syntax and rules creating their own world, their own existence. Everything the code needs is there, inside the computer.

I tap this semester’s passkey into the door on Baldwin Lab. I get access to the lab because I’m taking freshman Computer Syntax 101, although it’s a bullshit class; I could do most of the assignments in my sleep. This is where I come, though, when I don’t want to go home and face Sheila the Mother, or when Veronica is busy with Jack.

Down the hallway, there’s a grody water cooler, and then the lab, with its twenty Apple IIs and ten terminals hooked into the MUD, a broken clock, no windows, and three rules:

1. No food or drink

2. Save it to a floppy because it will get deleted

3. Don’t touch anyone else’s keyboard

The TA on duty doesn’t care if I work on personal projects, or if I listen to my Walkman with Television or the Clash turned up to eighteen. The glow of the monitor screen washes without judgment over my ripped jeans, my band T-shirts, my dyed-black hair. It feels like freedom.

When I told you, on our weekly call sometime near the start of high school, that I was taking Computer Basics, you got so excited, thinking I was learning BASIC. Back then, I didn’t even know what a programming language was. I sat there, coiling the phone cord around my fingers in Bubbe’s kitchen, which was the only place I called you from, because of Sheila. You described the possibilities of machine learning, and it was like you were speaking to me not from the East Coast, but from somewhere else in time, from some other world.

“You’re going to love it,” you said. “It’s the language of the future.”

I never told you this, although I think you would have laughed: the next day, I stopped by the high school library to see if they had any books on BASIC. I wanted to close the gap between what you’d thought I was learning and the rudimentary typing lessons I was getting in class. The librarian gave me some issues of Creative Computing: I tried to memorize the most obvious commands—LET, PRINT, GOTO, IF—even as my mind tumbled through all the ones I didn’t understand yet: DIM, CHR$, TIME versus TIME$. That same day after school, on a TRS-80 at the RadioShack downtown, I tried typing Valley Bomber, one of the programs printed on thin newsprint in the magazine’s back pages. Command after command after command. It seems so improbable, so strange—that shapes rendered in ink-on-paper could become something else inside the computer, but they can. In the game, the player flew through a valley surrounded by mountains, dropping bombs in the narrow stretch between the heights. I thought, while I was typing it all in, that I wouldn’t mind destroying some mountains. Just destroy it all, maybe.

The game didn’t work. I arrowed up through the lines of code, searching for what I’d done wrong, but the glowing letters swarmed opaquely, refusing to show me. After a week of typing the same sequence in over and over, I found the problem—I’d messed up something simple in the syntax.

But I’d gotten a taste of something. I went back to RadioShack again and again to the code, tossing my backpack under the counter and avoiding eye contact with the salesmen so they wouldn’t bother me. Once the screen booted up, I could be invisible for a while. Not a loner, not a disappointment of a daughter.

Later that year, I would meet Veronica and she would make me less of a loner, even if I stayed a disappointment to Sheila. But when she and I weren’t together, all I wanted to do was slip inside the programs like they were castles, made of logic rather than stones. With a Replacements tape blaring in my headphones, I taught myself to code from a copy of 100 BASIC Computer Games. That’s the book the librarian found for me after I’d burned through all her issues of Creative Computing.

And then, when you thought I was ready, you sent me a letter with the first part of a program, handwritten on a sheet of yellow legal paper. I understood the first few commands—naming the program, a REM line saying [This program will put the wind in your sails], but after that I got lost. What were the commands drawing on the screen? Impossible to tell from just the coordinates. I’d have to see them. The unfinished lines of code beckoned, an invitation to a new world where I was smart, I was important. You programmed real games in Cambridge, but you made time to write code with me. That first program: when we finished it, it drew a sailboat that disappeared into the horizon as the sun set.

Here is one of the things you taught me: every program is like a conversation in which the programmer asks one question over and over again, “How do I make the code do X?” and the code answers, offers a cascade of answers. The result is a personal, intimate kind of logic, and although the code itself might look dry and alien, the choices embedded in it—the defining of variables, sequencing of commands, layering of functions—are like a map of the programmer’s mind.

But you didn’t just teach me to make games, you taught me to love them, too. We worked through the rooms of Zork, each of us making our own grid paper map to mark the grues. We assembled ships in Pirate Adventure. We debated whether The Prisoner was a good game or just a good thought experiment.

And now, almost exactly four years after I started that dumb freshman computer class, I know more than enough BASIC to write a program to calculate the number of days since you died: thirty-seven.

The code I write doesn’t have feelings and it doesn’t care about mine. It either works or it doesn’t. When typing it into the Apple II, I have to stay focused. The fact that you are dead, that you are not in the world anymore, is like a strong magnet held against a cassette. Data—feeling—flattened into irretrievable nothing. But in the code, there are rules and patterns I can rest against. I know where I’ve been and where I’m going.

By the time I’m done today, it’s almost time for the lab to close. I hit RUN.



The TA on duty comes over. I slide my headphones off.

“Bug in the code?” he asks.

The expression came from a literal bug in a computer—that’s the story you told me—a moth trapped in the electrical relays, pulled out by Grace Hopper and taped into a logbook with the annotation “First actual case of bug being found.” A moth, pinioned in the relays, yielding only an error; whatever was intelligible, lost.

Here and now, it would mean: I typed something in wrong, transposed characters or inverted syntax, or even missed a command entirely.

I shrug. “Yeah.” I hit delete and the program’s text evaporates from the screen. “I’ll try again later.”

I get up and go out into the blazing spring evening to take the bus home. I’m thinking about patience, and how, in order to have patience you have to have hope or faith, or some clear idea that it gets better. I’m thinking about all the games you’ll never write, about the body of a moth pressed between relays, about lines of code that yield only “error,” so you have to rewrite it, every line. You can’t do that to a person: scroll through the logic and commands that make them who they are, rewrite the bugs. We run through life once, and when it’s over—when you hit an error—it’s just over, no one waiting to help you fix the mistakes.