Supercut

This class could very easily become “Donald Trump: The Class” and while I do find that interesting, I’m hesitant to make work about the man. I just don’t want to give him the attention. I don’t want him to have any more press coverage. I don’t want to give him my time. I don’t want to spend the time with his digital presence that making the work would require. He is awful. I just don’t want to.

So, I started looking at material of the other candidates. I cut up some of Hillary Clinton’s testimony at the Benghazi hearings. But, listening to people say ‘Chris Stevens’ over and over again was somehow worse. I kept trying to make something that critiqued the act of using this man’s death for one’s own means, but I couldn’t do that without using his death for my own means. I can see that being a struggle for the rest of the semester. Critiquing video coverage of a topic in a video class without doing the very thing you’re objecting to may be harder than it looks. I put the Benghazi video away.

In the end I found myself back at Donald Trump. I realized that I really wanted to yell at him. I wanted to tell him that he is an idiot, a coward, and that he isn’t smart enough to be president. I wanted to point to him and say “Can’t you see that this man is afraid?”. I don’t think that the supercut I made does that, but I do like what it does. I cut together all his promises from one speech and then laid text over his face that says “Mr. Trump does not know how to get any of this done.” It’s not a particularly cutting observation, but it’s a start.

Seeing is Forgetting

That’s the difference between being a West Coast artist and a European. A European artist really believed in himself as part of the historical tradition, that archive…Obviously, you think what you do is important, or you wouldn’t be pursuing it with the kind of intensity you do. But the minute I start thinking about making gestures about my historical role, I mean, I can’t do it, I have to start laughing, because there’s a certain humor in that.

It has taken me a long time to realize I don’t have to make art that engages with the artistic canon. Growing up it was natural to go to the museum and draw the statues. College was more of the same. Your work wasn’t anything if you didn’t know what came before you, if you didn’t know what everyone else was up to, if you weren’t reading the theory. That made a lot of sense to me, so I sunk into the history of art and writing about it. I engaged in ‘the discourse’. But, I think in the end it starved my projects of life. I made work that seemed ‘right’ and ‘good’, but burned out on it. I found that while I took great joy in fabricating the work, the pieces were somehow dead.

I stopped making things for a while after that. And I started to think that maybe I didn’t have it in me to be an artist, or a creator, or whatever it is that we do. That thought made me sad, but it passed. Eventually though, I realized that not making things was making me, not unhappy, but numb.
So now I try and make things again. But I try to keep a blind eye to ‘the discourse’ and ‘the canon’ (at least, compared to before, I can’t seem to stop loving to argue about art). I’m trying to focus on things that are fun, or funny. Things that will help people I can see around me in my neighborhood, or people I know. It feels so much better to think of every object as an iteration or experiment and to be free of any place in history or expectation of it.

Glow Blocks Accelerometers

Accelerometer and LEDs from coldsoup753 on Vimeo.

I had a great deal of trouble with the accelerometers of this project. I tried the ADXL335 and the MPU-6050 (as the MPU-6050 page says, “Reading raw values is easy, the rest is not”). Both accelerometers were good at spitting out data, but it was extremely difficult to get that data to be anything other than seemingly random numbers.

Eventually I found the ADXL345, which is simply the updated version of the ADXL335, and that turned out to be exactly the part that I needed. I combined this tutorial with my RGB LED code from my RGB Pencil project to make an LED light up a specific color when the accelerometer senses a tap, double tap, free fall, and inaction.

I tested this out by strapping a breadboard to my Arduino and dropping it a whole bunch of times, and it worked just fine. I originally planned on using the TLC5940NT to drive a whole bunch of RGB LEDs, but that did not work out. I ended up simply using the remaining pins on the Arduino.

 

/Arduino 1.0+ Only!
//Arduino 1.0+ Only!

#include 
#include 

//Accelerometer code from here: http://bildr.org/2011/03/adxl345-arduino/
ADXL345 adxl; //variable adxl is an instance of the ADXL345 library

