Howdy, Stranger!
It looks like you're new here. If you want to get involved, click one of these buttons!
Categories
In this Discussion
Guests: Kayla Adams * Sophia Beall * Daisy Bell * Hope Carpenter * Dimitrios Chavouzis * Esha Chekuri * Tucker Craig * Alec Fisher * Abigail Floyd * Thomas Forman * Emily Fuesler * Luke Greenwood * Jose Guaraco * Angelina Gurrola * Chandler Guzman * Max Li * Dede Louis * Caroline Macaulay * Natasha Mandi * Joseph Masters * Madeleine Page * Mahira Raihan * Emily Redler * Samuel Slattery * Lucy Smith * Tim Smith * Danielle Takahashi * Jarman Taylor * Alto Tutar * Savanna Vest * Ariana Wasret * Kristin Wong * Helen Yang * Katherine Yang * Renee Ye * Kris Yuan * Mei Zhang
Week 2: Poetry as Code? Code as Poetry
Q: Please write me a sonnet on the subject of the Forth Bridge.
A: Count me out on this one. I never could write poetry.
-- Alan Turing
Dear All,
Thanks to Evan and John for starting us off, and to everyone for your insights, and questions.
I want to begin by a small note on digital communication, intimacy, and ephemera. I've been moved by how intellectual, creative, and political occurs online, the poetics of it, which I think lends itself to the ephemeral nature of these conversations that spark ideas, and movements.
Forums like this, and others that we find at HASTAC, and --empyre-- for example, have facilitated new ways of thinking, engaging on digital topics. I find it important to think about the particular "digital landscape" in which we form these discussions, especially since much of the intersections on creative and critical code tends to happen in these digital, avant, moonlighting spaces, where transgression and mutations are encouraged, and ignited.
For my part, I want to share some ideas and examples of the intersection between code and poetry that have come up from the past year, and share from my current book of poetry which engaged with code and the robot. So primarily I will discuss code through my work as a poet. It has been an ongoing investigation of this idea of invented languages.
The question that outlines my poetry collection Love, Robot, which is a science fiction poetry collection of a world that robots and humans fall in and out of love, includes the intersection of code and poetry.
The following below is simply a series of gestures, and I look forward to the conversation.
Two articles I recently wrote from seemingly disparate forums may help articulate some of my current ideas and questions:
Two seemingly disparate publications, the Association for Computing Machinery graduate student magazine XRDS, and Poets & Writers, the publication for creative writers.
In the first article for ACM, I primarily address graduate students in computer science and ask to think about the humanities and poetry in their work. I also share how the poetics is an ongoing response to Alan Turing's "Computer Machinery and Intelligence:" "Can Machines Think?" and "I could never write poetry." I think these two quotes from Turing helps us think about the connections/transgressions/separations of code and poetics in important ways.
The article for Poets and Writers articulate how research can help the poem's formation, and I draw on my research process for writing the poetry. Both articulations, I hoped, would help bridge the intersections of poetics and technology, or code.
Another quote from William Carlos Williams to think with: "A poem is a small (or large) machine made of words."
Article Links:
https://dl.acm.org/citation.cfm?id=3155126&dl=ACM&coll=DL
https://www.pw.org/writers_recommend/margaret_rhee
I want to also gesture to Helen Vender's writing on poets, and particular "Poet's Thinking:"
"In short, the relation of poetry to thought is an uneasy one. Some law
other than the conduct of an argument is always governing a poem, even
when the poem purports to be relating the undolfing of thought. On the
other hand, even when a poem seems to be spontaneous outburst of
feeling, it is being directed, as a feat of ordered language, but
something one can only call thought."
Here, Vendler is interested in how poets think through their poetry, by
grouping together four poets-- Dickinson, Pope, Whitman, and Yeats--she
argues how poets embody a process of thinking, that is original, and
unique to the poet.
As Vendler writes, "My question--by what means does a poet reproduce an
individual and characteristic process of thinking? -- can be addressed
to any work."
Question: How can we think of the "codes" in poetics?
When I was a graduate student, I was researching the cultural history of robotics quite heavily, and turned to robotics code. I found code beautiful. As I was writing my collection, the idea of logics and pattern from Vender, along with the aesthetics of code inspired me to write codes in my poetic work. Largely these codes, go alongside the narrative poems I wrote. Later, I draw upon chatscripts as poems.
For example, here is the narrative poem Beam, Robot:
Then the algorithm that is included in the book, but not in the magazine publication:
Other provocations and examples. I will turn humbly to Mark Marino, who has always been an inspiring model of the intersection of the humanities/science, through his creative and critical code work. We recently had a reading at the Poetic Research Bureau in Los Angeles where Mark translated the code in my poem "Sleep, Robot," "Algorithm, Sleep":
Algorithm Sleep
1. config = source
2. loop
3. loop
4. if (config == goal) return goal reached;
5. if (config ==) stay
6. dream
7. ```
------------------------------------------------------------
By Mark Marino:
```javascript
// Javascript second try
function cycle () { // or should I call it -- preoccupy
while (config != goal)
stay();
return goal reached;
}
var config = source;
var i=0;
while (i<=2)
{i++;};
cycle();
dream ();
Language: Chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken
Input Dream
Language: HODOR
hodor hodor hodor hodor hodor hodor hodor hodor hodor hodor hodor
Input Dream
I also want to ask about the tangible poetics of coding? Outside the GUI and into the TUI.
The poetry of soldering?
I want to end these gestures with a note on community and writing prompts, so for those who want to engage can create their own code poems. Oftentimes, there is a romance to communities that can fail, and often fails. But I am buoyed by the possibility of conversation, as ephemeral it can be.
We must constantly strive towards it.
Writing Prompts:
- Drawing from the Marino Method of Poetics, translate a poem (or code) into 3 programming languages.
- Write your own poem about robots and humans interactions, write a narrative poem, then translate the narrative into code
- Pick a newspaper article about code (or any topic), and create an erasure. Erase words until you have a poem left. What do you have left? Create another iteration of the poem if you like.
Comments
Thank you, Margaret, for including my translations of your poem.
I fear my Chicken and Hodor versions capture more the reference than the sense of your poem, to use the Frege distinction that @erwig has pointed out. And even there I'm not so certain. Chicken and Hodor are challenging languages for this piece. You can run the Chicken code here and the Hodor code here. Here's a paper that "explains" Chicken.
I did want to also include my Shakespeare version, that I'm a little happier about:
BTW, this code play premiered at your book launch at the Poetic Research Bureau and featured in the cast: Lucy Burns, Jessica Ceballos y Campbell, SA Smythe, and myself.
This is a very artful and provocative engagement with the theme. I really enjoyed the poetry and the code at the end of the piece, which in many ways are sustained by the contemplations at the beginning.
When I attempt to think through the relation between code and poetry, I am often drawn to the social manifestations of both--while the process of writing either can be a creative outpouring of subjectivity, the intelligibility of both is densely situated in a matrix of social meaning. I find that this perspective elides many perfunctory objections people have with the comparison between the two. Too much attention on the object obscures all of the social labor being done to sustain the possibility that this object "means," and continues to mean through time.
There is a cleaving together of meaning present in both code and poetry; a digital poetics of combining disparate patches of meaning into new forms. I am thinking, here, of Alexander Galloway's Laruelle: Against the Digital, which likens digitality with philosophy, in that both enact a cutting and fragmentation of meaning. While I am just sketching the outline of a comparison here, I feel that coding is productive in much the same way that poetry is: they both offer a certain level of creative potential (which, with the former, carries with it the risk that we are not interfacing properly, a constant negotiation). There is something about importing modules and libraries that evokes form and genre in much the same way as writing a sonnet or an elegy might. I think that your post does some really interesting work exploring these social meanings more capaciously than an exclusively-human affair.
@mrhee , thank you for providing such a richly-textured starting point for discussion!
I'm intrigued at the implications of Vendler's observation "Some law other than the conduct of an argument is always governing a poem".
I'll be very happy to see poets' engagement with your question "How can we think of the 'codes' in poetics?" Not having a background of poetry myself, but rather of analytic philosophy, I spun off into a different direction from that starting point: perhaps something more like "How can we think of the 'poetics' of code?". (Also, @spizelo , thanks for mentioning Galloway's work - I'm definitely adding Against the Digital to my queue!).
It seems to me that part of what makes poetry possible, and powerful, is that its "enactment," so to speak, happens within the broadest and most unconstrained environment - that is, the mind of the reader/listener. The artifact itself uses objects - letters, punctuation marks, words, and the visual spaces within which they exist - which are constrained in certain ways by the systematic parameters of meaining-making which we've developed for those kinds of objects. Using in a poem the physical mark "k" will, we're confident, produce in the mind of the reader/listener a different perceptual experience than using the physical mark "m" - and we rely on that being the case, in fact. To some extent, then, a poem (as artifact), like code, does carry in itself "laws" which are framed with explicit boundaries.
However, back to my claim about enactment: when a poem is "run," in the execution of the poem - the situation where the poem enters a causal relation with some effect - its effects are most often governed by the subversion of, or at least a separation from, those explicit laws, as Vendler notes. The consciousness of the reader/listener is the runtime system for the poem, and that environment is sufficiently expansive to accommodate the successful execution of a poem which breaks the rules of the very language systems which give rise to it. It's this last which signals, I think, a significant difference from code. While both poetry and code are rooted in law-governed systems of symbolic meaning-making, the environments within which code is enacted are just as law-governed - code which breaks its own laws of syntax has no possibility of successful execution - whereas the environments within which a poem is enacted are not - a poem which breaks its own symbolic/syntactic laws can have a highly successful execution, often in part precisely thanks to the ways that very subversion challenges the reader/listener with unexpected reactions.
The challenge I see for those of us who pursue the possibility of poetic coding, then, is something like: when the execution of code occurs in a rule-governed environment, can meaning - arising from subversion of rule-based meaning systems - be found from executing code? or is the poetic value of code to be found always in the reading of it?
I think it depends on where you draw the boundaries of code for any given piece. It's like the old joke that a chemist will say all biology is chemistry, a physicist will say all chemistry is physics, and a mathematician will say all physics is math. If you consider the end of a piece of code to be everything in a particular file but don't consider the rest of the operating environment then I'd say yes, there can be meaning derived from executing the code rather than just reading it. If you widen scope to include the entire operating environment then that claim gets more difficult.
I won't claim it as particularly poetic, but anything interesting about the Asterisk Painting piece I used as an example in the Calvinball thread happens as a result of executing the code. It isn't even dependent upon code that is imported or part of the compiled program itself; its behavior changes based on external delays inherent to running on a CPU that has other things on its mind. The code itself is incredibly basic; only in execution does it gain a bit of meaning.
I'll also add that I'm a bit struck by the similarities between Algorithm, Sleep here and AI Prison from another thread. I want to fork one or the other to make sure all our electric sheep aren't condemned to milling around a prison yard.
I really love what you shared about the Asterisk Painting piece, though I don't yet feel like I have much coherent to articulate about my reaction (I'm working on it!). The dependencies of code execution upon hardware's physicality definitely seems like a significant locus for finding rule-independent opportunities for meaning in execution.
Thanks for sharing these works @mrhee. I am neither a coder or creative writer but would like to take on your second prompt:
I do the layout for cream city review (latest issue featuring your work @mrhee !).When making copyedits, I sometimes go in with some simple GREP queries to locate the texts that need to be adjusted. This distraction led to using these queries as a way to locate, extract, and place texts in desired a desired pattern.
For example, applying the following query [a|A] \<\w+’s \<\w+> \<\w+> \<\w+>
to an issue of cream city review produces the following:
a train’s bladed wheels and
a Winter’s Night a Traveler
a woman’s ID is printed
While this is not a poem about a robot-human interaction, it is the result of that interaction. This bit prioritizes my voice, however, and a narrative is produced through the connections I made. The robot (InDesign in this case) only looks for the parameters I've ascribed to it. It's a passive co-author.
On the other hand: \<[\l\u]*?> replaces every character with a bullet:
The original text is now rendered unknown to me. The narrative is no longer verbal but visual, even the sporadic clues "13th," "-man," "-six" fail to reveal anything meaningful. For the robot, the meaning is equivalent: a bullet is as valuable as a character and are easily exchanged for one another.
As @gpetruzella said, texts are constrained by the "letters, punctuation marks, words, and the visual spaces within which they exist." These parameters are augmented, in a sense, to highlight these semantic essences. But the results also highlight the limits of the query and the code's reliance, even with the use of wildcard characters, on the structure of language.
I'm happy to see Galloway (and specifically Laruelle) brought up here, as his writings on data, information, and decisional relation have been influencing my thoughts on digital poetics as of late (count this as another recommendation of that book @gpetruzella!).
I think this is very important to consider in any discussion of code as poetry, precisely because of the differences in how enactment works in both arenas. Even in constraint or procedure based conceptual poetics (my personal example of poetry that can be considered close to code without being some form of code poetry outright), Sol LeWitt's "idea [which] becomes the machine that makes the art" inheres in how the reader/listener's mind works as a "runtime system" as much as the operations which constitute the text of the work/performance itself. What this demonstrates is something that I think is implicitly expressed in @gpetruzella's comment, which is that the division between the two modes of "enactment" isn't a cut and dry one at all. So a way to think about this that considers both the operational and social manifestations of code and poetry is through how those two arenas make contact with one another.
A productive line of thought might be to think about how encapsulation works in programming languages (something that Galloway himself discusses at length in this blog post). The important aspect of encapsulation for this discussion, beyond the act of bundling and separation that Galloway (among many, many others) describes, is that encapsulation necessitates interfaces which facilitates access to and knowledge of said operations. And with the necessity of interfaces comes decisions about how those operations should be expressed to any given writer of code through said interface.
Interface, when contextualized in this manner, becomes a term that produces a meeting of the operational and the social aspects of code and poetry. And it is this meeting (or rather, meetings) that leads us to think of the ways in which poetic coding can generate similar types of enactment effects to what we get when a poem is read. Now, this could lead in many different directions: esolang would be merely one suggestion (as @mwidner suggests in another thread). But generally, part of how poetic code would work is that it would attend to not only the operational poetics of code, but how decisions relating to encapsulation and interface truck with them certain ideological elements that inhere themselves in a language's design, syntax, implementation, and other affordances that become important not only in relation to a language's operations, but also in how a writer of code interprets those operations (and at this point, we're in the wheelhouse of someone like a Wendy Chun and her discussions of software and ideology. It's also not coincidental that the further down this rabbit hole one goes, the more that functional and aesthetic categories begin to converge).
While I don't have much of a background in poetry, I write about esoteric programming languages for esoteric.codes, so wanted to comment a bit on the ones used here and a few favorite alternatives of mine.
While Shakespeare is a classic, a more recent set of languages worth looking at is Will Hicks's Esopo project, a series of programming languages designed for poetry, where rhyming schemes, punctuation, and formal elements like indentation are commands, leaving the programmer/poet a lot of room to construct poetry within that structure. Like many other esolangs, it works in an Oulipean fashion; the language's rules create constraints to be explored.
My favorite of the repeated word type languages (Hodor, Chicken, etc) is Ook!, as it was (likely) the first. Like many others, it's built on brainfuck, the classic esolang that inspired a slew of derivatives. In Ook!, the punctuation marks around each repeated syllable "Ook" indicate commands. This means, in a live reading of Ook! code, the verbal expression of each Ook syllable (pauses, rising intonation, etc) contain the information to, say, increment a number rather than begin a loop. The designer of Ook!, David Morgan-Mar actually doesn't seem to love his creation; he spoke to me about it for esoteric.codes; he's more proud of Piet, where programs are images, and Chef, where code is written as recipes that actually lead to edible creations. I feel like the chief contribution of languages like Ook! and Chicken is in bringing our attention to the surface layer of code; where brainfuck confuses us by its challenging logic and extreme minimalism, its expression (in punctuation marks) is actually pretty straightforward once you get used to it. But with Ook, Chicken, etc, it's harder to see the underlying algorithm because it's obscured by the repeating syllable; most of what you take in visually is pretty irrelevant to how the code functions. In terms of languages with repeated symbols, there's also the language Lenguage ("len" for "length"), which uses only the repeated number 1 to represent all code. Since it doesn't have line breaks, punctuation, spaces, or anything else to create patterns the way these others do, the length of the program (the number of 1s) gives us all the information needed about the program.
@DanielTemkin esoteric.codes is such a valuable resource, and you commentary in here is wonderful.
Those esoteric programming languages are good for what we are trying to do here because they disrupt a lot of our (or at least my) assumptions about programming languages and what it means to speak in code. They help defamiliarize the act of programming in a language. They reveal and challenge assumptions about the relationship between sign and signifier (although this isn't quite the right analogy), systems of symbolic exchange and operation. Back in the 2012 Working Group, @DavidBerry introduced us to many of the languages and did a particular exploration of Ramsey Nasser's Zajal. And in 2014, @amitorit, Roopika Risam, and Adeline Koh discussed Nasser's Alb.
I see so much critical work in these creative languages as they help us to interrogate the nature of programming languages. I have recently had a similar defamiliarizing experience as I come to understand spreadsheets as programming environments. By challenging what programming looks like, how code operates, these languages challenge how and what code means.
A note on those variations I did on @mrhee's poems. In addition to playing with the code poems in esoteric languages, I also wanted to see what they would look like in low-level languages. So asked my partner (Barbara Marino) for help, and she made this version:
But in making that assembly language version, she showed me how she was interpreting the code, which led to me revising some of the other translations.
In my mind, I had situated the work of converting @mrhee's poem as translating it from one language to another. In retrospect, I would characterize this activity a little differently. Rather than translating code from one language to another, we were translating @mrhee's dream code into an operational language (or at least a specific programming language), from specifications to (somewhat) executable code. In some ways it was more like translating Margaret Hamilton's diagrams in Axes into code. In other ways, it was like translating a laser blaster into a petit four, or translating a cozy blanket into a cottage. Like translating Hudsucker's drawing of a circle into a hula hoop, having only seen the sketch. Thinking of creativity, though, the process demanded that the translator continually ask: what is this poem code all about, what does it do, what does it mean?
On your first provocation, your "Algorithm" poems have me thinking about syntax: working with the formal syntax of code makes both code forms and poetic forms more apparent, present. What struck me was how poems so often narrate a process -- of realization, revelation, decision, etc -- and how this fits into what in programming would be called imperative semantics: do this, then do this, then do this, then .... In your poem, that would be do assign, do loop, do loop, do if and so on.
But then that made me wonder: what would a poetry of other programming semantics and syntaxes look like? Besides imperative programs, there are declarative, axiomatic, etc.
So one such form is the sexps (short for s-expressions, which is short for symbolic-expressions) of the Lisp family of languages. Sexps are words combined with balanced sets of parentheses, where the function (verb) comes first, followed by the arguments (subject and object).
Since you mentioned Williams, and since the source text is in everyone's head:
Besides the
(verb subject object)convention, I translated modifiers as functions,thetakes a noun and returns the noun specified,delicioustakes a noun and returns the delicious version of the noun, etc. There are also a few keywords from lisp:lambdabeginandcomposethat combine and abstract functions and statements in ways specific to lisp.So this is a lisp program which -- if we provided definitions for all the words used -- would return a function, ready to be addressed to
you.Below is the post with the photo that includes Mark Marino, Lucy Burns, SA Smythe, and Jessica Ceballos y Campbell.
Hi Mark,
This is so wonderful, and the performance of Shakespeare version was pretty much one of the most riveting of the evening! I was thinking this morning, I wonder if that was the first time there was a code poetics performance at PRB? In such iterations?
I wanted to share the photo of the said performance here. Many thanks again
Code poetry has become mystery for me. I was reading your posts without understanding moreover this discussion was my motivation to subscribe for the CCSWG18. Can somebody translate to me into natural language.
@Waliya The original verson of Algorithm Sleep is in English, but here was my attempt to try to understand it. Hope it helps:
You mean, now one can instruction computer in such algorithm without coding it?
yes, and no.
I mean, people can specify an algorithm without coding it. You can think of the poems that way. Or just think of them as poems, of course.
Please Sir @markcmarino , what is the limit of code critique studies? Does it include website coding critics? Is there a software for corpus analysis of codes? For example, the frequent occurrences of the machine language(codes symbols) and the natural language (human language) in the name of CCS.
A scrolling marquee saying H-A-M-L-E-T is probably not code poetry, but this last image is great:
Thank you @krisPurzycki for your thoughtful post and sharing. I am a huge fan of CCR, and so pleased to e-meet here! My warmest regards to everyone there!
I feel what you describe in terms of the GREP queries definitely intersect with code/poetics in such interesting ways! The narrative of layout, coding, and poetics! It is fascinating to think about the InDesign (robot) as taking on the parameters, you've ascribed to it. It certainly makes one think about human-robot relations in an intimate sense of learning and cybernetic interaction, which I feel is poetics.
Your post also makes me think about N. Kate Hayles's words on pattern, body, and cybernetics in her introduction to How We Became Post Human, and I feel it connects to the description and questions that you so eloquently lay out here:
"All that mattered was the formal generation and manipulation of informational patterns. Aiding this process was a definition of information, formalized by Claude Shannon and Norbert Wiener, that conceptualized information as an entity distinct from the substrates carrying it. From this formulation, it was a small step to think of information as a kind of bodiless fluid that could flow between different substrates without loss of meaning or form." (http://www.press.uchicago.edu/Misc/Chicago/321460.html)
Much to continue to think about! Thanks again.
Hi everyone,
Thanks so much for this incredibly generative discussion! I am provoked and buoyed by the thoughtful and provocations of ideas and creativity here! It helps my thinking and poetics immensely, and still thinking about the many insightful points raised! If anyone did write your own code poems, please feel free to share here as well! It would be great to end the week with poetry. As a kind reminder, I placed the writing prompts below:
Writing Prompts:
1) Drawing from the Marino Method of Poetics, translate a poem (or code) into 3 programming languages.
2) Write your own poem about robots and humans interactions, write a narrative poem, then translate the narrative into code
3) Pick a newspaper article about code (or any topic), and create an erasure. Erase words until you have a poem left. What do you have left? Create another iteration of the poem if you like.
Late to this discussion—but I wanted to chip in a few words about Louis Zukofsky's 80 Flowers, which I think is an interesting example of poetry that "reproduce[s] an individual and characteristic process of thinking" that also has interesting analogues in code. Zukofsky used a process that he called "condensation" to compose these poems, in which he progressively rewrote his notes in more and more compressed form (leaving out words, combining sources, phonetically rewriting, reducing through etymology) which became the words that formed the poems. (For all the usual Zukofsky reasons, it's difficult to find excerpts from 80 Flowers online; this Goodreads review has a representative handful). In her book Reading Zukofsky's 80 Flowers, Michele Leggott also calls this process "convolution," which is interesting because that word is also used to describe the operation of averaging together word vectors in natural language processing for the purpose of summary and classification—essentially the same poetic process as Zukofsky's, just accomplished through different means. I've been working on a "Zukofsky machine" to carry out poetic composition in this manner from arbitrary source texts—one preliminary experiment was my NaNoGenMo 2017 project, the Average Novel (output here).
In general, I'm interested in code-generated poetry that demonstrates its own process, to the extent that you can kind of "reverse-engineer" the procedure from the output. Examples of this include Jackson Mac Low's asymmetries etc. and Nick Montfort's recent The Truelist.
Please I need help, Last week (1) I was able to understand CCSWG18 but now in week 2, I ended it with a little understanding. My request is that, I entreat @markcmarino @jeremydouglass @apprrish @ebelloj,@mrheeloy,@mrhee@belljo @krisPurzycki, @adamhaile etc to harmonise these discussions on code poetry, creativity, code translation and mapping algorithm and add many other simplified examples and send into every participant's email so that we who are new to this world of coding may pick up to meet you up there. Thanks for your generosity and patience with novice like me.
@Waliya
Since you are asking for help here, I'd like to call the attention to your paper:
"Calabar lesbian cryptic languages"
available at
https://www.researchgate.net/publication/320555745_Calabar_lesbian_cryptic_languages
which for its significance states:
In its conclusion, your paper states that:
The final words in this paper are:
So my question is, is the agenda that you are promoting when you ask for help in this forum?
@JullyMalloy, it is a nice question. When we write a research project, one has to stand inline with the Constitution of the Nation and the standing order of the setting. It is in Nigerian Constitution that Lesbianism is not acceptable because of our African Christianity tradition and Islamic tradition we practice here. I am asking about coding as programming language."Lesbianism is popularly believed to be diabolic, taboo, disgusting and irreligious. Therefore, socio-educational violence is inevitable." In my statement here, I am standing as a judge to say: Violence is inevitable because it is a counterculture(strange culture fighting against long existing one). African feminism is matricentric. I am not talking of Afro-American setting but real African in Africa. Re-read the research paper. It is a report gathered from the ladies that I elaborated. If you care to know more my paper, inbox me. We are discussing coding here not lesbianism. R
As I've been thinking about @mrheeloy's call for us to convert poems in to code, and e.e. cummmings came to mind, perhaps because some of his poems are already so code-like. For instance, there's the classic poem about a grasshopper:
So, for fun, I "translated" this into Python. The code is, in a way, a reading of the poem and a new performance of it as a series of random leaps by the grasshopper, each of which shuffles the order of its letters:
I think that identifying the different words that cummings has obfuscated and using them as variable names to generate random strings that play on the word "grasshopper", each iteration of which is a
leApInG.shuffle(arIvInG)somehow gets across some spirit of the poem while also, in an odd way, making it a little more legible. There's a small chance, too, that the poem will print out the word "grasshopper" randomly. It hasn't happened yet for me, but it should, run enough times. Much is lost in the output of this code-poem compared to the original (except the first and last lines are printed), but considering the code and the output, it translates the spirit of the original into what I hope is similarly playful code.