Response to Lev Manovich’s “The Language of New Media”

This was a highly information-dense reading, and so it took me a longer time than usual to finish the reading. I did enjoy reading it though — the parameters that Manovich is trying to define new media with are interesting. He makes sure to come at the definition process from many angles: first, he creates five categories to say what constitutes new media (numerical representation, modularity, automation, variability, transcoding). He then goes on to say what does not constitute new media, busting some common myths about defining new media. Finally, having established a sort of parameter for understanding what new media is, he goes on to explore how it relates with our society and culture.

Something I liked about Manovich’s analysis was the connection that he made between changing societies and the changing nature of new media. I particularly liked, like Mari, the point about trends in new media reflecting the cultural shift from a sort of mass public sphere into a more individualized, unique one.

I also liked the section on cinema. Manovich writes: “Cinema, the major cultural form of the twentieth century, has found a new life as the toolbox of a computer user. Cinematic means of perception, of connecting space and time, of representing human memory, thinking, and emotions become a way of work and a way of life for millions in the computer age. Cinema’s aesthetic strategies have become basic organizational principles of computer software. The window in a fictional world of a cinematic narrative has become a window in a datascape. In short, what was cinema has become human-computer interface.” I am currently taking a class in which we are exploring principles and strategies of film and cinema, and this connection was an interesting one.

Overall, this was an interesting read that A. taught me a lot about the general history of computers and new media and B. has gotten me to think about why these definitions might be necessary and important, and how they can affect my own projects as an IM student.

Response to “Her Code Got Humans On the Moon — And Invented Software Itself” + Casey Reas’ Talk

This was a highly inspirational read.  The funny thing is that I have never officially been taught about Margaret Hamilton. The focus is always on the astronauts themselves — this is not to say that we shouldn’t learn about them, but that we should also learn about Hamilton.

There were quite a few things about her story that struck me. The first was the realization of how much remains unchanged. Tech remains a male-dominated field, and women still have to work hard to be taken as seriously as their male counterparts. There was a story in the article in which Hamilton wanted to incorporate a safety code in case a mistake was made, but her superiors kept insisting that the astronauts would not make the mistake — and then they did. The story is just one small incident, but it encapsulates so many women’s experiences at their workplaces. Another thing that struck me was how Hamilton was asked about her daughter, and whether she didn’t feel guilty about leaving her daughter while working. What saddens me is not only that this happened, but also that it continues very much to happen today.

What’s also impressive is that she didn’t simply make breakthroughs in software engineering  — she invented it. The sheer importance of that fact blows my mind. I am thoroughly inspired by this article. Happy International Women’s Day, everyone! 🙂

Casey Reas’ talk was very interesting in that it brings some new concepts to creating art that I had personally never considered before. It was intriguing for me to consider the juxtaposition between chaos and order and use the conflicts and tensions within those two to produce art.

I also liked the section where he specifically focused on Processing, as that was relevant to what we are studying at the moment. I enjoyed looking at his art piece, and look forward to implementing his ideas in my next Processing venture.

 

Assignment 7: Self-Portrait

When drawing my self-portrait, I decided that I wanted to do something different from just a depiction of how I looked — I wanted, instead, to capture a moment in time. My family’s favorite picture of me has always the one in which I am standing up on stage after my music concert, all of 15 years old, beaming and wearing a pink sari — a traditional Indian garment. I was unable to post the picture itself, given that it exists only physically and at home in Muscat, but here is a reference picture for what a sari looks like:

When I started the self-portrait, I struggled with making some abstract shapes that I really wanted to incorporate. I came across the bezierVertex function on the Processing website, and used it with the hair and the flying pallu (which is the drape over the shoulder). I also incorporated an actual image into my sari because I wanted to somewhat replicate the sari I had been wearing in the picture.

Initially, I had just wanted a portrait of myself smiling. However, due to a mistake I made while experimenting with the bezierVertex function, I ended up drawing a frown. I liked it, and decided to keep it. I ended up making two versions of the same portrait — grumpy and happy. The happy version spring up every time the mouse is pressed down.

This is what it looks like right now:

Grumpy version:

Happy version:

Here’s my code:

PImage photo;

void setup (){
 size (1000, 640);
 photo = loadImage("purple-bird-fabric-pattern-on-indian-cotton-sari-DNKTTM.jpg");
 background (0,0,139);
 //background (173,216,230);
}

