This week, I wanted to explore what kind of text could lend itself to this kind of random / “nonsensical” rearrangement without just feeling silly. I looked over my poetry section of my bookshelf and was immediately drawn to my favorite — Marie Howe’s “What the Living Do”, where she writes about her brother’s death from AIDS. That book never fails to nail down exactly what I believe about life and death, that it’s all found in the little details from each present moment, and I felt I could adapt the typical poem structure in the book and use randomness to highlight what the book has to say about grief.
Do you agree that “juxtaposition” is one of the foundations of poetic composition? How (if at all) is randomness uniquely suited to creating surprising juxtapositions in poetry? How does a procedural technique reflect the intentionality of its creator? What effect does the choice of source text have on the “output” of a procedural technique?
Hartman Ch.2 and Ch.3
accidentally left my annotations at home, will update this later
Poetry and Pleasure — Jackson Mac Low
Not sure exactly which section I’m supposed to read, so going to go with the intro and then skimming through the poems.
Love the idea that the primary reason for making art is to make art, and that there are so many types of art because there are so many different types of pleasure.
I love Cage’s chance-operations, wish I had time to finish his biography sitting on my desk.
The notion that these automated chance-driven poems are an attempt to do away with the ego of the artist in a Buddhist sense really resonates with me, and is something I definitely want to explore myself. One of the things that attracts me the most about these generated poems is the notion of authorship, and how silly it seems to claim individual authorship over any work that comes from other texts. I think it’s silly to claim individual authorship ever, but that’s a whole ‘nother blog post…
Feel like there’s a lot to unpack with his idea of “engaging with contingency” — so he’s basically leaving it up to chance, but defining the bounds of that chance. (intentionality of the creator)
*edit: I understand now, so ‘i’ is iterating through a number in the first example, and through an array in the second.
Having done a little bit of computer poetry in the past, I wanted to do something a little more abstract than just a cut and paste mad libs type poem. My initial idea (first thought, best thought? probably not…) that seems so unoriginal I’m convinced there’s already a section on this in the jupyter notebook, was to make a “Poetry Generator Generator”. How, you ask? Well that’s a great question (that I don’t know the answer to yet). Here’s my process of figuring it out!
Step One: Figure out the Elements of a Poetry Generator
Inspired by reading all of Hartman’s Virtual Muse on my new commute to school, I knew I needed to isolate the building blocks of a generator — to come up with a grammar perhaps — where instead of “adjective, verb, noun” maybe it would be “libraries, loops, input text”. Let’s break down each generator on the demo notebook to see:
Libraries: random and textwrap
String of input text: “newspaper”
Function A) splitting the string into an array of discrete words (how does this do that? space character?)
Function B) randomly shuffling the array and storing the new array
Output: printing the rejoined words as a string (in a formatted way — text wrap + 60?)
A House of Dust
Arrays: Materials, Locations, Lights, Inhabitants
Output structure variable: stanza_count (7)
For Loop: printing a series of strings dependent on pre-determined arrangements of the earlier arrays (mad-libs)
Arrays: sal_adjs, sal_nouns, adjs, nouns, advs, verbs
Complicated formatting function/loop
Output (constantly updated with salutation, body, sign-off)
Arrays: above, below, transitive, imperative, intransitive, texture, adjectives
path function: one line
cave function: one line
site function: one line
Output: stanza_count = 10, random amount of lines, path() cave() site()
Step 2: How tf am I going to do this?
So, on first glance, it seems like the core structure here is to have an array of possible entries that can then be manipulated by loops/functions to create interesting output. What I could do, then, would be to take these chunks of code and store them in similar arrays to be accessed from the output functions. Perhaps there could be a set of possible outputs also, randomly looped through, but all using the same input arrays. Damn, so ideally, each random poetry generator generated should be able to function as a usable generator also, so I should have another array of randomly chosen input text that can be fed in after the generator is finished? Hmm, should this all be contained in one script? Would be simpler for output (could output the generator code and the output), I just wonder if there’s a better way to use the jupyter notebook format (i.e. have different sections that run under different conditions, although I guess that’s not really something jupyter does… excited that I get to learn this).
Maybe starting with output and reverse-engineering is the way to go. So for the ideal output, perhaps there could be fourish stanzas (abstracted, could include the salutation, for ex.), and each stanza could come from a randomly selected generator using a randomly selected input array. Stanza_count could also be random, and just have a count variable that could increment and then trigger the end of looping through a series of switch/case loop blocks or whatever. Would that feel too disjointed? What am I talking about, this is computer poetry, disjointed might as well be a required library. But still, what I’m making right now is less poetry generator generator, and more a mad-lib of all these other outputs… How can I make the whole code more auto-generated and less cut and paste??? HMMMMMMM. Ideally the generator code output would be something clean that someone could then just run as a stand-alone script, but I think these outputs are going to be super long with a lot of repetition, unless I go crazy complicated with how each line is arranged…. hmm….
Alternatively, I could treat the whole thing like telephone, where the output of one generator becomes the input of the next, though most of the outputs care more about structure than actual content, so maybe that wouldn’t be very effective…
Okay, so for the purposes of this assignment, I think I’m going to go the simpler route and just have a script that randomly chooses which of these generators to run and which input arrays to use…
STEP 4: FRANKENSTEIN’S MONSTER RISES (again and again)
I won’t be pasting the txt of the transcript, but it was from a conversation about 20 minutes long, and is 3,592 words. Very tough to get a format down, couldn’t figure out the best way to get pauses, stutters, and simultaneous speech represented in a way that felt true and readable. Fidelity is tough, who knew (also relevant to conversation…)
The Politics of Transcription — Notes
— Interpretive Decisions (what is transcribed)
— Representational Decisions (how is it transcribed)
both contextualized by process, dependent upon transcriber’s own expectations and beliefs about the speakers and their interaction, the intended audience of the transcript, and its purpose.
— Naturalized Transcription (text conforms to written discourse conventions)
— Denaturalized Transcription (retains links to oral discourse forms)
— General Thoughts
Very interesting that the author of the transcript is so much more a part of it than one would think., You think of writing a conversation as a 1 to 1 transfer of information, but so much can be left out or added.
In middle school, I won a state wide contest in “Listening” (I can’t remember the type of competition this event was for), where I had to listen to a recording and take notes on it, then answer questions based on my notes. Fascinating to think about in this context, and a funny bit of my past that I hadn’t remembered until now…
— Interesting Key for Symbols:
Each line represents an intonation unit.
. end of intonation unit; falling intonation
, end of intonation unit; fall-rise intonation
? end of intonation unit; rising intonation
— self-interruption; break in the intonational unit
- self-interruption; break in the word, sound abruptly cut off
underline emphatic stress or increased amplitude
(.) pause of 0.5 seconds or less
(n.n) pause of greater than 0.5 seconds, measured by a stopwatch
h exhalation (e.g., laughter, sigh); each token marks one pulse
( ) transcriber comment
< > uncertain transcription
(()) nonvocal noise
[ ] overlap beginning and end
[[ ]] second overlap in proximity to the first
([ ]) phonetic transcription
= latching (no pause between speaker turns)
— Looked up on how to transcribe stuttering, since I do that a lot, and found an interesting article on verbatim vs clean copy transcripts: