Victor Sira was kind enough to take much better photos of my YEEP book than I’d had on my blog. The posts can be found on his tumblr.

Not to be too much of a self-promoter, but remaining copies of the book are available for $10 + shipping. They are from an edition of 100. If you're interested, contact me at site@danieltemkin.com.

for the C64... more to come

Here are shots of my Yeep!Eep!Eep! book. It's an edition of 100, each is 16 pages. I have some left over, so please contact me if you'd like one (I'm selling them for $CHEAP).

Here's me with my YEEP book at the art book fair. It was HOT in the room due to the unbelievable turn out -- thousands of warm bodies in that space. But it was worth it -- found tons of great books.

The ICP table. Somehow Garret and Nayland don't look nearly hot enough to have spent hours there. In the top photo, I've been there about ten minutes.

My YEEP book.

Come by this weekend and check out the NY Art Book Fair at PS1! ICP has a table where you'll find a book of images produced by my Yeep!Eep!Eep! program, along with books by other ICP students and alumni.

There will also be an open studios at our space in LIC down the street from PS1. I'll be there 11-3 on Saturday and will likely be in and out the rest of the weekend.

I'm pleased to be part of this year's Make Art conference in Poitiers, France.

My Yeep!Eep!Eep!Program will be included among some fantastic open source art projects from Nov 4 to 7. Unfortunately I won't be able to attend this year, but I'll be following the conference closely online. I'm thankful to Make Art for taking an interest in YEEP -- and making the effort to buy a C64 on eBay and type in my program by hand -- and I'm thankful for their support for open source projects in general.

The source code for YEEP is offered under the Creative Commons Attribution 2.5 license. It was written in BASIC with comments included, to make it easier for other programmers to experiment with and build on it. These comments have become part of the aesthetic of the program itself as they often appear onscreen as YEEP runs.

Two images of me by Teresa Christiansen, shot for her Méconnaissance series.

Yeep!Eep!Eep!Program (or YEEP) is my new glitch art app for the C64.

YEEP draws data to the screen, using whatever happens to be sitting in RAM at the moment, interpreted through character sets controlled by the user.

Since YEEP switches video banks when it starts up, it will function differently depending on what is sitting in memory. Using it right after a large program was loaded can create a different set of graphics. It will also look different depending on what was written to the screen when the program began. One way to alter the look of the final image is to draw characters to the screen manually before launching the program.

Once you've launched YEEP, here are the controls:

Controls

">" (or right arrow key) : cycle to next character set
"<" (or left arrow key) : cycle to previous character set

"c" : change background color (cycles through each of the 16 options)
"x" : add random characters

Changing Color

When YEEP first opens, it is in multi-color mode. The first time the "+" key is used, it takes it out of multi-color mode, into black & white.

WARNING: These color controlsare significantly slower than the others. They poke each of the control registers individually to recolor each character across the screen.

"+" : Add color. The first time this is used, it sets it to black and white. On each successive click, it adds an additional color, distributed randomly across the characters
"-" : Subtract color. Removes one color.
"b" : Reset. Clears color changes and goes back to multi-color mode.

This is a C64 program which uses pseudographics to create a circuit board-like pattern of vines across the screen, starting in the upper left and flowing to the bottom right. Each vine randomly changes direction as it goes. It uses box-drawing characters for vines and circles for the fruit or flowers (or what have you).

It's my first crack at a C64 program -- in the last 20 years anyway. The difference in programming for this type of system vs. what I work with on a daily basis is astonishing. It requires unlearning every good programing practice I've used since college, in order to get something that will run in any resonable amount of time. It was a challenge keeping lines under 80 characters, using two-letter variable names (and trying to carry meaning in those two letters enough to keep track of what they represent), skimping on comments, keeping track of line numbers, etc. Luckily, since this is a short program that doesn't need this to run too fast, I was able to compromise between the two approaches. It's a little slower than I'd like, but I kept it pretty comprehensible; luckily we have emulators with Warp mode.

This is leading up to a C64 Glitch program that's in development now: more on that later.

Images from the program:

Multi-color version:

More C64 goodness to follow soon. This is all warming up for a C64 glitch program I'm working on now.

Here's the actual code:

100 print chr$(147) : rem clear screen

110 print "drawing..."

: rem constants
120 let c0 = 9216 : rem upper left block
125 let c1 = 25 : rem number of rows
130 let c2 = 40 : rem number of cols
135 let c3 = 55296 : rem upper left color

220 for co = 0 to 10
230 read a :let al(co) = a :rem left-facing images
240 next co
250 data 64,67,73,75,110,125,113,114,115,91,87

260 for co = 0 to 10
270 read a :let ar(co) = a :rem right-facing images
280 next co
290 data 64,67,74,85,91,109,112,107,113,114,91

300 for co = 0 to 10
310 read a :let au(co) = a :rem up-facing images
320 next co
330 data 66,74,93,109,125,107,113,114,115,91,87

340 for co = 0 to 10
350 read a :let ad(co) = a :rem down-facing images
360 next co
370 data 66,66,73,85,93,110,107,114,115,91,87

373 for co = 0 to 5
375 read a :let ab(co) = a :rem both-facing (up and left) images
377 next co
380 data 75,91,87,113,115,125

400 for a = c0 to c0 + (c1 * c2)
410  let pc = peek(a-1) :rem pc = prior char
412  let uc = peek(a-c2) :rem uc = upper char
415  let hl = 0 :rem hl = has left
417  let hu = 0 :rem hu = has up

420   for b = 0 to 10
425    if pc = ar(b) then hl = 1
430    if pc - 128 = ar(b) then hl = 1
435   next

440   for b = 0 to 10
443    if uc = ad(b) then hu = 1
445    if uc - 128 = ad(b) then hu = 1
447   next

     :rem initial row and column
450  let rg = int(rnd(0)*20)
451  if rg = 0 then rg = 1
452  if rg = 2 then rg = 3
453  if a < c0 + c2 then goto 460 : rem if top row, choose upfacing
455  if (a - c0) / c2 = 0 then goto 480 : rem if left col, choose rightfacing
458  goto 495
460   let ri = int(rnd(0)*3)
465   if ri = 0 then let rg = 2
470   if ri > 0 then let rg = 4
475  goto 495
480   let ri = int(rnd(0)*3)
485   if ri = 0 then let rg = 0
490   if ri > 0 then let rg = 4

495  rh = int(rnd(0)*11) :rem random char indexer
500  rem get items for left or down facing items nearby
505  if hl = 1 and hu = 1 then goto 540
510  if hl = 1 then im = al(rh)
520  if hu = 1 then im = au(rh)
530  goto 590
540   rj = int(rnd(0)*6) :rem random char index
550   im = ab(rj)

590  if hu = 1 or hl = 1 then poke a, im
595  if (hu = 1 or hl = 1) and im = 87 then poke a + c3 - c0, 15

599  rem ordinary random chars
600  if rg = 0 then im = al(rh)
610  if rg = 1 then im = ar(rh)
620  if rg = 2 then im = au(rh)
630  if rg = 3 then im = ad(rh)
640  if rg >= 4 then im = 32 :rem space

700  if hl = 0 and hu = 0 then poke a, im :rem 128 + im for inverse
720  if hl = 0 and hu = 0 and im = 87 then poke a + c3 - c0, 15
730 next

800 poke 53272,(peek(53272)and15)or144
810 rem activate drawing

999 end