int RED_PIN = 13; //set pins for LEDs
int GREEN_PIN = 12;
int BLUE_PIN = 11;
int RED_PIN2 = 10; //set pins for LEDs
int GREEN_PIN2 = 9;
int BLUE_PIN2 = 8;
int RED_PIN3 = 7; //set pins for LEDs
int GREEN_PIN3 = 6;
int BLUE_PIN3 = 5;
int RED_PIN4 = 4; //set pins for LEDs
int GREEN_PIN4 = 3;
int BLUE_PIN4 = 2;



void setup(){
  Serial.begin(9600);
  adxl.powerOn();
  pinMode(RED_PIN, OUTPUT);
  pinMode(GREEN_PIN, OUTPUT);
  pinMode(BLUE_PIN, OUTPUT);
  pinMode(RED_PIN2, OUTPUT);
  pinMode(GREEN_PIN2, OUTPUT);
  pinMode(BLUE_PIN2, OUTPUT);
  pinMode(RED_PIN3, OUTPUT);
  pinMode(GREEN_PIN3, OUTPUT);
  pinMode(BLUE_PIN3, OUTPUT);
  pinMode(RED_PIN4, OUTPUT);
  pinMode(GREEN_PIN4, OUTPUT);
  pinMode(BLUE_PIN4, OUTPUT);

  //set activity/ inactivity thresholds (0-255)
  adxl.setActivityThreshold(75); //62.5mg per increment
  adxl.setInactivityThreshold(75); //62.5mg per increment
  adxl.setTimeInactivity(5); // how many seconds of no activity is inactive?
 
  //look of activity movement on this axes - 1 == on; 0 == off 
  adxl.setActivityX(1);
  adxl.setActivityY(1);
  adxl.setActivityZ(1);
 
  //look of inactivity movement on this axes - 1 == on; 0 == off
  adxl.setInactivityX(1);
  adxl.setInactivityY(1);
  adxl.setInactivityZ(1);
 
  //look of tap movement on this axes - 1 == on; 0 == off
  adxl.setTapDetectionOnX(0);
  adxl.setTapDetectionOnY(0);
  adxl.setTapDetectionOnZ(1);
 
  //set values for what is a tap, and what is a double tap (0-255)
  adxl.setTapThreshold(50); //62.5mg per increment
  adxl.setTapDuration(15); //625μs per increment
  adxl.setDoubleTapLatency(80); //1.25ms per increment
  adxl.setDoubleTapWindow(200); //1.25ms per increment
 
  //set values for what is considered freefall (0-255)
  adxl.setFreeFallThreshold(5); //(5 - 9) recommended - 62.5mg per increment
  adxl.setFreeFallDuration(20); //(20 - 70) recommended - 5ms per increment
 
  //setting all interupts to take place on int pin 1
  //I had issues with int pin 2, was unable to reset it
  adxl.setInterruptMapping( ADXL345_INT_SINGLE_TAP_BIT,   ADXL345_INT1_PIN );
  adxl.setInterruptMapping( ADXL345_INT_DOUBLE_TAP_BIT,   ADXL345_INT1_PIN );
  adxl.setInterruptMapping( ADXL345_INT_FREE_FALL_BIT,    ADXL345_INT1_PIN );
  adxl.setInterruptMapping( ADXL345_INT_ACTIVITY_BIT,     ADXL345_INT1_PIN );
  adxl.setInterruptMapping( ADXL345_INT_INACTIVITY_BIT,   ADXL345_INT1_PIN );
 
  //register interupt actions - 1 == on; 0 == off  
  adxl.setInterrupt( ADXL345_INT_SINGLE_TAP_BIT, 1);
  adxl.setInterrupt( ADXL345_INT_DOUBLE_TAP_BIT, 1);
  adxl.setInterrupt( ADXL345_INT_FREE_FALL_BIT,  1);
  adxl.setInterrupt( ADXL345_INT_ACTIVITY_BIT,   1);
  adxl.setInterrupt( ADXL345_INT_INACTIVITY_BIT, 1);
}

