C64 Coding Under (Many) Constraints

Screenshot from Tyger Tyger; black and white border, scattering of orange and black characters on blue

Yesterday I wrote a little demoscene production, an intro, called “Tyger Tyger.” It’s a Commodore 64 machine language program with 32 bytes of code and the requisite 2 byte header, found on all C64 PRG files. It only garnered third place out of five entries in the 256b compos at @party 2021, behind two impressive entries that were for a different platform (DOS) and went to the limit of allowable code (eight times as much).

I wrote this intro under a formal constraint (32 bytes of machine language code) and several process constraints. Specifically, I wrote it all yesterday, mostly on a Amtrak train, finishing up the sound once I got to the party itself in Somverville. I also exclusively used a hardware Commodore 64 running Turbo Macro Pro v1.2, rather than cross-assembling the code on a contemporary computer and testing it on an emulator. To be specific, I used an unofficial hardware version of the Commodore 64 called the Ultimate 64, which is a modern FPGA implementation of Commodore’s hardware—not, however, an emulator. I placed a SID chip (a 6581) in the machine, so the only analog component that would otherwise need to be emulated was an authentic original.

Writing the code exclusively on the train provided me with some additional challenges, because the power kept cutting out and my system (which has to be plugged into AC power) shut off each time.

I’d never used any version of Turbo Macro Pro before, neither the C64 assembler nor TMPx, the cross-assembler. I figured out the basics of how to use the editor and learned the syntax the assembler used. It’s quite an excellent piece of software—thanks, Style!

And tremendous thanks to Dr. Claw, who put on a safe, responsible, demoparty—masks required when not eating, full vaccination required for all. It was a tiny one, yes, but it was a party! The event continues the important social and artistic traditions of the North American demoscene.

Sea and Spar Between 1.0.2

When it rains, it pours, which matters even on the sea.

Thanks to bug reports by Barry Rountree and Jan Grant, via the 2020 Critical Code Studies Working Group (CCSWG), there is now another new version of Sea and Spar Between which includes additional bug fixes affecting the interface as well as the generation of language.

As before, all the files in this version 1.0.2.are available in a zipfile, for those who care to study or modify them.

Sea and Spar Between 1.0.1

Stephanie Strickland and I published the first version of Sea and Spar Between in 2010, in Dear Navigator, a journal no longer online. In 2013 The Winter Anthology republished it. That year we also provided another version of this poetry system for Digital Humanities Quarterly (DHQ), cut to fit the toolspun course, identical in terms of how it functions but including, in comments within the code, what is essentially a paper about the detailed workings of the system. In those comments, we wrote:

The following syllables, which were commonly used as words by either Melville or Dickinson, are combined by the generator into compound words.

However, due to a programming error, that was not the case. In what we will now have to call Sea and Spar Between 1, the line:

syllable.concat(melvilleSyllable);

does not accomplish the purpose of adding the Melville one-syllable words to the variable syllable. It should have been:

syllable = syllable.concat(melvilleSyllable);

I noticed this omission only years later. As a result, the compound or kenning “toolspun” never was actually produced in any existing version of Sea and Spar Between, including the one available here on nickm.com. This was a frustrating situation, but after Stephanie and I discussed it briefly, we decided that we would wait to consider an updated version until this defect was discovered by someone else, such as a critic or translator.

It took a while, but a close reading of Sea and Spar Between by Aaron Pinnix, who considered the system’s output rather than its code, has finally brought this to the surface. Pinnix is writing a critique of several ocean-based works in his Fordham dissertation. We express our gratitude to him.

The result of adding 11 characters to the code (obviously a minor sort of bug fix, from that perspective) makes a significant difference (to us, at least!) in the workings of the system and the text that is produced. It restores our intention to bring Dickinson’s and Melville’s language together in this aspect of text generation. We ask that everyone reading Sea and Spar Between use the current version.

Updated 2020-02-02: Version 1.0.2 is now out, as explained in this post.

