Hello, Globe

Monday 25 April 2016, 4:45 pm   ////  

On Saturday, the 400th anniversary of Shakespeare’s death (and, happy birthday, too, Will), I delivered to Twitter, via post-haste dispatch, the following four Commodore 64 BASIC programs, versions of the famous “Hello world” program:

400 ? chr$(147)"hello world":for a=1 to 500:next:? chr$(19)"brave":new:rem #c64

400 ? chr$(144)chr$(79)chr$(84)"hello world":rem #c64

400 ? "hello world"chr$(4^3+(2b or not 2b)):rem #c64

400 for a=0to255:? chr$(147)spc(a)"(QRQ) hello world":next:? chr$(147):rem #c64

Type ’em in to a for-real Commodore 64 or to this Web-based emulator here. No special characters are involved, so entering these programs should be easy; lowercase letters will appear capitalized and the few capital ones will appear as graphical symbols.

Let me know what you think … and if you see the relationship to four of Shakespeare’s plays.

Great Workshop for New Programmers at Babycastles

Monday 25 April 2016, 1:41 pm   ///////  

I had a launch event Saturday afternoon for my new book, Exploratory Programming for the Arts and Humanities. Not a typical reading or book party, but a workshop for people completely new to programming but interested in pursuing it. It was at the excellent gallery and venue, Babycastles, on West 14th Street in Manhattan.

I don’t actually have the list of attendees – I’d like to sent everyone a note, but it will have to wait! – but two people I knew beforehand participated and ten others joined in, with some people from Babycastles also participating and helping out. (Special thanks to Lauren Gardner for hosting!) I was very glad that the group was diverse in terms of gender, race, background, interests … also, pleased that this time around we had more people who were genuinely new to programming. I’ve done similar workshops before, prior to the publication of Exploratory Programming, and often there are folks who have had some programming classes and done some programming projects before. I’m glad to help such people as they re-start work with code, but I tried to make sure this time that there was no crypto-prerequisite suggested; the session really was for those wanting to program but lacking background.

Of course we dealt with programming as culturally situated and meaningful within art, poetry, writing, and inquiry. We used the historical Memory Slam examples that I prepared a few years ago for another event in Lower Manhattan.

Because the book is out and registration for the workshop included a copy of it, I didn’t feel the need to go through particular code examples that are in there. I was able to frame the whole idea of programming and focus on a few early specifics in both JavaScript and Python – showing that code is just editing a text file; that there’s a difference between code and data (and parameters, too); and that error messages can be helpful rather than frustrating. We did work with specific code, but didn’t cover specific code discussions in the book or the exercises in there. The book is for use in a classroom, but also for individual learners, to allow people to continue their work as programmers formally and informally.

Many people introducing a new book will have book parties, with or without readings, that draw a much larger crowd that this event did. But, as Brian Eno said about the Velvet Underground’s first album, not many people bought it but all the people who did started a band. I hope everyone who participated in this modest event at Babycastles goes on to start a band, by developing a programming practice engaged with the arts and humanities.

Update: I should have mentioned – we’ll have a similar workshop on May 15 at the School for Poetic Computation!

Language Hacking at SXSW Interactive

We had a great panel at SXSW Interactive on March 11, exploring several radical ways in which langauge and computing are intersecting. It was “Hacking Language: Bots, IF and Esolangs.” I moderated; the main speakers were Allison Parrish a.k.a. @aparrish; Daniel Temkin DBA @rottytooth; and Emily Short, alias @emshort.

I kicked things off by showing some simple combinatorial text generators, including the modifiable “Stochastic Texts” from my Memory Slam reimplementation and my super-simple startup name generator, Upstart. No slides from me, just links and a bit of quick modification to show how easily one can work with literary langauge and a Web generator.

Allison Parrish, top bot maker, spoke about how the most interesting Twitter bots, rather than beign spammy and harmful or full of delightful utility, are enacing a critique of the banal corporate system that Twitter has carefully been shaped into by its makers (and compliant users). Allison showed her and other’s work; The theoretical basis for her discussion was Iain Borden’s “Another Pavement, Another Beach: Skateboarding and the Performative Critique of Architecture.” Read over Allison’s slides (with notes) to see the argument as she makes it:

Twitter Bots and the Performative Critique of Procedural Writing

