"Code is language

from the start.

Code is not merely written.

It is enacted."

Zeroichi Arakawa, interviewed by Kate Vass — Japan

Kate Vass: Executed Poetry transforms code from a technical instruction into a performative act. At what point does code stop being software and become language?

Zeroichi Arakawa: I don't think there is a moment when code stops being software and becomes language. Code is language from the start. The question feels a little like asking when words become poetry, and I don't take poetry to be a deviation from useful language: code can be useful and poetic at once. The same lines look like an instruction when read for their output, and like a poem when read for their structure, their state, their conditions, and the places where they might fail. Nothing switches on inside the code itself. Seeing poetry in code isn't new, either. Noël Arnaud's Poèmes ALGOL (1968) couldn't be executed, but it made poetry out of a way of relating to a language, and it's in that relation, between a writer and a number of readers, that I'd locate the poem.

KV: Conway showed that simple computational rules can generate unexpectedly complex behaviour. Your work shifts the focus from generating behaviour to verifying executable language. How do you see Executed Poetry extending or departing from that lineage?

ZA: It's a good question, and it sent me back to what Conway was actually doing. Even he was continuing something older, and what he was after wasn't rich output so much as a rule whose behaviour you couldn't decide just by looking: something that stays hard to prove. I feel close to that. Still, I hesitate to place myself for or against a lineage; they tend to be drawn afterwards. I'd rather look for what the works here share, and think about how to carry it forward. For me that shared thing is the relation between something written and its coming into effect. What draws me is the side of that relation that can be read and verified.

For me, execution is closer to verification than to generation. To be executable is to be verifiable, and that matters. There's a real gap between what compiles and what doesn't, what runs and what doesn't. But being executable doesn't make something a poem: it's only one of the conditions to be met. My poems don't reduce to their rules or algorithms.

I wouldn't say poetry here "emerges" from execution. It lives in the act of a reader verifying the structure a writer has left behind. Whether that code was written by a person or by an AI may not be essential. I increasingly write in dialogue with AI myself, but what counts isn't the resulting code so much as how you face it, and how you test it through execution.

The piece may sit at an angle to the works around it, but I don't think it stands outside them: we share that basic question about what it means for something written to come into effect. Where I'd like to carry it, though, is toward work that asks something of the reader: to think for themselves, to doubt a little, to notice where they're trusting a surface and where they could check what's underneath. Not work that only looks good on the surface, but work you have to read. I find myself wanting more of that, and making more of it, because it feels like something this moment quietly needs. As more is generated for us, deciding for yourself how much to take on trust, and where to verify, seems to matter more, not less.

KV: In traditional poetry the text exists before it is read. In Executed Poetry, the work seems incomplete until someone runs it. Where, for you, does the artwork actually reside—in the code, the execution, or the experience?

ZA: In the sense that a text exists before it is read, traditional poetry and poetry-in-code aren't so different. What differs is that we already live inside a world computers have made, so a poem in code comes with a set of attached parts: the source code, the machine, the trigger for execution, the display, the person who executes it, and the record of that execution. The work doesn't sit in any one of these. It sits in the whole arrangement.

The original, physical Executed Poetry came out of exactly this concern: that the source code printed on paper, and only that, would be taken for the work. There is still no established form for what a poem in code should be as an artwork. So I find it hard to think of the work as residing "in the experience." What execution leaves behind is closer to a structured absence and a partial attestation. Nor is the work completed by being executed. How far a reader can verify it for themselves, and the fact that the code a reader writes to check it stands on the same plane as the code of the work: that is where I'd put it.

KV: As software increasingly generates language alongside humans, what distinguishes an instruction from a poem? Can computation itself become expressive, or does meaning only emerge through interpretation?

ZA: Whether the code was written by an AI or by a person, and whatever the author's intent, we need a way of reading that works the same either way. As I said above, what separates an instruction from a poem lies not in a property of the code but in how it's read. So I can't quite settle into either of the two options: that "computation itself is expressive," or that "meaning emerges only through interpretation." You can't tell from the source code alone, and you can't tell from the computation alone. Meaning arises between the two, in the practice of reading code while verifying it. This is probably a mode somewhat distinct from interpretation, though that's something I'm still checking carefully for myself.

KV: The exhibition ultimately asks a single question: Can emergence itself become conscious? If Conway revealed how simple rules could generate life-like behaviour, what do you think emerges once those same rules begin generating language, memory, and shared culture?

ZA: I'd rather not answer this one too neatly. What I want isn't so much an answer as a careful look at a place in computer-based art that hasn't been touched much, and to get others looking at it too.

What computers produce has already worked its way into this messy world and can't be erased. It's already culture, and already memory. If that's so, the question isn't how we generate it but whether we take it as a finished result to be looked at, or as a structure that can be read and verified.

And what accumulates seems to me closer to a series of partial attestations than to a preserved record. The attestations remain, but the events they pointed to don't return. What remains has been selected.

Artist Profile

Next: Society — Part III of III

— 27th August