Esopo

    other woodwork
        like a folding
       up, a
      branch-work growth
                  of
          AshPaper trees come together
    as we demand
          perfect edges, impossible creases
      a Scream of roots
        toe-curled
        inward
    gro(w/a)n
        past lines of pebbles, into wellstones
                                  cracked. broken.
    perfect edges impossibly creased
    what's left of that?

Summary

Medium: Language specifications for esoteric programming languages with Javascript implementations

Status: Ongoing

Project webpage: https://github.com/wphicks/Esopo/

Review: https://esoteric.codes/blog/esopo-turing-complete-poetry

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

The informal specifications for Correspond are available here.