void loop(){
  
  //Boring accelerometer stuff   
  int x,y,z;  
  adxl.readAccel(&x, &y, &z); //read the accelerometer values and store them in variables  x,y,z

  // Output x,y,z values - Commented out
  //Serial.print(x);
  //Serial.print(y);
  //Serial.println(z);


  //Fun Stuff!    
  //read interrupts source and look for triggerd actions
  
  //getInterruptSource clears all triggered actions after returning value
  //so do not call again until you need to recheck for triggered actions
   byte interrupts = adxl.getInterruptSource();
  
  // freefall
  if(adxl.triggered(interrupts, ADXL345_FREE_FALL)){
    Serial.println("freefall");
    showRGB(200);
  } 
  
  //inactivity
  if(adxl.triggered(interrupts, ADXL345_INACTIVITY)){
    Serial.println("inactivity");
     showRGB(400);
  }
  
  //activity
  if(adxl.triggered(interrupts, ADXL345_ACTIVITY)){
    Serial.println("activity"); 
     showRGB(700);
  }
  
  //double tap
  if(adxl.triggered(interrupts, ADXL345_DOUBLE_TAP)){
    Serial.println("double tap");
     showRGB(300);
  }
  
  //tap
  if(adxl.triggered(interrupts, ADXL345_SINGLE_TAP)){
    Serial.println("tap");
    showRGB(100);
  } 

 
}


void showRGB(int color)
{
  int redIntensity;
  int greenIntensity;
  int blueIntensity;

  // Here we'll use an "if / else" statement to determine which
  // of the three (R,G,B) zones x falls into. Each of these zones
  // spans 255 because analogWrite() wants a number from 0 to 255.

  // In each of these zones, we'll calculate the brightness
  // for each of the red, green, and blue LEDs within the RGB LED.

  if (color <= 255)          // zone 1
  {
    redIntensity = 255 - color;    // red goes from on to off
    greenIntensity = color;        // green goes from off to on
    blueIntensity = 0;             // blue is always off
  }
  else if (color <= 511) // zone 2 { redIntensity = 0; // red is always off greenIntensity = 255 - (color - 256); // green on to off blueIntensity = (color - 256); // blue off to on } else // color >= 512       // zone 3
  {
    redIntensity = (color - 512);         // red off to on
    greenIntensity = 0;                   // green is always off
    blueIntensity = 255 - (color - 512);  // blue on to off
  }

  // Now that the brightness values have been set, command the LED
  // to those values

  analogWrite(RED_PIN, redIntensity);
  analogWrite(BLUE_PIN, blueIntensity);
  analogWrite(GREEN_PIN, greenIntensity);
  analogWrite(RED_PIN2, redIntensity);
  analogWrite(BLUE_PIN2, blueIntensity);
  analogWrite(GREEN_PIN2, greenIntensity);
  analogWrite(RED_PIN3, redIntensity);
  analogWrite(BLUE_PIN3, blueIntensity);
  analogWrite(GREEN_PIN3, greenIntensity);
  analogWrite(RED_PIN4, redIntensity);
  analogWrite(BLUE_PIN4, blueIntensity);
  analogWrite(GREEN_PIN4, greenIntensity);
}

Wikipedia Article Visualization – Proposal

My main challenge with this project has been that I knew that I wanted to make some kind of data visualization, but I did not have a strong idea of the data I wanted to visualize. Dano suggested in class that the main challenge for data-viz is often finding the question that you want to answer. I gave some thought to questions that interested me, what kind of visualizations I enjoy, and came up with a question I would like answered:

Is there an article imbalance on Wikipedia?

At the moment Wikipedia is the working authority on basically everything. But like any other source of information it has its biases and limits. I’d like to explore what those limits might be. To that end, I would like to make a cartogram showing the size of a country relative to how many english language history articles it has on Wikipedia. There would be a timeline slider, so you can see how different historical periods are represented.

I would have to create the dataset either using the Wikipedia API or by downloading the relevant sections as XML.

Inspiration Visualizations:

Interesting interactive cartogram: http://www.carbonmap.org/

Population Cartogram

 

Not a Cartogram

Questions:

Thoughts on showing information on a cartogram vs 

How important is it to include information from other languages?

Is D3.js the best way to make this visualization? Is there a good intro to D3?

Infinite Pong, again

