Geeta Dayal's review of the book in Slate

Discussion on Reddit r/Programming, including a hilarious Enterprise Java version.

A discussion at Stack Overflow stemming from a Bash shell version posting.

A discussion on Hacker News, which also features a number of re-implementations.

A post on Boing Boing, which also includes a good comment thread.

void draw() {
  frameRate(20);
  int x = frameCount%20*5;
  int c = int(random(2))*5;
  line(x+c, 95, x+5-c, 100);
  if (x==95) {
    PImage s = get();
    background(204);
    image(s, 0, -5);
  }
}

void draw() {
  int x = frameCount%20*5;
  int c = int(random(2))*5;
  line(x+c,89,x+5-c,94);
  if (x==95) set(0,0,get(0,5,100,x));
}

void draw() {
  int x = frameCount%20*5;
  int c = int(random(2))*5;
  line(x+c, 89, x+5-c, 94);
  if (x==95) set(0, 0, get(0, 5, 100, x));
}

void draw() {
  int x = frameCount%20*5;
  int c = int(random(2))*5;
  line(x+c,89,x+5-c,94);
  if (x==95) copy(0,0,100,100,0,-5,100,100);
}

The top is shorter, but the bottom is more efficient with copy() moving the pixels
 

void draw() {
  int x = frameCount%33*3;
  int c = int(random(2))*3;
  line(x+c,94,x+3-c,96);
  if (x==96) copy(0,0,100,100,0,-3,100,100);
}

String s="";
void draw() {
  s += "/\\".charAt((int)random(2));
  textFont(createFont("",10,false),10);
  text(s,0,93);
  if (s.length() == 33) {
    copy(0,0,100,100,0,-7,100,100);
    s = "";
  }
}

1. void draw() {
2.   int x = frameCount3*3;
3.   int c = int(random(2))*3;
4.   line(x+c,93,x+3-c,96);
5.   if (x==96) copy(0,0,100,100,0,-3,100,100);
6. }

1. void draw() {
2.   int x = frameCount3*3;
3.   int c = int(random(2))*2;
4.   line(x+c,94,x+2-c,96);
5.   if (x==96) copy(0,0,100,100,0,-3,100,100);
6. }

int w = 200; // canvas size
int n = 25;  // number of grid cells
int d = w/n; // diameter of a grid cell
boolean[][] memory = new boolean[n][n]; // core memory ;-)

void setup() {
  size(w, w);
  noSmooth();
}

void draw() {
 
  // draw the raster
  background(255);
  scale(d);
  strokeWeight(1.0/d);
  for (int x=0; x<n; x++) {
    for (int y=0; y<n; y++) {
      int r = memory[x][y] ? 1 : 0;
      line(x, y+r, x+1, y+1-r);
    }
  }
 
  // rescale and constrain mouse coordinates
  int mX = constrain(mouseX/d, 0, n-1);
  int pmX = constrain(pmouseX/d, 0, n-1);
  int mY = constrain(mouseY/d, 0, n-1);
  int pmY = constrain(pmouseY/d, 0, n-1);
 
  // flip line when the mouse moves to a new square
  if(mX != pmX || mY != pmY) {
    memory[mX][mY] = !memory[mX][mY];
  }
 
}

//////////////////////////////////////////
//                                      //
//    10 PRINT - Stacked 3D Version     //
//                                      //
//////////////////////////////////////////

// Works best in Processing 2.0 JavaMode

int w = 400; // canvas size
int n = 10;  // number of grid cells
int d = w/n; // diameter of a grid cell
float depth = 0.5; // relative cell depth

void setup() {
  size(w, w, P3D);
  rectMode(CENTER);
  background(255);
  strokeWeight(3);
  fill(204);
}

void draw() {

  // get coordinates
  int xy = frameCount % (n*n);

  // shift image in z-direction
  if (xy == 0) {
    PImage img = get();
    background(255); 
    pushMatrix(); 
    translate(0, 0, -d * depth);
    tint(255, 127);
    image(img, 0, 0);
    popMatrix();
  }

  // scale and rotate the square
  scale(d);
  translate(xy%n + .5, xy/n + .5, -depth * .5 );
  rotate(QUARTER_PI - HALF_PI *int(random(2)));
  rotateX(HALF_PI);
  
  // draw the square
  rect(0, 0, sqrt(2), depth);
  
}

void setup() {
  size(400, 400, P3D);
  rectMode(CENTER);
  background(255);
  fill(0, 0, 255);
  noStroke();
}

/* @pjs preload="REAS.png"; */

PImage img;
int d, n = 50;

void setup() {
  size(400, 400);
  d = width/n;
  img = loadImage("REAS.png");
  img.resize(n, n);
}

