Description

Among both digital language artists and more conventional programmers,
there is a long history of human-readable poetry written in languages
intended for computation. From Larry Wall’s famous Black Perl to Alan Sondheim’s codework, these pieces play at the
interface between related languages with decidedly different intended
uses. As John Cayley points out in his essay
The Code is not the Text (unless it is the Text), this
interface is a somewhat problematic one. By writing code primarily for
consumption by a human reader, digital artists all too often make “a
simple point based on digital transparency and translatability… and this more
or less exhausts the significance and affect of the work.”

For serious coders, this point is so commonplace that any extended
treatment of it becomes annoying at best. Such writers (or readers),
however, may access additional layers of significance through an
appreciation of the connection between the natural-language surface of
the text and its algorithmic expression. For these writers, the
structures inherent in algorithms and algorithmic language offer a
natural-language constraint in much the same way that the Oulipo deal
with poetic constraint. And just as the success of Oulipian literature
depends in part on the beauty of these imposed poetic structures,
successful codework depends on the beauty of its own algorithmic
structure. Finding ways to non-trivially engage with the relationship
between these structures and natural language (particularly in a way
that remains accessible to non-coding readers) presents a significant
challenge.

Esopo is an ongoing project intended to directly grapple with this
challenge through yet another playful practice in modern coding culture-
namely the development of esoteric programming languages. Esoteric
languages can in principle be used to implement any algorithm, but use an
impractical syntax (often to comedic effect).
Prominent examples include Whitespace (a
language written entirely in whitespace characters), Shakespeare (a language
written in the style of an Elizabethan theater script), and Ook! (a language writen in “Orangutan words”). In
the Esopo project, new programming languages are developed using
techniques characteristic of natural-language poetry to specify
algorithmic instructions. Thus, the requirements of the desired algorithm
directly specify poetic constraints for the code but do not make further
demands on the content of the text.

Crucial to the aesthetic success of this project is a careful
consideration of the relationship between specific linguistic constraints and
their corresponding algorithmic instructions. What should enjambment
signify in the world of algorithms? What command ought to correspond to
end-rhyme? These relationships certainly should not be random, or else the
structure of the resultant texts will not meaningfully reflect the
structure of their signified algorithms. But neither should these
relationships be stultifyingly illustrative.

Esopo introduces several languages, each proposing different answers to
these difficult questions and thereby fostering different aesthetics in the
poetic code they invite. Some are designed to compile almost any text they
receive as input, while others demand strict adherence to certain formal
rules. Other languages are designed not so much to encourage production of new
algorithmically-engaged text as to draw attention to the structure of
existing work. For instance, Emily is a language designed to compile the
poems of Emily Dickinson to non-trivial algorithms by making use of poetic
techniques Dickinson regularly employed throughout her work. While the
algorithms thus produced are of little practical interest, they highlight
interesting patterns in the linguistic structure of these pieces.

The eventual goal of the project is to provide a web-based Javascript
interpreter for all of the Esopo languages, thereby encouraging writers to
experiment at the intersection between algorithmic and natural-language
structures. As these languages evolve and more poetic code is produced, this
project will invite ever more sophisticated interventions in this liminal
zone.

Examples

The poem at the top of this page can be used to calculate factorials using one
of the Esopo languages known as AshPaper. For complete information on how
this works, including annotations of this example, take a look at the
informal specs for AshPaper in
the Esopo repository. You can also try
it for yourself here via a Javascript interpreter that handles all
but the end-rhyme feature of the language. The repository contains a
(slightly more reliable) Python-based interpreter that correctly parses
end-rhyme.

As another example, the following “letter” can be used to multiply two
numbers using Correspond, another Esopo language based on literal
correspondence by mail:

Dear Reader,
I do not expect a reply. What did I describe last? Sand and dust
on a white table. Who would have responded to that? I can't even
remember why I wrote about it. Does it still matter?
Always,
Your Writer