void draw() {
 
 if(mousePressed == false) {
 
 background(0, 0, 139);
 stroke (0);
 strokeWeight(1);
 fill(100,67,33);
 
 ellipse (500, 110, 70, 70);
 
 fill(255, 0, 255);
 
 image(photo, 460, 150, 80, 400);
 
 strokeWeight(1);
 beginShape();
 vertex(459, 142);
 bezierVertex(80, 0, 80, 75, 30, 75);
 bezierVertex(50, 80, 60, 25, 30, 20);
 endShape(); //shawl
 
 fill(255, 0 , 255, 100);
 
 triangle(459, 142, 442, 305, 547, 299);
 
 fill(0);
 beginShape();
 vertex(501, 76);
 bezierVertex(541,74, 569, 113, 527, 143);
 bezierVertex(528, 88, 533, 126, 501, 83);
 endShape(); //hair
 
 beginShape();
 vertex(501, 76);
 bezierVertex(486,74, 470, 87, 460, 114);
 bezierVertex(471, 132, 463, 110, 501, 83);
 endShape(); //hair
 
 stroke(100, 67, 33);
 strokeWeight(10);
 line (460, 150, 433, 243);
 line(433, 243, 537, 176);
 line(540, 150, 566,243);
 line(566, 243, 456, 172);//grumpy hands
 
 //line (460, 150, 433, 243);
 //line(433, 243, 372, 163);
 //line(540, 150, 566,243);
 //line(566, 243, 633, 173); //happy hands
 
 
 stroke(0);
 strokeWeight(2);
 noFill();
 beginShape();
 vertex(488, 130);
 bezierVertex( 496, 138, 498, 122, 507, 128); //grumpy
 //bezierVertex(496, 138, 498, 138, 506, 130);// happy
 endShape();
 println(mouseX, " ", mouseY);
 }
 
 //CHANGE CODE
 else if(mousePressed == true) {
 
 background (173,216,230);
 stroke (0);
 strokeWeight(1);
 fill(100,67,33);
 
 ellipse (500, 110, 70, 70);
 
 fill(255, 0, 255);
 
 image(photo, 460, 150, 80, 400);
 
 noStroke();
 triangle(459, 150, 319, 345, 422, 381);
 
 
 
 fill(255, 0 , 255, 100);
 
 triangle(459, 142, 442, 305, 547, 299);
 
 fill(0);
 beginShape();
 vertex(501, 76);
 bezierVertex(541,74, 569, 113, 527, 143);
 bezierVertex(528, 88, 533, 126, 501, 83);
 endShape();
 
 beginShape();
 vertex(501, 76);
 bezierVertex(486,74, 470, 87, 460, 114);
 bezierVertex(471, 132, 463, 110, 501, 83);
 endShape();
 
 stroke(100, 67, 33);
 strokeWeight(10);
 
 line (460, 150, 433, 243);
 line(433, 243, 372, 163);
 line(540, 150, 566,243);
 line(566, 243, 633, 173); //happy lines
 
 
 stroke(0);
 strokeWeight(2);
 noFill();
 beginShape();
 vertex(488, 130);
 bezierVertex(496, 138, 498, 138, 506, 130);// happy
 endShape();
 println(mouseX, " ", mouseY);
 
 }

}

Assignment 6 — Rotating Zombie Head

This assignment was a quite a challenge for me, as I generally try to keep my hardware work simple and focus more on challenging myself through the code or creativity. However, with this one, hardware was the main focus because the code was extremely straightforward (almost the same as what we did in class), so the challenge lay in trying to get the motor to do the exact movement I was visualizing.

I hopped around a few ideas a bit before I arrived at rotating zombie head. My initial thought was to have a boy zombie head that would rotate faster and faster as a girl zombie head got closer to it. However, I couldn’t get around the design difficulties of restricting the girl zombie head to stay in the range of a particular sensor without repurposing the tray from my midterm project, so I scrapped the girl and simply made a googly-eyed photocell that would control the speed at which the zombie head moved. [I had also briefly flirted with the idea of making a wheel of fortune sort of mechanism, before I realised it had to be at least vaguely a human movement, so I decided to stick with the rotating head.]

The challenge of constructing the project head was twofold: 1) tennis balls were proving to be extremely difficult to use as a head, as they wouldn’t stay on the gear and were hard to decorate and 2) the gear itself has an opening that was too big for my motor, so I had to pry open the edges of the gear box so that my motor would fit in. As for the head, I simply stuck a piece of paper onto the gear wheel and covered the backside with some hair strands.