We do not have the ability to change the system as it is published in The Winter Anthology or DHQ, so we are presenting Sea and Spar Between 1.0.1 1.0.2 here on nickm.com. The JavaScript and the “How to Read” page indicate that this version, which replaces the previous one, is 1.0.1 1.0.2.

Updated 2020-02-02: Version 1.0.2 is the current one now and the one which we endorse. If you wish to study or modify the code in Sea and Spar Between and would like the convenience of downloading a zipfile, please use this version 1.0.2.

Previous versions, not endorsed by us: Version 1 zipfile, and version 1.0.1 zipfile. These would be only of very specialized interest!

Incidentally, there was another mistake in the code that we discovered after the 2010 publication and before we finished the highly commented DHQ version. We decided not to alter this part of the program, as we still approved of the way the system functioned. Those interested are invited to read the comments beginning “While the previous function does produce such lines” in cut to fit the toolspun course.

Nano-NaNoGenMo or #NNNGM

Ah, distinctly I remember it was in the bleak November;
And each separate bit and pixel wrought a novel on GitHub.

April may be the cruelest month, and now the month associated with poetry, but November is the month associated with novel-writing, via NaNoWriMo, National Novel Writing Month. Now, thanks to an offhand comment by Darius Kazemi and the work of Hugo van Kemenade, November is also associated with the computer-generation of novels, broadly speaking. Any computer program and its 50,000 word+ output qualifies as an entry in NaNoGenMo, National Novel Generation Month.

NaNoGenMo does have a sort of barrier to entry: People often think they have to do something elaborate, despite anyone being explicitly allowed to produce a novel consisting entirely of meows. Those new to NaNoGenMo may look up to, for instance, the amazingly talented Ross Goodwin. In his own attempt to further climate change, he decided to code up an energy-intensive GPT-2 text generator while flying on a commercial jet. You’d think that for his next trick this guy might hop in a car, take a road trip, and generate a novel using a LSTM RNN! Those who look up so such efforts — and it’s hard not to, when they’re conducted at 30,000 feet and also quite clever — might end up thinking that computer-generated novels must use complex code and masses of data.

And yet, there is so much that can be done with simple programs that consume very little energy and can be fully understood by their programmers and others.

