Brendon Walter PC

From BenningtonWiki
Jump to: navigation, search

Wiki home

Reading

The Art of Interactive Design

I found that Chris Crawford's writing, The Art of Interactive Design was highly opinionated, yet in a fun, engaging way. Despite his claims that one cannot interact with a book, I had a bit of an interaction with it ('low end' interaction, as he may put it) by writing notes in the margins countering his claims and often times, I would find a paragraph or two later the answer (or at least a partial) answer to the questions I asked in the margin.

His idea of 'interaction' is that one person provides an input, such as a thought (in this case, the book gave an idea). The other person listens to and thinks about the thought (I read the idea and thought about it) and then gives an output in the form of a reaction to the thought (me writing in the margins). The process then repeats, with the roles switched (this is that part where the writing and I were unable to hold a proper 'interaction,' though finding my thoughts later answered almost gave the illusion that I was interacting with the book.)

Though I found the first chapter interesting and I found myself agreeing with most of what he was saying (arguing in the margins for the sake of argument), the next chapter seemed rather outdated and I did not agree with what he said nearly as much. In parts, he seemed to miss the point of using a computer to do certain activities. Whether this is because computers were not advanced enough when he wrote this or because he did not understand the uses of it, I don't know. One example is when he writes: "Sure, the computer can offer beautiful graphics, but any kid with a few bucks can pick up a calendar with much better graphics." (25)

To which I responded in the margins: “I don't get his point...” While a calendar tends to have twelve pictures in it, a computer can hold many more. Not only that, but the pictures on the computer can be any size, too small to use, or so large that anything can be done with it. If the kid decided to print out the picture, he could have either a small picture or even the size of a poster. While with the calendar, he is stuck with one size, unless he wanted to crop it down. Which he could do on the computer, anyways.

Perhaps Crawford's point about this was that once the kid is able to resize, crop, and otherwise manipulate the image, it becomes interactive. If it were non-interactive, it would be nothing more than pixels on a screen, and a print out calendar is more useful at that point.

The Bandwidth of Conciousness

Reading this made me think about the conversations we had in my other class, Make Me Dangerous, a few weeks ago about artificial intelligence. One of the 'smart' computers we talked about was given a list of what humans consider to be 'common knowledge,' such as water is wet and rain is water, thus rain is wet. In one part of the reading, the author mentions that although we can only keep around 7 things in mind, we can memorize long strings of numbers, such as pi. It made me think of memorizing facts in school only to recite them on the test. This method may get you a good score on the test, but it is not actually learning the information as all that is done is rote memorization and no logical reasoning. As is such, someone who uses that method of learning and does not learn to reason, they may appear to be smart, though when faced with a task of reasoning out a problem it will become apparent that their smartness is only on a base level.

Similarly, the computer that was given a list of 'common knowledge' may appear to be smart, but it is only on a base layer. A computer that is able to think out a problem logically and can learn rather than relying on a document of given knowledge is actually intelligent.

As I read on, my mind started to wander to what a computer that mimics the human brain would be like. In brief, it would be a disaster. The computer would be unable to multi-task, would not be able to think quickly, would forget documents after saving them, change remembered documents each time it is accessed, and would move documents into the wrong folder, just as my brother and I share the same memory yet he swears it happened in Canada while I swear it happened in Cape Cod.

It makes me wonder why we are so set on making computers be as human like as possible in their intelligence. What good would a computer be if we could accomplish the same thing ourselves?

Design of Everyday Things

Reading what Donald Norman had to say about the design of everyday things reminded me of something we were told in Web As Artistic Platform that I have kept with me when designing web pages (and other things): 'if you need instructions on how to use the site, you're doing something wrong.'

As Norman points out, things have to be intuitive to use. If it takes the user a long time to learn, what is the point of having all of those extra functions? Very few people will learn how to use them as most don't want to go through the effort. One example that rang true for more was the digital watch. I have been using the same watch for the past few years, though three different iterations because I keep on losing them. Each time I go to get a new watch, I choose the exact same one I had last time, not only because its cheap, but because I finally (kind of) learned what each of the three buttons do. I don't want to take the time to get a new watch and have to learn the function of each button all over again. Mine works fine, thank you, though after several years, I'm still struggling with how to change the time and how to make it so my alarm is turned on without beeping on the hour. Each button has many different functions depending on what mode the watch is in. In the normal timekeeping mode, the top left button turns a light on so it can be read in the dark. In another mode, it resets the stop watch or something. That is the thing with these overly complex objects, I can't tell you what each button does. I have to play with it before I can get it to do what I want, even though I have owned the same style watch since the beginning of high school. Somehow, those three buttons, which should be so easy, have alluded me for the past four or five years.