void draw() {
  int m = constrain(130 * mouseX / width, 1, 129);
  loadPixels();
  for(int x = 0; x < n; x++) for(int y = 0; y < n; y++) {
    float val = 256 - (img.pixels[y*n+x] & 255);
    for(int dx = 0; dx < d; dx++) for(int dy = 0; dy < d; dy++) { 
      int z = val % (2*m) < m ? (dx+dy+1) * 255 / d : (dx+d-dy) * 255 / d;
      pixels[ (y*d + dy) * width + (x*d + dx) ] = val > 2 * abs(z - 255) + 2 ? #000000 : #ffffff; 
    }
  }
  updatePixels();
}

PImage img;
PShader shd;
int w = 50, h = 50;

void setup() {
  size(400, 400, P2D);
  ((PGraphicsOpenGL) g).textureSampling(2); 
  img = loadImage("REAS.png");
  img.resize(w, h);
  shd = loadShader("10PRINT.frag");
  shd.set("imageRes", float(width), float(height));
  shd.set("sampleRes", float(w), float(h));
}

void draw() {
  shd.set("m", float(mouseX) / width);
  shader(shd);
  image(img, 0, 0, width, height);
}

// 10PRINT.frag - GLSL 10 PRINT filter - bitcraft lab 2012

uniform sampler2D textureSampler;
uniform vec2 imageRes;
uniform vec2 sampleRes;
uniform float m;

void main(void) {
 
	// get texture position
	vec2 pos = gl_FragCoord.xy;
	pos.y = imageRes.y - pos.y;
	
	// get block position
	vec2 d = imageRes / sampleRes;
	vec2 delta = mod(pos, d);
	
	// sample texture brightness
	float val = 1.0 - texture2D(textureSampler, pos / imageRes).r;

	// 10 PRINT dithering
	float z = (delta.x + (mod(val, 2.0 * m) <  m ? delta.y * d.x / d.y : d.x - delta.y * d.x / d.y)) / d.x;
	gl_FragColor = vec4(vec3(val > 2.0 * abs(z - 1.0) ? 0.0 : 1.0), 1.0);

}

int j = 0; int k =0;
//char c[] = new char[]{'\\','/','|','—',' '};
char c[] = new char[]{'\\','/',' '};

void draw() {
  for (int i = 0; i < 40-abs(20-j); ++i) {
     print(c[i>abs(20-j)?(int)(Math.random()*(c.length-1)):c.length-1] + " ");
  }
  j=(j+1)%40;
  println();
}

1. int S=500, N= 200, o=S/2, i= 4, r;
2. float s= TWO_PI/N;
3. PVector[] T;
4. 
   
5. void setup () {
6.       size (S,S);
7.       smooth ();
8.       T = new PVector[N];
9.       for (int n=0; n<N; n++) T[n] = new PVector (cos (n*s), sin (n*s));
10. }
11. 
    
12. void draw () {
13.       for  (int p=0, j=p+1, r1, r2; p<N; p++, j=(p+1)%N) {
14.       r1=r2=r;    
    
15.       if (random(1)<.5) r1=r+i; else r2=r+i;
16.       line ( o+T[p].x*r1, o+T[p].y*r1, o+T[j].x*r2, o+T[j].y*r2 );
    
17.       }
18.       r+=i;
19. }
    

1. int s=40;
2. void setup() {
3.   size(640,480);
4.   background(255);
5.  
6.   colorMode(HSB);
7. }
8. void draw() {
9.   filter(ERODE);filter(ERODE);
10.   tint(230);
11.   image(get(),0,5);
12.  
13.   strokeWeight(15);
14.   strokeCap(PROJECT);
15.  
16.   for(int x=0; x < width; x+=s) {
17.     for(int y=0; y < height; y+=s) {
18.       stroke(map(y,0,height,90,120),255,200);
19.       if(noise(x/50f,y/50f,frameCount/100f)>0.5) {
20.         line(x,y,x+s,y+s);
21.       } else {
22.         line(x+s,y,x,y+s);
23.       }
24.     }
25.   }
26. }

1. int y = 1;
2. void draw() {
3.   int x = frameCount%20*5;
4.   int c = int(random(2))*5;
5.  
6.  if (y==1){
7.   fill(255,255*int(random(1)),0);
8.  }
9.  
10.  if(y==2){
11.   fill(255*int(random(1)),0,255);
12.  }
13.  if(y==3){
14.   fill(255,255,255*int(random(1)));
15.  }
16.  
17.  if(int(random(6))>=1){
18.    fill(255,255,255);
19.  }
20.  
21.   rect(x+c,89,x+5-c,94);
22.   if (x==95) set(0,0,get(0,5,100,x));
23.   y = int(random(4));
24. }