Here is the inside of the box:

Here is how it worked:

 

For the future:

  1. I would try to create an actually round head so that the movement seemed more natural (or as natural as a zombie can be).
  2. As Nahil suggested, I would reverse the code so that more darkness = faster spinning, and not the other way around.
  3. Try and add the girl zombie, and see if I can come up with some mechanism that’s not a tray or a lane but will still put the girl zombie in the range of the sensor.

Defensive Pot Plant: Stupid Pet Trick

After jumping around from one idea to another for quite a bit of time, I finally decided on an idea – I was going to make a creature that would react in a progressively panicked way as something got closer to it. As I coded the project and went through materials to decide what I was going to make, the vague idea of two creatures evolved into that of a pot plant and a seal. As the seal got closer to the plant, the plant would do three things: 1) make more panicked music 2) flash progressively more red lights and 3) get its fists out, ready to fight the seal.

The code for the project was relatively straightforward. I struggled a bit with the tone command — no matter how I wrote the command, the music wouldn’t play — I had tried everything and was about to give up when I realized that the code wasn’t working because I’d put in “>” instead of “<”. The struggle is real!

Here’s the code:

#include <Servo.h>


#include "pitches.h"



const int ledred1 = 3;
const int ledred2 = 6;
const int ledblue1 = 5;
const int ledblue2 = 9;
const int ledred3 = 10;


int sensor = A0;

int ledState3 = LOW;
int ledState4 = LOW;
int ledState5 = LOW;
int ledState6 = LOW;


int melody1[] = {
 NOTE_C5, NOTE_G4, NOTE_G4, NOTE_A4, NOTE_G4, 0, NOTE_B4, NOTE_C5
};

int melody2[] = {
 NOTE_C3, NOTE_G3, NOTE_G4, NOTE_A4, NOTE_GS4, 0, NOTE_A4, NOTE_C5
};

int melody3[] = {
 NOTE_C5, NOTE_G4
};

int noteDurations[] = {
 4, 8, 8, 4, 4, 4, 4, 4
};

Servo myservo1;
Servo myservo2;

int beat_counter = 0;
void setup() {

 pinMode(ledred1, OUTPUT);
 pinMode(ledred2, OUTPUT);
 pinMode(ledblue1, OUTPUT);
 pinMode(ledblue2, OUTPUT);
 pinMode(ledred3, OUTPUT);
 Serial.begin(9600);

 myservo1.attach(12);
 myservo2.attach(11);

 // put your setup code here, to run once:




}

void loop() {


 // put your main code here, to run repeatedly:
 Serial.println(analogRead(sensor));

 if (analogRead(sensor) < 200) {
 digitalWrite(ledblue1, LOW);
 digitalWrite(ledblue2, LOW);
 digitalWrite(ledred1, LOW);
 digitalWrite(ledred2, LOW);
 digitalWrite(ledred3, LOW);

 
 //tone(2, melody1[1], noteDurations[1] * 100);
 for (int counter = 0; counter < 8; counter++) {
 tone(2, melody1[counter], noteDurations[counter] * 150);
 delay(150);
 noTone(2);

 myservo1.write(0);
 delay(10);
 myservo2.write(0);
 }
 }


 else if (analogRead(sensor) < 370) {
 analogWrite(ledblue1, 20);
 analogWrite(ledblue2, 20);
 analogWrite(ledred1, 20);
 analogWrite(ledred2, 20);
 analogWrite(ledred3, 20);


 for (int counter = 0; counter < 8; counter++) {
 tone(2, melody2[counter], noteDurations[counter] * 150);
 
 delay(150);
 noTone(2);

 myservo1.write(90);
 delay(10);
 myservo2.write(90);
 }

 }


 else if (analogRead(sensor) < 500) {
 digitalWrite(ledblue1, HIGH);
 digitalWrite(ledblue2, HIGH);
 digitalWrite(ledred1, HIGH);
 digitalWrite(ledred2, HIGH);
 digitalWrite(ledred3, HIGH);


 for (int counter = 0; counter < 2; counter++) {
 tone(2, melody2[counter], noteDurations[counter] * 150);
 delay(150);
 noTone(2);

 myservo1.write(180);
 delay(10);
 myservo2.write(180);
 }


 }


}

Most of the challenges of this project were hardware-based. Luckily, I found a box with a low-rise and sturdy ceiling, so it could do both the things I wanted it to — support the pot plant on top while still making it easy for the breadboard to lie in there undisturbed.