Experience Design

Compared to our first reading this term, I preferred Nathan Shedroff's definition of 'interactive' - "a process of continual action and reaction between two parties (whether living or machine)." This statement, simple and concise, sums up the method input, processing, and output proposed by the first author. What I found more interesting, however, was his next sentence that read, "It is debatable whether or not a computer is capable of actually initiating action rather than merely reacting through its programming." I find this idea interesting - what makes us capable of initiating something rather than the idea that we do it because it is 'programmed' within in us make those initiations? Most would argue 'freewill.' Freewill is the idea that we are more than our surroundings and nature, that we fully choose to do what we do rather than because it is within our nature (or, it is our destiny, if you will).

The idea of whether we have free will or not is something that I have considered for around 4 years now. At first, I was horrified at the thought that we may not have any control of our actions but as I thought about the idea (in my attempts to prove that I do have free will), the idea that we don't made more and more sense, and all evidence I could find pointed to the idea that free will is an illusion. Eventually, I came to the conclusion that we do not possess free will and are the victims of genetics and nurture (though the way we react and change due to events, such as a family death or an attack of our personal being is determined by our genetics). Along with this, following logic, I came to the conclusion that everything is pre determined - not by a god or any higher being, but by simple action-reaction. We can accurately predict the movement of a body in space, why an atom in our brain? Why not the movement of every atom? To predict the movement of every atom in our brain and how each atom affects another (and what the result of that would be) would take an incredible amount of time and would be so complex that its doubtful that we will ever be able to do so. But behind each atom, behind each object, is a complex series of equations each changing surrounding equations making it so there is only a few, pre decided paths that can be taken, such as HTML code in a web page.

If our actions are predetermined, what, then, makes it so that we can initiate a task while a computer, just as preprogrammed (though perhaps more simply), can't?

Projects

From Getting Started With Arduino

Example 01: Blinking LED

This has an LED light that blinks on for one second, then off for one second. Repeat.

//project 1 : Blinking LED

const int LED = 2;          // LED connnected to digital pin 5 (D2)

void setup() {
  pinMode(LED, OUTPUT);    // Sets digital pin as the output
}

void loop (){
  digitalWrite(LED, HIGH); // Turns LED on
  delay(1000);             // waits a second
  digitalWrite(LED, LOW);  // Turns LED off
  delay(1000);             // waits a second
}


Example 02: Push Button LED

This is supposed to have a button that turns the LED on when clicked, then off when pressed again. I either did something wrong, or there is something wrong in the wiring somewhere (probably the button?) because the LED turns on when I near my hand to the button, and off again when I move it away. Sometimes the light stays on when I move my hand away, then slowly turns off on its own time.

// uses a button to turn a LED either on or off

const int buttonPin = 3;
const int LEDPin = 2;

int buttonState = 0;          //variable for reading the pushbutton status

void setup() {
  pinMode(LEDPin, OUTPUT);   // define LEDPin as OUTPUT
  pinMode(buttonPin, INPUT); // define buttonPin as INPUT
}

void loop(){
  buttonState = digitalRead(buttonPin); // read the state of the pushbutton value
  if (buttonState == HIGH) {            // if the button is pressed
    digitalWrite(LEDPin, HIGH);         // turn the LED on
  }
  else {                                // otherwise
    digitalWrite(LEDPin, LOW);          // turn LED off
  }
}


Example 04: Fade In, Fade Out

I was unable to get this to work properly. The LED turns on and off, but does not fade in and out. I assumed that something was wrong with my code and checked it over and over again against the code in the book. When I could not find an error, I copied the code from the book into the Arduino program but the results remained the same.

//This program makes the LED appear to slowly fade on and off by 
//flickering faster than the human eye can detect. 

const int LED = 2;    //LED conected to D2
int i = 0;           //Counts up and down

void setup() {
  pinMode(LED, OUTPUT); //defines LED as an output
}

void loop() {
  
  for (i = 0; i < 255; i++) {    //fades the LED in
    analogWrite(LED, i);         //set brightness
    delay(10);
  }

  for (i = 255; i > 0; i--) {      //fades the LED out
      analogWrite(LED, i);
      delay(10);
  }

} 