http://itp.jscottdutcher.com/pong4/

This week, much like last week, was an exercise in not getting as much done as I would have liked. Adding functions to my previous code was a breeze, until I ran it and kept getting an uncaught reference error. It took me ages to figure out where I was missing a curly bracket and I felt like a right fool the whole time I was looking. Oh well! It remains remarkably satisfying when your code works, even when all it is is a meager refactor.

ar gameStart = false;
var paddleL = {
  x: 10,
  y: 100,
  w: 15,
  h: 100,
};
var paddleR = {
  x: 770,
  y: 100,
  w: 15,
  h: 100,
};
var ball = {
  x: 50,
  y: 20,
  diam: 25,
  speedX: 5,
  speedY: 5,
};
var speedX = 5;
var speedY = 5;
var paddleSpeed = 12;
var s = "Welcome to Infinte Pong! Player one controlls their paddle with the a and z keys. Player two controls their paddle with the /? key and the '\" key. Press the space bar to begin";

/*function down(x){
 x = x + 5;
}*/


function setup() {
  createCanvas(800, 600);
  smooth();
  //background(0);
  //fill(255)
  //text(s, 10, 10, 70, 80);
}

function draw() {

  //if (keyPressed(32) === true) {
  gameStart === true;
  //}
  
    background(64, 161, 76);
    noStroke();

  createLeftPaddle();
  createRightPaddle();
  createBall();
  ballBounceTopAndBottom();
  ballBounceRight();
  ballBounceLeft();
  
  

}
  function createBall() {
    //Create ball
    fill(198, 237, 44);
    ellipse(ball.x, ball.y, ball.diam, ball.diam);

    ball.x = ball.x + speedX;
    ball.y = ball.y + speedY;
  }



  function createLeftPaddle() {
    //Create the left paddle
    fill(0, 50, 50);
    rect(paddleL.x, paddleL.y, paddleL.w, paddleL.h);
    //Control the left paddle
    if (keyIsDown(90) === true) {
      if (paddleL.y + paddleL.h < height - 5) { paddleL.y = paddleL.y + paddleSpeed; } } if (keyIsDown(65) === true) { if (paddleL.y > 5) {
        paddleL.y = paddleL.y - paddleSpeed;
      }
    }
  }

  function createRightPaddle() {
    //Create the right paddle
    fill(50, 50, 0);
    rect(paddleR.x, paddleR.y, paddleR.w, paddleR.h);
    //Control the right paddle

    if (keyIsDown(191) === true) { //move paddle down
      if (paddleR.y + paddleR.h < height - 5) { paddleR.y = paddleR.y + paddleSpeed; } } if (keyIsDown(222) === true) { //move paddle up if (paddleR.y > 5) {
        paddleR.y = paddleR.y - paddleSpeed;
      }
    }

  }

  function ballBounceTopAndBottom() {

    //If if the ball hits the top or bottom of the court it bounces
    if (ball.y + 12.5 > height || ball.y < 12.5 && ball.x > 0 && ball.x < width && ball.y > 0 && ball.y < height) { speedY = speedY * -1; //reverse the direction of the motion ball.y = ball.y + speedY; //keeps things moving print("wham"); } } function ballBounceRight() { //if the x of the edge ball is more than the x of the right paddle and //the y of the ball is greater than the y of the rectangle and //less than the y of the rectangle plus the height if (ball.x + 12.5 > paddleR.x && ball.y + 12.5 > paddleR.y && ball.y + 12.5 < paddleR.y + paddleR.h && ball.x > 0 && ball.x < width && ball.y > 0 && ball.y < height) { speedX = speedX * -1; //This reverses the direction, I think ball.x = ball.x + speedX; //This keeps the ball moving print("bam"); } //if the edge of the ball is lower than rect y and //the x of the ball is greater than the x of the rect and less than the width else if (ball.y + 12.5 > paddleR.y && ball.y < paddleR.y + paddleR.y + paddleR.h && ball.x + 12.5 > paddleR.x && ball.x < paddleR.x + paddleR.x && ball.x > 0 && ball.x < width && ball.y > 0 && ball.y < height) {
      speedY = speedY * -1; //reverse the direction of the motion
      ball.y = ball.y + speedY; //keeps things moving
      print("bam top");
    }

    //if the edge of the ball is higher than rect y plus height and 
    //the x of the ball is greater than the x of the rect and less than the width
    else if (ball.y + 12.5 < paddleR.y + paddleR.h && ball.y > paddleR.y && ball.x > paddleR.x && ball.x < paddleR.x + paddleR.h && ball.x > 0 && ball.x < width && ball.y > 0 && ball.y < height) {
      speedY = speedY * -1; //reverse the direction of the motion
      ball.y = ball.y + speedY; //keeps things moving
      print("bam bottom");
    }
  }