I soldered the LEDs, the distance sensor, the two Servos and carved out a hole in the middle of the box and came out through the hole in the middle of the pot. It looked like this:

By now, I had realized that the sensor had a very specific range that I wasn’t always able to get the seal within. A solution to this was to use a tube sort of structure which would put the seal directly in the range of the sensor. Another advantage of this structure was that it would make the project a little more intuitive for someone approaching it for the first time.

Annnd this is how the final version looks!

For the future, these are the things I would do better with this project:

  • The music: I would ramp it up to be more distinctive in terms of “happy” and “panicked”. I would also try to get the buzzer outside of the box so that the music is louder.
  • Add more LEDs to make the visual imagery more striking.
  • Make the transition between various stages smoother so that it feels like a smooth transition instead of three clear distinctions between the various stages of panic.

 

Response to Robert Casati’s talk

Robert Casati’s presentation on design was unusual and thought-provoking. Encouraging us to move away from defining design, he proposed that we to consider practical implications and human understanding as more important in categorizing things as design or not. He also provided various thought-provoking examples that led to a series of questions that really made think about how I think of the word design.

However, I do think that there is definitely a drawback to completely shirking the idea of definition — something that I think we saw in the talk itself. A lot of the students had specific questions relating to some aspects of this design/definition, but these questions were either left unanswered or dismissed, in a certain way, because at times I felt as though Casati simply didn’t want to talk about definition. While he may have been trying to reinforce his idea, I felt that it came off more as declining conversation on the topic, instead of actively engaging and disproving disagreements that anyone else would have had.

Assignment 4: DJ Mini

For this assignment, we had to create a musical instrument. I was very much still in the zone that I explored last week with my light-patterns project, and so I decided to go with something similar this week. I really liked the idea of a DJ setup so I decided to go with two knobs that could control frequency and duration each, and have LEDs light up according to what note is being played.

The code was pretty straightforward — however, I had to go back to the coding we did in class on Wednesday to fully understand how to use the tone function and how to manipulate duration and frequency without a for loop. Once I felt like I had a decent grasp over how to do that, the code wasn’t too difficult. Here’s the code:

#include "pitches.h"

int melody [] = {
 NOTE_C4, NOTE_D4, NOTE_E4, NOTE_F4, NOTE_G4, NOTE_A4, NOTE_B4
};

int melody2;

int duration;
int melodynote;
int knob = A0;
int knob2 = A1;

const int ledpinred1 = 6;
const int ledpinred2 = 7;
const int ledpingreen1 = 8;
const int ledpingreen2 = 9;
const int ledpinblue1 = 10;
const int ledpinblue2 = 11;

int ledState6 = LOW;
int ledState7 = LOW;
int ledState8 = LOW;
int ledState9 = LOW;
int ledState10 = LOW;
int ledState11 = LOW;
int ledState12 = LOW;
int ledState13 = LOW;


void setup() {
 // put your setup code here, to run once:
pinMode(ledpinred1, OUTPUT);
 pinMode(ledpinred2, OUTPUT);
 pinMode(ledpingreen1, OUTPUT);
 pinMode(ledpingreen2, OUTPUT);
 pinMode(ledpinblue1, OUTPUT);
 pinMode(ledpinblue2, OUTPUT);

 }

void loop() {
 // put your main code here, to run repeatedly:

ledState6 = LOW;
ledState7 = LOW;
ledState8 = LOW;
ledState9 = LOW;
ledState10 = LOW;
ledState11 = LOW;
ledState12 = LOW;
ledState13 = LOW;
 
if (analogRead(knob)<140){
 melodynote = 0;
 ledState6 = HIGH;
 
}


else if (analogRead(knob)<280){
melodynote = 1;
ledState7 = HIGH;

}

else if (analogRead(knob)<430){
melodynote = 2;
ledState8 = HIGH;

}

else if (analogRead(knob)<570){
melodynote = 3;
ledState9 = HIGH;

}

else if (analogRead(knob)<710){
melodynote = 4;
ledState10 = HIGH;

}

else if (analogRead(knob)<860){
melodynote = 5;
ledState11 = HIGH;

}

else if (analogRead(knob)<1023){
melodynote = 6;
ledState12 = HIGH;

}



int duration = (analogRead(knob2)/4);



digitalWrite(ledpinred1, ledState6);
 digitalWrite(ledpinred2, ledState7);
 digitalWrite(ledpingreen1, ledState8);
 digitalWrite(ledpingreen2, ledState9);
 digitalWrite(ledpinblue1, ledState10);
 digitalWrite(ledpinblue2, ledState11);
 
 tone(3, melody[melodynote], duration);
delay(duration*2);
}

As for the project, I started with wiring the buzzer and two knobs into the breadboard. The knobs were quite small, but I was keen on using them because I loved the feel of twisting and turning knobs to create music, in some imitation of a DJ. After I added the lights, this is what it looked like:

After this, the project was essentially done. I wanted to present it in a way that wasn’t just wires and a breadboard. So I decided to use a piece of styrofoam I found and added a couple of quirky elements to it. As it stands, the audience (or people sitting in front of the person using the project) should only be able to see the light art piece flashing through the translucent paper (and hear the music, of course!)

Here’s what it looks like:

For the future of this project, I would very much like to stabilise the physical structure. If there’s a way in which the knobs are more easily operable and the whole structure can stand by itself, then that’s how I would hope to do with this project in the future.

 

Response to “Design Meets Disability”

To be quite honest, I hadn’t even thought about disability in terms of design until I read this article. So it was a thought-provoking article in that it not only opened up a whole new perspective on design but also provided great insights on that perspective.

I enjoyed the format of the piece — it was divided into digestible little sections, each offering a point of view on the topic at hand. I loved the contrast that the author made between eyewear and hearing aids. It was poignant, and yet a very practical point. I agree with the author that design for disability needs to make itself visible instead of continuing to focus on discretion.

In terms of my own IM projects, I think that this readings has made me expand my understanding of practicality and usability — both aspects that I have been thinking about while making my projects. It encourages me to be more inclusive in how I perceive my audience, which is good not just for the practical purposes of my projects but also the creative thought that I put into them.

Assignment 3: Making the lights dance

For our third assignment, we had to use an analog sensor to control LED lights in an unexpected way. Inspired by some of the projects that were showcased last week, I decided to have two analog sensors control a combination of LED lights. The idea was just to create something that people could have fun with. I plan to accompany the project with a song that varies in tempo and melody, and people can play with the lights according to the music if they so wish.

The first step was to code different patterns into the LED lights that could then be controlled by an analog sensor. This is what it looked like:

After this, I had to add another sensor that would then control theme intervals between blinks as the LEDs played out the various patterns. So I now had both a speed and a pattern controller. This is what it looked like:

Since I had some time left over, I decided I wanted to transfer the project into a cardboard box and improve its usability. It was hard to get hold of both sensors at once when they were simply hanging off the breadboard, which made it hard to simply toggle them and have fun with the lights, which is why I thought setting it up in a box would make it easier to use.

This process, however, was harder than I expected. First, I had to solder wires tot he ends of all my LEDs, and then I had to figure out a way to arrange the breadboard and redbird within the box so as to not disturb any of the wiring arrangements. LED ends would touch each other or wires would disconnect from the breadboard and be completely invisible, and only after I had taken the whole thing apart could I identify what had gone wrong.

The challenges with this project were definitely more hardware-based than anything else, but I am glad I finally got it to work because it looks much better now and is easier to use.

This is what it currently looks like:

In the future, I hope to incorporate music into the project instead of playing songs from outside it. It would be super cool to have each LED light play a different note that people could then use to create their own songs.

I’ve also included the code here below: (many thanks to James and Nahil for helping me out with the code!)

const int ledPinblue = 6;
const int ledPinblue2 = 7;
const int ledPinyellow = 8;
const int ledPinyellow2 = 9;
const int ledPinred = 10;
const int ledPinred2 = 11;
const int ledPingreen = 12;
const int ledPingreen2 = 13;

int ledState6 = LOW;
int ledState7 = LOW;
int ledState8 = LOW;
int ledState9 = LOW;
int ledState10 = LOW;
int ledState11 = LOW;
int ledState12 = LOW;
int ledState13 = LOW;



const int knob = A0;
const int knob2 = A1;

long previousMillis = 0;

bool State1 = true;

void setup() {
 // put your setup code here, to run once:
 
 pinMode(ledPinyellow, OUTPUT);
 pinMode(ledPinyellow2, OUTPUT);
 pinMode(ledPinred, OUTPUT);
 pinMode(ledPinred2, OUTPUT);
 pinMode(ledPinblue, OUTPUT);
 pinMode(ledPinblue2, OUTPUT);
 pinMode(ledPingreen, OUTPUT);
 pinMode(ledPingreen2, OUTPUT);

Serial.begin(9600);

}