Example 05: Fade With Push Button

Originally, I had the same problem with this that I did with the Push Button LED. The light would turn on when my hand neared the button and off when my hand moved away. This time, however, the button would occasionally flicker rapidly. I looked at other students' pictures to see what they did, and solved the issue. The button now works fine, and the LED can now fade in.

//This turns the LED on when a button is pressed and keeps it on 
//after the button is released. Holding the button will change
//the brightness.

const int LED = 3;    //the LED is in D3
const int BUTTON = 2; //the button is in D2

int val = 0;     //stores the state of the input pin

int old_val = 0; //stores the previous value of 'val'
int state = 0;   //0 = LED off ; 1 = LED on

int brightness = 128;        //makes 'brightness' a value
unsigned long startTime = 0; //when the button started to be
                             //pressed
                             
void setup() {
  pinMode(LED, OUTPUT);
  pinMode(BUTTON, INPUT);
}

void loop() {
   val = digitalRead(BUTTON);  //read input value and store it
   
   if ((val == HIGH) && (old_val == LOW)) {
     state = 1 - state; //change the stae from off to on, v-v
    
     startTime = millis();  //millis is the Ardunio clock
    
    //this line remembers when the button was last pressed
    
     delay(10); 
   }

  if ((val == HIGH) && (old_val == HIGH)) {
    //if the button is held for more than 500ms
   if (state == 1 && (millis() - startTime) > 500)  {
     brightness++; //increase brightness
     delay(10);
     
     if (brightness > 255) {
       brightness = 0; //if the brightness is over 255, return to 0
       }
     }
   }
  
  old_val = val; //val is now old
  
  if (state == 1) {
   analogWrite(LED, brightness); //turn LED ON at the current
                                 //brightness level 
  } else {
   analogWrite(LED, 0); // turn LED OFF
  }
 }


Example 06A: Light Sensor Blinking LED

Once again, I had issues with this. I think part of the problem was that the book's instructions were poor, and were not completely accurate. For example, it says that the light sensor is always considered an input, but nothing worked until I connected the sensor to A6 rather than D3 like I originally had. This problem was solved when looking at other students' wikis and finding someone who had a similar problem.

//This makes an LED blink slowly and speed up when the light sensor 
//is blocked.

const int LED = 2; // the pin for the LED
const int SENSOR = A6;

int val = 0; 

void setup() {
  pinMode(LED, OUTPUT); 
}

void loop() {
  val = analogRead(SENSOR); 
  digitalWrite(LED, HIGH); 
  delay(val);
  
  digitalWrite(LED, LOW); 
  delay(val);
}


Example 06B: Light Sensor LED

This one worked without problem.

The set up of the Arduino and breadboard is exactly the same as 06A above.

//This makes the LED turn on when the sensor is exposed to light, and
//off when the light is blocked.

const int LED = 2;
const int SENSOR = A6;

int val = 0;

void setup() {
 pinMode(LED, OUTPUT); 
}

void loop() {
 val = analogRead(SENSOR); //read value from sensor 
 analogWrite(LED, val/4); //turn the LED on at the brightness set
                          //by the sensor
 delay(10);
}


Example 07: Serial Communication

Arduino and breadboard setup remain the same as in 06A.

const int SENSOR = A6;

int val = 0;

void setup() {
 Serial.begin(9600); //open a serial port to send data back to
                    //the computer at 9600 bits per second 
}

void loop() {
  val = analogRead(SENSOR);
  Serial.println(val); //print the value to the serial port
  delay(100);
}

Other

Servo Motor

//powers a servo motor that is turned by a light sensor.

#include <Servo.h>

Servo servoMotor;
int servoPin = 3;

void setup() {
 Serial.begin(9600);
 servoMotor.attach(servoPin);
}

void loop() {
 int analogValue = analogRead(A4);
 Serial.println(analogValue);
 int servoAngle = map(analogValue, 0, 1023, 0, 179);
 servoMotor.write(servoAngle);
}

Sweep

//makes a servo motor turn 180 degrees one way, then turn back

#include <Servo.h>

Servo myServo;

int pos = 0;

void setup() {
 myServo.attach(3); 
}

void loop() {
 for(pos = 0; pos < 180; pos +=1) { // goes from 0 to 180 degrees
   myServo.write(pos);
   delay(15); 
 }
 for(pos = 180; pos >= 1; pos-=1) { //goes from 180 to 0 degrees
   myServo.write(pos);
   delay(15);
 }
   
}