Because of this, I have recently announced Nano-NaNoGenMo. On Mastodon and Twitter (using #NNNGM) I have declared that November will also be the month in which people write computer programs that are at most 256 characters, and which generate 50,000 word or more novels. These can use Project Gutenberg files, as they are named on that site, as input. Or, they can run without using any input.

I have produced three Nano-NaNoGenMo (or #NNNGM) entries for 2019. In addition to being not very taxing computationally, one of these happens to have been written on an extremely energy-efficient electric train. Here they are. I won’t gloss each one, but I will provide a few comments on each, along with the full code for you to look at right in this blog post, and with links to both bash shell script files and the final output.

OB-DCK; or, THE (SELFLESS) WHALE


perl -0pe 's/.?K/**/s;s/MOBY(.)DI/OB$1D/g;s/D.r/Nick Montfort/;s/E W/E (SELFLESS) W/g;s/\b(I ?|me|my|myself|am|us|we|our|ourselves)\b//gi;s/\r\n\r\n/
/g;s/\r\n/ /g;s//\n\n/g;s/ +/ /g;s/(“?) ([,.;:]?)/$1$2/g;s/\nEnd .//s’ 2701-0.txt #NNNGM

WordPress has mangled this code despite it being in a code element; Use the following link to obtain a runnable version of it:

OB-DCK; or, THE (SELFLESS) WHALE code

OB DCK; or, THE (SELFLESS) WHALE, the novel

The program, performing a simple regular expression substitution, removes all first-person pronouns from Moby-Dick. Indeed, OB-DCK is “MOBY-DICK” with “MY” removed from MOBY and “I” from DICK. Chapter 1 begins:

Call Ishmael. Some years ago—never mind how long precisely—having little or no money in purse, and nothing particular to interest on shore, thought would sail about a little and see the watery part of the world. It is a way have of driving off the spleen and regulating the circulation. Whenever find growing grim about the mouth; whenever it is a damp, drizzly November in soul; whenever find involuntarily pausing before coffin warehouses, and bringing up the rear of every funeral meet; and especially whenever hypos get such an upper hand of , that it requires a strong moral principle to prevent from deliberately stepping into the street, and methodically knocking people’s hats off—then, account it high time to get to sea as soon as can. This is substitute for pistol and ball. With a philosophical flourish Cato throws himself upon his sword; quietly take to the ship. There is nothing surprising in this. If they but knew it, almost all men in their degree, some time or other, cherish very nearly the same feelings towards the ocean with .

Because Ishmael is removed as the “I” of the story, on a grammatical level there is (spoiler alert!) no human at all left at the end of book.

consequence


perl -e 'sub n{(unpack"(A4)*","backbodybookcasedoorfacefacthandheadhomelifenamepartplayroomsidetimeweekwordworkyear")[rand 21]}print"consequence\nNick Montfort\n\na beginning";for(;$i<12500;$i++){print" & so a ".n;if(rand()<.6){print n}}print".\n"' #NNNGM

consequence code

consequence, the novel

Using compounding of the sort found in my computer-generated long poem The Truelist and my “ppg 256-3,” this presents a sequence of things — sometimes formed from a single very common four-letter word, sometimes from two combined — that, it is stated, somehow follow from each other:

a beginning & so a name & so a fact & so a case & so a bookdoor & so a head & so a factwork & so a sidelife & so a door & so a door & so a factback & so a backplay & so a name & so a facebook & so a lifecase & so a partpart & so a hand & so a bookname & so a face & so a homeyear & so a bookfact & so a book & so a hand & so a head & so a headhead & so a book & so a face & so a namename & so a life & so a hand & so a side & so a time & so a yearname & so a backface & so a headface & so a headweek & so a headside & so a bookface & so a bookhome & so a lifedoor & so a bookyear & so a workback & so a room & so a face & so a body & so a faceweek & so a sidecase & so a time & so a body & so a fact […]

Too Much Help at Once


python -c "help('topics')" | python -c "import sys;print('Too Much Help at Once\nNick Montfort');[i for i in sorted(''.join(sys.stdin.readlines()[3:]).split()) if print('\n'+i+'\n') or help(i)]" #NNNGM

Too Much Help at Once code

Too Much Help at Once, the novel

The program looks up all the help topics provided within the (usually interactive) help system inside Python itself. Then, it asks for help on everything, in alphabetical order, producing 70k+ words of text, according the GNU utility wc. The novel that results is, of course, an appropriation of text others have written; it arranges but doesn’t even transform that text. To me, however, it does have some meaning. Too Much Help at Once models one classic mistake that beginning programmers can make: Thinking that it’s somehow useful to read comprehensively about programming, or about a programming language, rather than actually using that programming language and writing some programs. Here’s the very beginning:

Too Much Help at Once
Nick Montfort

ASSERTION

The “assert” statement
**********************

Assert statements are a convenient way to insert debugging assertions
into a program:

assert_stmt ::= “assert” expression [“,” expression]

A plot

So far I have noted one other #NNNGM entry, A plot by Milton Läufer, which I am reproducing here in corrected form, according to the author’s note:


perl -e 'sub n{(split/ /,"wedding murder suspicion birth hunt jealousy death party tension banishment trial verdict treason fight crush friendship trip loss")[rand 17]}print"A plot\nMilton Läufer\n\n";for(;$i<12500;$i++){print" and then a ".n}print".\n"'

Related in structure to consequence, but with words of varying length that do not compound, Läufer’s novel winds through not four weddings and a funeral, but about, in expectation, 735 weddings and 735 murders in addition to 735 deaths, leaving us to ponder the meaning of “a crush” when it occurs in different contexts:

and then a wedding and then a murder and then a trip and then a hunt and then a crush and then a trip and then a death and then a murder and then a trip and then a fight and then a treason and then a fight and then a crush and then a fight and then a friendship and then a murder and then a wedding and then a friendship and then a suspicion and then a party and then a treason and then a birth and then a treason and then a tension and then a birth and then a hunt and then a friendship and then a trip and then a wedding and then a birth and then a death and then a death and then a wedding and then a treason and then a suspicion and then a birth and then a jealousy and then a trip and then a jealousy and then a party and then a tension and then a tension and then a trip and then a treason and then a crush and then a death and then a banishment […]

Share, enjoy, and please participate by adding your Nano-NaNoGenMo entries as NaNoGenMo entries (via the GitHub site) and by tooting & tweeting them!

My @party Talk on Computer-Generated Books

I just gave a talk at the local demoparty, @party. While I haven’t written out notes and it wasn’t recorded, here are the slides. The talk was “Book Productions: The Latest in Computer-Generated Literary Art,” and included some discussion of how computer-generated literary books related to demoscene productions.

Salon 256 on May 1

SALON 256 is a forum for presentation and discussion of very small creative computer programs. Such programs have featured in digital art and poetry, electronic literature, computer music, and the demoscene.

YOU are invited to present a tiny program of yours:

Monday May 1 . 5pm-7pm . MIT’s 14E-304

Presenters already confirmed:

  • Mike “Dr.Claw” Piantedosi
  • Angela Chang
  • Sofian Audry
  • Nick Montfort
  • Chris Kerich
  • Willy Wu
  • Henry Lieberman
  • Doug Orleans

Programs in an interpreted language are fine, as long as the code is 256 bytes or less; compiled programs with an executable file of 256b or less are fine, too.

Building 14 also holds the Hayden Library and is not Building E14.
If you’d like to present, leave a comment or sign up at the event.

A Purple Blurb / The Trope Tank production.

Tiny Trope Tank Productions

Recently, at the suggestion of our writer in residence, Milton Läufer, we in the Trope Tankt have been producing digital files for discussion at meetings. These productions, almost always computer programs but not constrained to be such, must be at most 256 bytes.

It’s been extremely productive in terms of thinking about digital media, platforms and programming languages, and how we approach creative projects — and even other projects — generally. Postdoctoral researcher Sofian Audry prompted us to discuss this some at the last meeting.

So far we have three sets of 256b files which have landed in this directory, organized by date and with file names that indicate who wrote what:

http://nickm.com/trope_tank/256/

They include work by RA Chris Kerich, who has produced rather demoscene-like visual effects using Python running in a terminal, and by postdoctoral researcher Angela Chang, who has provided short example programs for use in teaching. Angela’s examples show that you don’t have to have hypercompressed, confused code when you write short, interesting programs. You can value clarity and pedagogical usefulness if you like, or you can pack in as much as possible, for instance, in order to produce a visual effect.

Sofian has explored creative computing history by writing a 256b Commodore 64 BASIC program that implements, or at least strongly refers to, the classic Lemonade Stand BASIC program. Milton has generated various compelling visual displays. His and Chris’s most recent programs are less clearly mathematical and regular, instead imitating the natural world.

It was very apropos that Christian Bök pointed me to Dwitter, a framework for making tiny programs that can be easily shared on the Web, just recently. I’m sure we’ll all dig into that soon.

My pieces include one bash script, one Python 3 program, and an executable of 256b written in assembly for the Commodore 64. The Python 3 program is actually a very tiny text adventure, Wastes, and is listed on the Interactive Fiction Database. In fact, I’m pleased to see that at this point, it has one four-star (our of five) review!

Hello, Globe

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+(2*b or not 2*b)):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

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

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

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

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’

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

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.

((((t\*2^12018^t>>16)&42)\*(t^12)&t>>5)>>3|t\*9&(t&4^42)>>5)-1

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

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

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.