function ballBounceLeft() {
    //if the ball hits the left wall
    /* if (ball.x < 0) {
       speedX = speedX * -1; //This reverses the direction, I think
       ball.x = ball.x + speedX; //This keeps the ball moving
       print("pow");*/

    //if the ball hits the front of the left paddle
    if (ball.x - 12.5 < paddleL.x + paddleL.w && ball.y + 12.5 > paddleL.y && ball.y + 12.5 < paddleL.y + paddleL.h && ball.x > 0 && ball.x < width && ball.y > 0 && ball.y < height) {
      speedX = speedX * -1; //This reverses the direction, I think
      ball.x = ball.x + speedX; //This keeps the ball moving
      print("pow");
    }
  }

Infinite Pong

 

http://itp.jscottdutcher.com/pong3/

This was a frustrating project. I wanted to accomplish more with it than I did, and I know that they are things I can do but I eventually just ran out of time. A lot of that is leaving things to the last minute, which stops me from being able to get the project help that I need. I guess that’s something to be mindful of for the future.

Anyway, I guess this is something of a v1 of this project that I will continue to update.

I started out by looking at someone else’s pong game. I found a simple version written in processing here. I adapted that code for p5 and picked it apart until I understood what all the pieces did:

//original code borrowed from: http://www.openprocessing.org/sketch/47481

var gameStart = false;
var x = 150; //This is the x where the ball starts
var y = 150; //This is the y where the ball starts
var speedX = 5; //This is the speed of the ball's x coordinate
var speedY = 5; //This is the speed of the ball's y coordinate
var leftColor = 200; //This is the color of the left bar
var rightColor = 128; //This is the color of the right bar
var diam = 20; //This is the diameter of the ball
var rectSize = 150; //This is the size of the right paddle NOTE: When it resets the paddle gets bigger

function setup() {
  createCanvas(500, 500);
  noStroke();
  smooth();
}

function draw() {
  background(255);

  fill(128, 128, 128);
  ellipse(x, y, diam, diam);

  fill(leftColor);
  rect(0, 0, 20, 500); //This is the size of the left rectangle, but it is just for show
  fill(rightColor);
  rect(width - 30, mouseY - rectSize / 2, 10, rectSize); //This is the size of the right paddle and how it moves

  if (gameStart === true) {

    x = x + speedX;//This is the ball movement
    y = y + speedY;//This is also the ball movement. Why do we consider these separately?
  }

  // if ball hits left paddle, invert X direction and apply effects
  if (x > width - 30 && x < width - 20 && y > mouseY - rectSize / 2 && y < mouseY + rectSize / 2) 
  /*
  If x is greater than the width of the canvas - 30 and x is less than the width of the canvas - 20
  NOTE: I don't understand what the above does it seems to affect the size of the left paddle,
  but I don't know why
  and y is greater than the top of the rectange and the bottom of the rectangle then:
  */
  {
    speedX = speedX * -1; //This reverses the direction, I think
    x = x + speedX; //This keeps the ball moving
    rightColor = 0; //This makes the left paddle black for a sec
    fill(random(0, 128), random(0, 128), random(0, 128));//This is the splat color
    var diamHit = random(75, 150);//This is the splat animation
    ellipse(x, y, diamHit, diamHit);//This is also the splat animation
    rectSize = rectSize - 10; //This makes the left paddle smaller
    rectSize = constrain(rectSize, 10, 150); //This keeps the left paddle from disapearing compleatly
    print("pow");
  }

  // if ball hits wall, change direction of X
  else if (x < 25) //if the ball is less than this margin on the right side then: { speedX = speedX * -1.1;//This reverses the direction and makes it faster x = x + speedX; //This keeps the ball moving print("bam"); } else { //This resets the colors of the paddles to whatever they were before the 'hit' animation leftColor = 128; rightColor = 128; } // resets things if you lose if (x > width) {
  //If x moves out of frame
    gameStart = false; //State resets
    x = 150; //The ball goes back to here
    y = 150; //and here
    speedX = random(3, 5); //speed is random again
    speedY = random(3, 5); //speed is random again
    rectSize = 150; //the size of the right paddle resets
  }


  // if ball hits up or down, change direction of Y  
  if (y > height || y < 0) 
  //If y is greater than the height of the canvas or less than 0 then:
  {
    speedY = speedY * -1; //reverse the direction of the motion
    y = y + speedY; //keeps things moving
    print("wham");
  }
}


function mousePressed() { //changes the state at the beginning when mouse is pressed
  gameStart = true;
}

After I felt like I had a handle on things I set off writing my own code. I started with using keypresses to make the paddles work, as I wanted two people to be able to play this on one machine. After that seemed to be working I added the ball logic to the game. This is where I ran into some trouble.

I think that because I am describing the edges of the paddles instead of all of them the ball is getting caught behind the paddles and sometimes comes back into the canvas.

Additional things I wanted to add:

  • Intro screen with directions and a start button.
  • Sound when the ball hit a paddle or the wall
  • More balls, like one more every 5 seconds
var gameStart = false;
var paddleL = {
  x: 10,
  y: 100,
  w: 15,
  h: 100,
};
var paddleR = {
  x: 770,
  y: 100,
  w: 15,
  h: 100,
};
var ball = {
  x: 50,
  y: 20,
  diam: 25,
  speedX: 5,
  speedY: 5,
};
var speedX = 5;
var speedY = 5;
var paddleSpeed = 12;
var s = "Welcome to Infinte Pong! Player one controlls their paddle with the a and z keys. Player two controls their paddle with the /? key and the '\" key. Press the space bar to begin";

/*function down(x){
 x = x + 5;
}*/


function setup() {
  createCanvas(800, 600);
  smooth();
  //background(0);
  //fill(255)
  //text(s, 10, 10, 70, 80);
}

function draw() {

  //if (keyPressed(32) === true) {
  //gameStart === true;
  //}

  //if (gameStart === true) {
    background(64, 161, 76);
    noStroke();

    //Create the left paddle
    fill(0, 50, 50);
    rect(paddleL.x, paddleL.y, paddleL.w, paddleL.h);
    //Control the left paddle
    if (keyIsDown(90) === true) {
      if (paddleL.y + paddleL.h < height - 5) { paddleL.y = paddleL.y + paddleSpeed; } } if (keyIsDown(65) === true) { if (paddleL.y > 5) {
        paddleL.y = paddleL.y - paddleSpeed;
      }
    }
    //Create the right paddle
    fill(50, 50, 0);
    rect(paddleR.x, paddleR.y, paddleR.w, paddleR.h);
    //Control the right paddle
    if (keyIsDown(191) === true) { //move paddle down
      if (paddleR.y + paddleR.h < height - 5) { paddleR.y = paddleR.y + paddleSpeed; } } if (keyIsDown(222) === true) { //move paddle up if (paddleR.y > 5) {
        paddleR.y = paddleR.y - paddleSpeed;
      }
    }
    //Create ball
    fill(198, 237, 44);
    ellipse(ball.x, ball.y, ball.diam, ball.diam);

    ball.x = ball.x + speedX;
    ball.y = ball.y + speedY;
    //If if the ball hits the top or bottom of the court it bounces
    if (ball.y + 12.5 > height || ball.y < 12.5 && ball.x > 0 && ball.x < width && ball.y > 0 && ball.y < height) {
      speedY = speedY * -1; //reverse the direction of the motion
      ball.y = ball.y + speedY; //keeps things moving
      print("wham");
    }

    //if the ball hits the left wall
    /* if (ball.x < 0) {
       speedX = speedX * -1; //This reverses the direction, I think
       ball.x = ball.x + speedX; //This keeps the ball moving
       print("pow");*/

    //if the ball hits the front of the left paddle
    if (ball.x - 12.5 < paddleL.x + paddleL.w && ball.y + 12.5 > paddleL.y && ball.y + 12.5 < paddleL.y + paddleL.h && ball.x > 0 && ball.x < width && ball.y > 0 && ball.y < height) { speedX = speedX * -1; //This reverses the direction, I think ball.x = ball.x + speedX; //This keeps the ball moving print("pow"); } //if the x of the edge ball is more than the x of the right paddle and //the y of the ball is greater than the y of the rectangle and //less than the y of the rectangle plus the height if (ball.x + 12.5 > paddleR.x && ball.y + 12.5 > paddleR.y && ball.y + 12.5 < paddleR.y + paddleR.h&& ball.x > 0 && ball.x < width && ball.y > 0 && ball.y < height) { speedX = speedX * -1; //This reverses the direction, I think ball.x = ball.x + speedX; //This keeps the ball moving print("bam"); } //if the edge of the ball is lower than rect y and //the x of the ball is greater than the x of the rect and less than the width else if (ball.y + 12.5 > paddleR.y && ball.y < paddleR.y + paddleR.y + paddleR.h && ball.x + 12.5 > paddleR.x && ball.x < paddleR.x + paddleR.x&& ball.x > 0 && ball.x < width && ball.y > 0 && ball.y < height) {
      speedY = speedY * -1; //reverse the direction of the motion
      ball.y = ball.y + speedY; //keeps things moving
      print("bam top");
    }

    //if the edge of the ball is higher than rect y plus height and 
    //the x of the ball is greater than the x of the rect and less than the width
    else if (ball.y + 12.5 < paddleR.y + paddleR.h && ball.y > paddleR.y && ball.x > paddleR.x && ball.x < paddleR.x + paddleR.h && ball.x > 0 && ball.x < width && ball.y > 0 && ball.y < height) {
      speedY = speedY * -1; //reverse the direction of the motion
      ball.y = ball.y + speedY; //keeps things moving
      print("bam bottom");
    }
  //}
}

Takeaways of the Week – Shoot for MVP

Use less time on grunt work. Don’t make parts you don’t have to, it’s ok to buy them. Spend some money, save some time.

Sometimes it’s ok to go with an obvious answer or an easy project for homework. Each week is not a fully realized idea in and of itself. They are doodles and sketches. It’s more important to master new tools and skills and explore quick little ideas than to polish something. Keep moving. You can always come back to something you like.

Make more doodles. If you made something for a homework assignment that came together quickly, try making something else as well. Go in a different direction from the same starting point.

 

You made this? I made this.

I did not make this. From Nedroid.

These days it seems like it is a given that people can and should consume as much culture as possible, remixing and remaking it as they see fit. In fact, we now argue that this is what thinkers have always done. The only differences are that now not only can we do it better and faster, we can record every combination and recombination. I don’t really have any objection to this. I like the thought that ideas are free and can marry and mesh into glorious new forms. I like doing it myself; it’s a rush.

But it also unnerves me. I think that it is right for there to be some form of copyright on ideas and works of art for the life of the artist. The ideal creator would still be magnanimous with what they have created, but ultimately the control should stay with them while they are alive. This is a pretty middle of the road position, but it feels really radical in today’s world of infinite remixes, mashups, and viral videos.

Ultimately it keeps coming back to one main question:

Isn’t what I make mine?

Yes yes, everything is made of many influences, cherry picked from what came before. Maybe creators don’t even make anything, but are simply at the right crossroads of thought at the right time. It doesn’t matter. What I make is mine. Even if there are many like it, even if all I am doing is putting new words to an old melody. My works will always be tied to my own, singular experience of being alive in the world. That is part of their context and to strip them of that takes away some of their meaning.

Everything is made up of other things, other ideas. But the maker should still get some say in how the work is used, if only for a little while.