Daniel Temkin introduced the group to esoteric programming languages, including several that he created and a few classics. He brought copies of a chapbook for people in the audience, too. We got a view of this programming-language creation activity generally – why people devise these projects, what they tell us about computing, and what they tell us about language – and learned some about Temkin’s own practice as an esolang developer. Take a look at Daniel’s slides and notes for the devious details:

Esolangs: A Guide to "Useless" Programming Languages

Finally, interactive fiction author Emily Short reviewed some of the classic problems of interactive fiction and how consideration has moved from the level of naïve physics to models of the social worlds – again, with reference to her own IF development and that of others. One example she presented early on was the challenge of responding to the IF command “look at my feet.” Although my first interactive fiction, Winchester’s Nightmare (1999) was not very remarkable generally, I’m pleased to note that it does at least offer a reasonable reply to this command:

Winchester's Nightmare excerpt

That was done by creating numerous objects of class “BodyPart” (or some similar name) which just generate error messages. Not sure if it was a tremendous breakthrough. But I think there is something to the idea of gently encouraging the interactor to o play within particular boundaries.

Emily’s slides (offering many other insights) may be posted in a bit – she is still traveling. I’ll link them here, if so.

Update! Emily’s slides are now online — please take a look.

I had a trio of questions for each pair of presenters, and we had time for questions from the audience, too. The three main presenters each had really great, compact presentations that gave a critical survey of these insurgent areas, and we managed to see a bit of how they speak to each other, too. This session, and getting to talk with these three during and outside of it, certainly made SXSW Interactive worth the trip for me.

There’s an audio recording of the event that’s available, too.

Explorers of Bottomless Pit Return with Treasure

Tuesday 8 September 2015, 5:04 pm   ///////  
They found the key.

They found the key.

Far from plunging us into darkness, Reading Project: A Collaborative Analysis of William Poundstone’s Project for Tachistoscope {Bottomless Pit} provides brilliant and multifaceted reflections on a rapid, serial electronic literature work. (You can read Bottomless Pit for free online, by the way, in ELCv1 and on Poundstone’s site.)

The party that sets out on the adventure of this reading is Paladin Jessica Pressman, who seeks truly through media archeology and quests into thorny literary theories; Thief Mark C. Marino, who slyly reverse-engineers the program and acquires the source code, stealing sequences of words and images along with how they are produced; and Illusionist Jeremy Douglass, who summons visualizations of the piece that dazzle but also unfold new understandings. They ascend from the endless passage of Project, and from the dungeon of collaboration, with numerous new insights, showing how different reading strategies – ranging from rather conventional to quite novel – can inform one another. There’s so much background offered (etymological, historical, bibliographical) that one imagines it being drawn out of a bag of holding. The view of the project that emerges seems beyond what a Beholder would be able to comprehend.

These three cover the fundamental workings of Project well, showing the role of randomness (a saving throw of sequential words does not abolish chance) and how individual pixels shine during a loop of the main story text. What this text means and alludes to, and the presence of a second sequence of less coherent words, is also discussed, and connections are made between such meanings and references and the piece’s material and technical aspects. From the media technology of various historical tachistoscopes to the nature of the pit in Freudian psychoanalysis, there is a great deal about Project that is – let’s not say excavated, but illuminated – in this book.

In its engagement with computation, the relationship of recent computational work to historical and literary concepts, and in the way it helps to develop productive collaborative approaches in the humanities, this is a landmark investigation – almost surely deeper than you imagine. It’s essential reading for those interested in digital literature, but also also for anyone (concerned with e-lit or not) who wonders how humanistic thinking can continue to develop and how thinkers can work together in new ways.

Paging Babel

Wednesday 26 August 2015, 2:20 am   ////////  

About 12 hours ago I was reading “The New Art of Making Books” by Ulises Carrión, a text I’d read before but which I hadn’t fully considered and engaged with. As I thought about Carrión’s writing, I felt compelled to put together a short piece on the Web. That took the form of a Web page containing a rapidly-moving concrete poem. The work I devised is called “Una página de Babel.”

Screen capture of Babel

Many will surely note that it is based on Jorge Luis Borges’s “Una biblioteca de Babel” (The Library of Babel). And, I hope people are aware of some the other interesting digital projects based on this story. I have seen one from years ago on CD-ROM; one that is very nice, and available on the Web, is Jeremiah Johnson’s BABEL. There’s also the exquisite Library of Babel by Jonathan Basile.

My piece does not try to closely and literally implement the library that Borges described, although it does have a page that is formally like the ones in Borges’s library: 80 characters wide, 40 lines long. Given this austere rectangular regularity, I assumed a typewriter-like monospace font.

The devotion of “Una página” to what the text describes stops there; instead of using the 23-letter alphabet that Borges sketches to populate this 80×40 grid, I use the unigram probabilities of letters in the story itself, in the Spanish text of “La biblioteca de Babel.” So, for instance, the lowercase letter a occurs a bit less than 8.4% of the time, and this is the probability with which it is produced on the page. The same holds for spaces, for the letter ñ, and for all other glyphs; they appear on the page at random, with the same probability that they do in Borges’s story. Because each letter is picked independently at random, the result does not bear much relationship to Spanish or any other human language, in which the occurrence of a glyph usually has something to do with the glyph before it (and before that, and so on).

“Una página” is also non-interactive. One can zoom, screenshot, copy and paste, and so on, but the program itself does not accept user input.

I sketched the program in Python before developing it in JavaScript, and when I was done with the HTML page that includes the JavaScript program, I thought I’d make a Python version, too. But when I did, I was disappointed; the Python program isn’t a page, and doesn’t produce a page, and so doesn’t seem to me to fit the concept, which has to be that of a page. Thus, I’m not going to release the Python program. The JavaScript version is the right one, in this case.

Running All Night

Tuesday 11 August 2015, 11:39 pm   ////  

A recent production of mine, Running All Night, was shown at Babycastles in New York recently during the Playdate, July 23-August 7, 2015.

The piece is a 128-byte Commodore 64 program that functions as a clock or timer. It was executing during the whole show and presented a different image every moment of the day. Here’s once glance as what it looked like as it ran on a TV turned to face the window.

Running All NIght at Babycastles

There was also a TV inside and a single page (dot-matrix printed) of the assembly source code.

You Have Been Offered ‘More Tongue’

Thursday 16 July 2015, 6:10 pm   /////  

I just put a new poetry generator up. This one was released in inchoate form at @party, the Boston area demoparty. I’ve finished it, now, writing an HTML page of 2kb that employs JavaScript to generate nonsense poems that I, at least, find rather amusing.

More Tongue (paused)

‘More Tongue’ is available in an expanded version (functioning the same but with uncompressed code and more meaningful variable and function names) which I suggest for just about everyone, since I encourage everyone to study and modify the code, for fun, for art, and so on. If you want to see the 2k version working, that’s there too.

I could have compacted this below 2kb, although I rather doubt I’d have gotten it to 1kb without some major shift in the way the program works. I can see a few inefficiencies in how I put the program together, and while I did turn to some compression resources I didn’t use the famed Minify. I was happy, though, with what the 2kb page does.

I’ll be reading from this in about an hour at Babycastles’s WordHack event, here in Manhattan, during the open mic. Hope to see some of you there.

@Party 2015 Productions

Sunday 21 June 2015, 6:38 pm   ////////  

I had five productions (one of them a collaboration) this time around at @Party, the Boston-area demoparty.

Browser demo: “More Tongue.” This was, well, not really a standard demo, even for a browser demo, that generates nonsense poems with compact code. Like everything at demoparties, it’s been released, but I’m going to work on a post-party version, so I’m leaving the party version out of this list.

Wild: “Shortcat.”

Shortcat is a very simple encoding scheme to make bytes (thus computer programs) into pleasing Unicode tweets, IMs, etc. #demoscene

Encoder: cat x.prg | perl -pe 'binmode STDOUT,":utf8";tr/\x00-\xff/\x{2500}-\x{25ff}/;' > x.txt #demoscene

Decoder: cat x.txt | perl -pe 's/[\x00-\x7f]//g;s/\xe2(.)(.)[^\xe2]*/chr((ord($1)-148)*64+ord($2)-128)/eg;' > x.prg #demoscene

To decode, copy the Shortcat string to a new text file, save it, decode. ASCII (incl. spaces & newlines) will be ignored #demoscene

When decoding, don’t include other Unicode besides the Shortcat string in your selection #demoscene