Serial Out

When I got to the step in the guide on importing the serial library, I ran into an error saying:

sketch_apr09a.cpp:4:1: error: ‘import’ does not name a type
sketch_apr09a.cpp:5:1: error: ‘Serial’ does not name a type

I went to the instructions given on how to fix the guide, but ran into problems there, maybe because I'm using linux and the guide is written for macs (I think). This is what happened:

 ~ $ sudo mkdir -p /var/lock
[sudo] password for brendon: 
 ~ $ sudo chmod 777/var/lock
chmod: missing operand after `777/var/lock'
Try `chmod --help' for more information.

chmod --help is no help at all.


When going over the homework in class, I got it working somewhat, but it still is not working fully. We thought that there might have been a problem with the computer I was using in class, but I have the same results on my own computer (and other computers) as I did there. Here's the information:

Code I was using:


import processing.serial.*;

Serial myPort;        // The serial port
float xPos=0;         //horizontal postion of the graph


void setup () {
  size(800, 600);        // window size
  println(Serial.list()); // List all the available serial ports
  String portName = Serial.list()[4];
  myPort = new Serial(this, portName, 9600);
  background(#4D5558); //Background color
}


void draw () {
  // nothing happens in draw.  It all happens in SerialEvent()
}

void serialEvent(Serial myPort){
  int inByte = myPort.read(); //read the byte from the serial port
                              //named myPort
  println(inByte); //prints it
  float yPos = height - inByte; //line goes to height minus byte's value
  stroke(#D95252);  // line color
  line(xPos, height, xPos, height - inByte);
  if (xPos >= width) {
    xPos = 0;   // at the edge of the screen, 
                //go back to the beginning
    background(#4D5558);  // clear the screen by 
                          //resetting the background
  }
  else {
    xPos++;   // horizontal position increases by one 
              //for next reading:
  }
}

Pictures:

This is the set up of the arduino and breadboard.

No matter how much or which way I turn the pin, it seems to average out around 32-34, as can be seen here.

The graph appears flat, with only slight variations. When the graph is first being generated, it starts off at a higher point then quickly decreases to its flattened state. I'm at a lost as to what's wrong with it.

I tried other peoples' coding, looked at other peoples' pictures to make sure I had it wired correctly, but nothing seems to work.

High Current Loads

const int transistorPin = 2;

void setup() {
 pinMode(transistorPin, OUTPUT);
}

void loop () {
 digitalWrite(transistorPin, HIGH);
 delay(1000);
 digitalWrite(transistorPin, LOW);
 delay(1000); 
}

and

const int transistorPin = 2;

 void setup() {
   pinMode(transistorPin, OUTPUT);
 }

 void loop() {
   int sensorValue = analogRead(A0);
   int outputValue = map(sensorValue, 0, 1023, 0, 255);
   analogWrite(transistorPin, outputValue);
 }

Mid Term Project

Mid Term Page

Final Project

Brendon Walter Final Project

Artists

Still Moving by Maurice Benayoun (2008)

In his project, Still MovingMaurice Benayoun searched Google News for the terms "excited," "anxious," and "nervous" from 3,200 cities around the world. He took the data he collected and put it onto a map of the world that shows 'what the world is feeling.' The 'map' is a large, somewhat round sculpture that has each of the 3,200 cities on it. The cities are colored as to show what of the three terms showed up the most in the news (red for excited, black for anxious, and yellow for nervous).

When the sculpture is touched, the name of the city and the emotion is projected onto the surface of the sculpture and a sound system hidden underneath plays at a frequency that can only be felt. As a result, audience members not only see the emotions of the world, but also feel it. Video

Sol Lewitt

I first saw Sol Lewitt's pieces during a class field trip to Dia Beacon and was enthralled by the detail of his work. He is not an interactive artist, but I still find his work interesting and influential. He tends to write out descriptions for how to make a Sol Lewitt piece so that anyone can copy it and make their own installation. He would write out a certificate of authentication for some of these installations making them official rather than just a copy.

I find his work so interesting because his is more the idea rather than the installation. Anyone can make a Sol Lewitt piece, but he was the one to come up with the idea. When walking around Dia Beacon, I was blown away by the amount of detail in each piece. They seemed maddening to do - there was one piece that was just free handed straight lines going halfway up the wall, none of the lines intersecting or touching at any point.