No Blame Project – Creative Coding Collaboration with Tyler Carter

Creative Writing to Creative Coding

This year I have finally started to take on and complete some serious creative coding projects. For about a decade I have been satisfied to write with software created by others — mchain, Gnoetry, etc. Now I am working to creating digital poetry, digital arts and interactive writing systems of my own, customized for new writing projects. I’ve settled on the Processing generative arts language/environment to begin with, and have worked mostly in Java at this point. I am just starting to work with p5.js too, which is a javascript variant of Processing using pretty much the same syntax.

Earlier this year I completed my first complete sketch, or program, which I had drafted almost two years ago. You can read about that program here: LINEmaker v. 0.2. That project is text-based but also incorporates user interaction to create simple visual poems.

I’ll be writing more on my work with digital poetry and Processing soon, either here or at a new website, as my work progresses.

Collaborating on No Blame with Poet Tyler Carter

Beginning in July of this year, I began working with my friend and fellow poet/writer Tyler Carter to implement a writing system he had used several years before as a computer program. I was still learning basic coding skills with Processing, so I chose to continue using it even though this project would only really be sorting text and using I Ching casting methods to put together a book of 64 poems — i.e. there would be no interaction or anything drawn to the screen. I felt that Java and Processing would work well for this even though the project would not take advantage of any of the special features of the Processing language/environment.

The No Blame project has been complete now (the book, at least) for about a month, and I feel it has been a very successful collaboration. The permutations of the 256 lines of text, set by the program into 4 sets of 16 poems of 16 lines each, are kaleidoscopic and regularly engaging — something that does not always happen with conceptual computational systems like this. The four sets are arranged as: (1) the original 16 poems written from the 256 lines, (2) the same lines rearranged into 16 lists of 16 lines each according to linguistic/other characteristics, (3) the original poems “remixed” according to a set of unique (as in non-repeating and comprehensive) stanza patterns, and (4) the linguistic lists “remixed” in the same fashion.

The I Ching plays a significant role in the work, and it brings a sense of wholeness to the work as well as connecting to a longer tradition of using the I Ching in process poetry (Jackson Mac Low and John Cage, for example). The work does not connect thematically with the I Ching, nor should it be thought to have any oracular use; instead, it seeks to mirror/reproduce the architecture or structure of the mystical system. All of the poems are ordered and titled according to the unique I Ching hexagram cast by the program at its final stage of assembling the book, so the four sets mentioned above are not discrete, but are all interwoven together through the book. All 64 hexagrams are represented in the book, hinting to the representation of the whole person through the parallel systems of the hexagram titles and the assembled (and reassembled) statements of the poems.

Tyler and I are sending the manuscript out to presses soon for publication, but you can view the code, which I have commented heavily, at GitHub (see link below). If you are a publisher interested in works of computational or process poetry, I’d be glad to hear from you (see the Contact Me page for contact).

This project has helped me to grow as a programmer quite a bit, and I am proud of some of the solutions I made to rather complex problems, like how to create a set of 16 non-repeating four-line stanza patterns from the numbers 1-16 using all numbers exactly 4 times in each of the four stanza slots (each line in the pattern is a “slot”). That was quite tricky. Creating a simple alphanumeric system for representing I Ching hexagrams took some thought as well. Collaborating with another poet to construct a computation poetry program has been very rewarding as well, and I hope for more collaborations in the future as programmer and poet/programmer.

Code for No Blame at GitHub


LINEmaker : a concrete poem maker written in Processing 2

Click here for LINEmaker

LINEmaker is the fruit of my labor to move my concrete poem series LINES from OpenOffice, where I was using the advanced font settings to create poems from letters smashed closely together (and taking advantage of some of OpenOffice’s glitches with this). Here are two of my favorite New LINES poems: line-010813

New-LINES-HarkThe program takes this basic idea, but adds more interaction and options. It was coded in Processing and exported to javascrpt.

To use LINEmaker, you must first click in the canvas area to begin writing, then you can move the mouse horizontally to expand/condense the font spacing and vertically to adjust the transparency of the text.

Here are some screenshots from LINEmaker:

131114_185514_19692131114_185934_35270131114_144858_33795 131114_134325_1151

Click here for LINEmaker


View and Purchase My Digital Art at Redbubble!

redbubble_logoLast week, I joined the online arts community/store Redbubble, and there are now 17 of my artworks up for sale as prints, posters or greeting cards. I have already documented some of my process of making these works, but you can also find more details in the descriptions for each image and in my public profile statement.

This has been a year in the works so far. I’m excited to see what kind of response my work gets, and my profile is only going to grow in interest as I get further into learning Processing 2.0 and using databending techniques.

Check out eRoGK7’s profile and portfolio at Redbubble!

Self-Portraits created in Processing + GIMP

I’ve begun learning a programming language again. This time its Processing, and I’m finally getting serious about it. I just received a copy of Matt Pearson’s Genarative Art last month, but I’m working through the examples in Generative Design: Visualize, Program and Create with Processing by Hartmut Bohnacker, Benedikt Gross, Julia Laub and Claudius Lazzeroni first.

These self-portraits were the result of applying sketch P_4_3_2_01 (with text and character attributes tweaked a bit in the code) to a profile picture of mine. As the process used was typographic, and this is a self-portrait, I used my first name as the text to be repeated. The shapes of the large letters, stacked into elongated cylinders, distort the features and colors of my face into strangely evocative curves and knives. The images captured from the processing session were then enlarged and passed through many filters until they came out as they have.

I haven’t learned enough to really create my own generative art / digital poetry code, but tweaking other people’s code has always been the best way for me to figure out what’s going on in the code. I’ll keep plugging away, and coding my heart out.


Note: They look better at full size, so click on them to view them at 100%.



The image file used as input in Processing.


self-portrait-processing-gimp-4 self-portrait-processing-gimp-3 self-portrait-processing-gimp-1 self-portrait-processing-gimp-2