void loop() {
 // put your main code here, to run repeatedly:
 unsigned long currentMillis = millis();
 // int knobvalue = analogRead(knob);
 int knobvalue = 500;
 int knob2value = analogRead(knob2);

 if (currentMillis - previousMillis > knob2value && State1 == false) {
 State1 = true;
 if(analogRead(A0) < 6) {
 ledState6 = LOW;
 ledState7 = HIGH;
 ledState8 = LOW;
 ledState9 = LOW;
 ledState10 = LOW;
 ledState11 = LOW;
 ledState12 = LOW;
 ledState13 = HIGH;
 }
 else if (analogRead(A0) < 11){
 
 ledState6 = LOW;
 ledState7 = LOW;
 ledState8 = HIGH;
 ledState9 = HIGH;
 ledState10 = LOW;
 ledState11 = LOW;
 ledState12 = HIGH;
 ledState13 = HIGH;
 }
 else if(analogRead(A0)<32){
 ledState6 = LOW;
 ledState7 = HIGH;
 ledState8 = HIGH;
 ledState9 = LOW;
 ledState10 = LOW;
 ledState11 = HIGH;
 ledState12 = HIGH;
 ledState13 = LOW;
 }
 else if(analogRead(A0) <=1023) {
 ledState6 = HIGH;
 ledState7 = LOW;
 ledState8 = LOW;
 ledState9 = LOW;
 ledState10 = HIGH;
 ledState11 = HIGH;
 ledState12 = HIGH;
 ledState13 = LOW;
 }

 previousMillis = currentMillis;
 } else if (currentMillis - previousMillis > knob2value && State1 == true) {
 State1 = false;
 if(analogRead(A0) < 6){
 ledState6 = HIGH;
 ledState7 = LOW;
 ledState8 = LOW;
 ledState9 = LOW;
 ledState10 = LOW;
 ledState11 = LOW;
 ledState12 = HIGH;
 ledState13 = LOW;
 }
 else if (analogRead(A0) <11){
 ledState6 = HIGH;
 ledState7 = HIGH;
 ledState8 = LOW;
 ledState9 = LOW;
 ledState10 = HIGH;
 ledState11 = HIGH;
 ledState12 = LOW;
 ledState13 = LOW;

 
 }
 else if(analogRead(A0)<32){
 ledState6 = HIGH;
 ledState7 = LOW;
 ledState8 = LOW;
 ledState9 = HIGH;
 ledState10 = HIGH;
 ledState11 = LOW;
 ledState12 = LOW;
 ledState13 = HIGH;
 }
 else if(analogRead(A0) <=1023) {
 ledState6 = LOW;
 ledState7 = HIGH;
 ledState8 = HIGH;
 ledState9 = HIGH;
 ledState10 = LOW;
 ledState11 = LOW;
 ledState12 = LOW;
 ledState13 = HIGH;
 }
 previousMillis = currentMillis;
 }


 
 digitalWrite(ledPinblue, ledState6);
 digitalWrite(ledPinblue2, ledState7);
 digitalWrite(ledPinyellow, ledState8);
 digitalWrite(ledPinyellow2, ledState9);
 digitalWrite(ledPinred, ledState10);
 digitalWrite(ledPinred2, ledState11);
 digitalWrite(ledPingreen, ledState12);
 digitalWrite(ledPingreen2, ledState13);

}

 

 

 

Response to “Making Art Interactive” and “Physical Computing’s Greatest Hits and Misses”

In “Making Art Interactive”, the author urges interactive artists to let the public do the work. In a sense, this post was an attempt to define interactivity in a practical manner, as opposed to an abstract, theoretical one. The author believes that an interactive art piece should be left to the interpretation of the person interacting with it. I particularly liked his example of a good director and how good directing can produce a collaborative, interactive performance on stage — having dabbled in theatre/drama, I fully agree with and understand the analogy.

The second reading — “Physical Computing’s Greatest Hits and Misses”— was a look into the various patterns that have developed in physical computing. Apart from being a great source for ideas, the post also encouraged readers not to give up on ideas even if they had been done before, because everyone always has their own original perspective to add to a pattern. Personally, I often get discouraged because I feel as though nothing I do is truly original, but this post made me feel more optimistic about my ideas and encouraged me to explore what original interpretation I could bring to them.