[NetBehaviour] code as literature as idiom

Rob Myers rob at robmyers.org
Mon Jan 27 01:23:52 CET 2014

On 26/01/14 01:36 PM, Bishop Zareh wrote:
> As a Programmer and as an Artist, I can tell you that I frequently
> write Code as Literature, with the express intent of having it read
> rather than executed. At first it came from what they called "airplane
code." Before airplanes were connected to the internet, especially
during the era of "enterprise computing" no code could be run on an
airplane because the compiler was online, on vpn even. Yet programmers
with good intuition and experience could still write, even during an
8-hour flight - all sans compiler. Airplane Code was not poetry; it was
not meant to be read, but when the programmer's prediction of the
compiler's reaction became unclear, programmers resorted to psuedo-code
buried in comments, for their eyes only but none-the-less written in a
hybrid language of intention and execution - a combination of what they
wanted and what they thought could work. And then the programmers
starting showing these psudeo-codes to each other.

Laptops with batteries that will last for most of a domestic flight have
been commonly available since the 90s and compilers for Java or COBOL
would run on them. If you wanted longer usage times, more batteries were

Compilers at low levels of optimization are pretty deterministic.

If we're talking about mainframe programming or integrating with
server-side frameworks without decent mocks then that's what
documentation is for.

And if we're talking about pre-laptop AFK coding with pen and paper it's
easy enough to write code in full that way. Psuedocode in that context
would be more about DRY or documentation access than compiler issues.

Programmers do write pseudocode to communicate, and may be forced to by
management, but this has a history that is independent from the category
or era(s) of enterprise computing.

"A hybrid language of intention and execution" is code, not psuedocode.
Code has to be run. Without running there is no execution and, with
apologies to Lua and HyperTalk, by definition pseudocode does not run.

This is the core problem of code poetry and code as literature. Software
is written firstly for human beings to read, but formatting literature
as code doesn't make it code and variable names tend not to be
semantically significant to runtimes. There needs to be something
meaningful in the code's execution in a literary way and this needs to
relate to its syntax.

> Then there comes Programming Education, where code tutorials are
designed to be read by students, and the Open Source Community's
tradition of having "well-commented source." Both with brilliant
asides/insertions like "insert calculus here." These practices formed a
toolkit for writing code as literature.


> GIST was designed for just this
purpose. GIST uses the same principals (*sic*) as GIT, but is designed
to be code that is read, rather than compiled.

A Gist is a Git repository. Like Github's main use of Git it's an
enclosure and a Facebookization, in this case of the pastebin market.
pastebin.com for example dates back to 2002 and was not dedicated to code.

Code sharing communities date back to the dawn of computing and their
suppression by enclosure, by "Intellectual Property" law, is what gave
rise to Free Software in the first place.

Sharing non-executable code is weaker than sharing executable code.
Complaints about incomplete and non-running code provided in questions
on StackOverflow are about community and value.

> I was surprised it did not come up in the initial discussion, and
wanted to mention it here.
> A step from GIST to Literature is not hard to see, especially among
dilettante and savant programmers, passing messages/documents around,
working without warrant or language, double especially for the ones

If code as literature is simply "code with funny variable names that
probably doesn't run" then that is disappointing. If it's "code as the
shared communication of a community" then this long predates GitHub's
enclosure. But that doesn't explain how it's literature.

If we take a more abstract view of literature as a written means of
promulgating worldviews and values and of building community and of
resolving contradictions in ideology then code can be that. But
literature is not unique in its capacity for that, and it's not clear
why we should call code that performs these functions literature rather
than law (cf. Lessig) or religion (cf. Jobs).

> called "artists". The realz question is why these coppers be bangin' on
our Lit yo. Its gots to be about power 'cause if iran-contra was
theater, then wtf. its Eitha' 'bout weapons or influence dog && my
moneyz on influence.

It's a matter of ego.

Hackers are often ignorant of the problem domain of literature and
litterateurs are often ignorant of the problem domain of hacking. It's
easy to make code that looks superficially like literature or literature
that looks superficially like code and to seek their perceived higher
status in a particular social domain. What's much harder is to find a
synthesis of the affordances and demands of the two that actually does
useful work in either problem domain.

There's More Than One Way To Do It, and people do do it, but it's not
easy, and it's certainly not a product of corporate enclosure of time or

- Rob.

More information about the NetBehaviour mailing list