Add a hashtag (e.g., #c64) and/or other info (e.g., SYS4096) to help people run the program. That’s it. Nanointros everywhere! #demoscene

Check this Tweet for an example.

Executable music: “Dial Up” by devourant & nom de nom.


Play it in an HTML5 player.

Intro: “Chronon,” a 32-byte Commodore 64 program.

PRG file. Source.

PET Code

Demo: “PET Code,” a 128-byte Commodore 64 program that is a demake of Jörg Piringer’s “Unicode.”

PRG file, demo version (runs once & ends). PRG file, looping version. Source.

Thanks to Metoikos, Dr. Claw, Luis, and other organizers and volunteers for putting this year’s party on – and to Boston Cyberarts and the sponsors of the event.

Shebang Bash at Babycastles, July 2

Thursday 11 June 2015, 3:04 pm   ///////  

Shebang Bash is a two-part event at Babycastles (137 West 14th Street, Floor 2, New York City) on Thursday, July 2.

It'll be sort of like this reading in Saint Petersburg, but with projectors.

It’ll be sort of like this reading in Saint Petersburg, but with projectors and a workshop beforehand.

The workshop (beginning at 6pm) provides an opportunity for anyone to begin developing computational poetry by modifying existing programs. Those without programming experience are particularly encouraged to attend. Workshop participants will develop, share, and discuss their work. Participants must register in advance and bring their own notebook computer running Linux, Mac OS, or Windows. (A tablet or phone will not suffice; computers are not available at the gallery.) Those who wish to can show and/or read from their work during the second part of Shebang Bash, although presenting during the reading isn’t a requirement.

The reading (beginning at 8pm) will feature work from Nick Montfort’s #! (Counterpath, 2014), modified versions of Montfort’s “Taroko Gorge,” and poems developed just previously at the workshop. Montfort will read from several pieces in #!, will screen concrete poems from the book, will discuss the project of this book and his computational poetry practice, and will answer questions.

#! (pronounced “shebang”) is a book of programs and poems, consisting of short programs in Python, Perl, and Ruby followed by examples of their output. While the book is published by a small press that specializes in poetry, part of its heritage can be traced to BASIC programming books and magazines from the 1970s and 1980s. Copies will be available for sale at Shebang Bash.

Tickets to the reading will also be available at the door on the day of the event. For workshop tickets or to get reading tickets in advance, see the Eventbrite page.

Translating E-Literature = Traduire la littérature numérique

Monday 9 March 2015, 1:40 pm   /////  

The proceedings of the June 12-14, 2012 Paris conference on the translation of electronic literature are now online. These include a paper by Natalia Fedorova and myself, “Carrying across Language and Code.” The conference took place at Université Paris 8 Vincennes-Saint-Denis and Université Paris Diderot, and encouraged me and collaborators to undertake the Renderings project, the first phase of which is now onlne.

#! Reviewed in ebr

Sunday 1 February 2015, 6:18 pm   /////  

To continue the trend of three-letter publications presenting reviews of #!, ebr (Electronic Book Review) has just published a review by John Cayley – an expert in electronic literature, an accomplished cybertext poet, a teacher of e-lit practices, and someone who has created digital work engaging with the writings of Samuel Beckett, among other things.


It would be difficult to ask for as thoughtful and detailed a review as Cayley provided. Nevertheless, now that ABR and ebr have offered reviews, I do hope that IBR, OBR, and UBR will follow suit.

#! Reviewed in ABR

Tuesday 13 January 2015, 12:10 pm   /////  

Steven Wingate’s review of my book #! (pronouonced “Shebang,” Counterpath Press, 2014) appears in the current American Book Review and seems to be the first review in print.

Review of #! in ABR

I was very pleased to read it. Wingate discusses how the presentation of code provided a hook for understanding what programs do, much as bilingual editions allow a reader to learn more (at least a bit more) about a different language by skipping back and forth between recto and verso. An important goal of mine was to offer more access to computing and to show that code can be concise and open. I aimed to do this even as I wrore rather obscure and difficult programs, such as the ones in Perl, but certainly when writing Ruby and Python, the languages Wingate finds most pleasing.

Even better, Wingate modified “Through the Park” to create his own elliptical text generator with his own language. Modifying the code that’s there is a close reading of it indeed, just as the reader who memorizes a poem knows it better than someone who looks over it or reads it aloud once. I’m very glad that Wingate got into the programs & poems in #! so deeply and that he wrote this review. I’m sure it will help to open up new perspectives on code and poetry.

Trope Tank Writer in Residence, Spring 2015

Wednesday 7 January 2015, 11:54 pm   ///////  

Andrew Plotkin, Writer in Residence at the Trope Tank for Spring 2015

This Spring, Andrew Plotkin (a.k.a. Zarf) is the Trope Tank’s writer in residence. Andy will be at the Trope Tank weekly to work on one or more of his inestimable projects — as a game-maker, programmer, and platform developer, he has been working furiously for many years. (His home page is modest in this respect; See also his latest game, Hadean Lands.)

“The Era Canto,” a Poem for 2015

Monday 5 January 2015, 12:34 pm   /////  

Happy New Year! My New Year’s poem for 2015 is a one-line BASIC program for the Commodore 64: “The Era Canto.”

The Era Canto

Megawatt Reviewed

Monday 29 December 2014, 4:44 pm   ///////  

The first review of Megawatt has appeared (originally in German), and it’s quite a detailed analysis of the book, its relationship to Watt, and how the code and output text, in their presentation here, relate. The review is by Hannes Bajohr at 0x0a.

Here is the automagical Googly translation.

The English version of the review was posted January 3.

Renderings (phase 1) Published

Wednesday 10 December 2014, 10:31 pm   //////  

For the past six months I’ve been working with six collaborators,

  • Patsy Baudoin
  • Andrew Campana
  • Qianxun (Sally) Chen
  • Aleksandra Małecka
  • Piotr Marecki
  • Erik Stayton

To translate e-lit, and for the most part computational literature works such as poetry generators, into English from other languages.

Cura: The Renderings project, phase 1

After a great deal of work that extends from searching for other-langauge pieces, through technical and computing development that includes porting, and also extends into the more usual issues assocaited with literary translation, the first phase of the Renderings project (13 works translated from 6 languages) has just been published in Fordham University’s literary journal, Cura.

Please take a look and spread the word. Those of us rooted in English do not have much opportunity to experience the world-wide computational work with langague that is happening. Our project is an attempt to rectify that.

Some Houses of Dust

Monday 1 December 2014, 9:37 pm   /////  

Zach Whalen pointed out that it would probably be interesting to compare the reimplementations of A House of Dust that he did early this year and that I did more recently. Whalen’s work to reimplement historical systems is really excellent, by the way, and I in fact showed his animated GIF of “Kick that Habit Man” when I premiered Memory Slam, including a workalike of Gysin and Sommerville’s program and my version of the Knowles and Tenney poem, at NYU ITP’s Code Poetry Slam.

While I’m not going to go deep into code-level analysis of these – that’s a better task for some other code scholar and code warrior – I will make a few high-level points about the two versions, to at least cover some of the obvious differences.

My implementation is much more flat, for better or worse.

Flat in terms of files; all the CSS and JavaScript used by my implementation is packed into the one HTML page, so it’s easy to save it to your desktop, change the file around quickly, and see the result. However, that’s not a very Enterprise way to go about it; Whalen’s version reflects more typical programming practices in that regard, linking to a standard CSS file used throughout the site and using JavaScript stashed in .js files.

My version is also flat also in terms of appearance. While I present the plain monochrome all-caps stanzas scrolling up, Whalen gives a Janus-like look backwards to the pinfeed fanfold paper on which the original poem was published and forwards to the world of social media, via the “Share” button. This is a visual reminder of how the original prinout looked (although it did have four spaces of indentation rather than one!) and an indication of how its output can be part of today’s systems of sharing. I chose to use a proportional font because the monospace font seems too austere and too severe of a historical reminder to me, but I’m glad there is Whalen’s monospace alternative as well. That the lines in Whalen’s version appear a bit at a time is also a nice printerly touch.

It’s an empirical question as to whose version is the most easily modifiable and remixable. One can change the strings around quite easily in both versions to attain new versions of the classic program, after all the files are obtained. I would guess (and hope) that my version might have the edge in providing this sort of flexibility to those exploring the poem through programming, whether new or experienced. If so, that might make it useful in this particular regard and make up for the less historicized appearance and less sharable output.

There was another point to my implementation, which was that it was done more or less uniformly with the other three pieces included in my Memory Slam. So, a new programmer working with any one of those would be more easily able to continue to work with other programs in the set.

That’s something of a start to the discussion of these. I certainly welcome further comments and comparisons.

Next Page »
This work is licensed under a Creative Commons Attribution-Noncommercial-Share Alike 3.0 Unported License.
(c) 2016 Post Position | Barecity theme