Author: Amy Chen

Some interesting points Victor made about others’ responses are:

iPad is good: After his first blog post, I did not expect him to say that iPads/iPhones are good for now. It seemed that he was against the whole idea of a screen, but regardless, it makes me question what the timeline is for when a certain technology is no longer innovative. At what point do we say a screen is not enough?

What about voice: I’m not sure when this post was made, but I wonder what Victor’s opinions on recent technologies like Alexa are because the technology definitely fit his idea of interested using “tools for creating and understanding.”

What about brain interfaces: I agree with Victor about how computers are pretty much controlling our body and how our daily activities will soon be dominated by computer controlled in some way or another. It’s what many people are worried about, but how does Victor want to address this? What future interaction design can be made in the future that would stop this from happening?

My child can’t tie his shoelaces, but can use the iPad: I felt the point he made here was a harsh. He says that using screen technology is similar to restricting literature to Dr. Seuss’s vocabulary as if that was bad. He says that a “fully-functioning adult human being deserves so much more.” However, isn’t the whole point of interactive designs to be simple and not overdone? Humans are looking to make their life simpler; a lot of people would rather read Dr. Seuss’s book than to have to read Shakespeare.

Bret Victor’s post about the future of interaction design was very compelling to me because it made me question what the future looks like. I’ve always thought “What else can we make when everything’s already been invented?” I think the reason why developers are creating more and more apps through a screen is because there’s so much more you can create on phones, tablets, etc. Even within his own post, Victor does not mention any technology that’s not Pictures Under Glass, but I acknowledge the fact that he is writing this post to inspire younger generations to think of something more revolutionary than what is currently thought of as the future of interaction design. 

I believe the future is the screen because outside of that, what can you really create? I agree with Victor’s point about how these screen technologies leads us to lose connection with the task that we are performing. Isn’t that somewhat the purpose of technology though? It’s suppose to make your life easier; what if you’re too lazy to use your hands? Some people want things done with a swipe of the finger.

I respect what Victor has to say about the future of interaction design, but I really don’t know what else to expect than a screen that can do so much more than what we humans are capable of.

Before reading this chapter, I had no idea that my inability to open certain doors would be addressed as a bad design concept. I’ve noticed that I’ve walked into numerous doors only to take a step back to understand how exactly to open it. Once I genuinely thought I was locked inside the NYU Shanghai staircase because the door handle was locked when I tried to twist and pull. I had to text my friend to get me out of the staircase and when she came she told me to just push. Thanks for letting me know that my stupidity was because of bad designers, Norman!

I found the concept of discoverability very familiar. To me, it sounded like what we read about interaction. How is the agent interacting with the object. What is the relationship between these two items? The only difference to me seemed to be the fact that affordance needs to be useful. These affordances will determine what actions are possible. Norman then goes and talks about how signifiers are used to communicate where action should take place and that we need both affordance and signifiers. However, he also talks about how adding external signifiers that need to be added indicate bad design. I totally agree on the last point, but I wonder what the line is between when there is too much signifiers and when signifiers aren’t needed at all. I would think that it is very similar to when feedbacks are considered to be too much to point where it starts to annoy people.

Another point Norman made was about how engineers are bad designers because they think too logically, and not everyone can follow and interact with the product the way engineers want them to. I think this is where designers come in, but there is still a problem between what the designer want users to do vs what the user actually ends up doing with the product. There is still the burden of communication and I’m not sure where Norman would suggest to fix this problem. User testing? After all of Norman’s examples, it still amazes me how designers/companies still roll out with products like digital watches with buttons that aren’t labeled.

For this week’s project, I used an Ultrasonic distance sensor as my analog input to create a box that opens its lid when you are far away from it. Once you come close enough with your hands over the box, it will shut on you. The goal of the project is to tempt the user to come close, but once you come too close, it will surprise and close on you. Ideally, the cover would be much heavier so that if it shuts, the person’s hand would be trapped there.

The Ultrasonic distance sensor is faced upwards so that it can detect whether there is a hand over it or not. Depending on its distance value, I map it to the servo, which will rotate between 50 to 180 degrees. I have attached a cardboard on the servo wing so that it is heavier and strong enough to hold up the cardboard box on top. In its neutral 50 degree, the cardboard does not push on the lid, however, once a hand gets close enough, the servo will rotate and will bring the cardboard with it to raise the lid. I have also included a Piezo buzzer that beeps more and more often once a hand gets close to it and a red LED light will also turn on.

During the project, I had problem figuring out what degrees to set the servo so that it went exactly between the 90 degrees needed to lift the lid. Additionally, the distance sensor takes a while to get the correct value, so there are times when every 10ms, it would jump between 1 and 403. To stop that from happening, I added a bit of a delay, but I’m not sure if that’s the correct way to fix it.

To improve on this project, I would probably also mount the servo in a more stable way rather than just hot gluing it to the side because it kept tilting to one side.

 

Attached is the code for the program :

#include <Servo.h>;

Servo servo;
int lightPin = 8;
int buzzerPin = 9;
int servoPin = 10;
int trigPin = 11;
int echoPin = 12;

void setup() {
  Serial.begin(9600);
  servo.attach(servoPin);
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  pinMode(buzzerPin, OUTPUT);
  pinMode(lightPin, OUTPUT);
}

void loop() {
  int distanceInches = getCurrentDistance();
  int pos = 50;
  if (distanceInches <= 30) {
    pos = map(distanceInches, 1, 30, 150, 180);
    tone(buzzerPin, 3000, map(pos, 150, 180, 30, 200));
    delay(10);
  }

  if (pos != 50) {
    analogWrite(lightPin, map(pos, 150, 180, 50, 255));
  } else {
    digitalWrite(lightPin, LOW);
  }
  
  Serial.println(distanceInches);
  servo.write(pos);
}

float getCurrentDistance() {
  float dist;
  float echoT;

  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);

  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  echoT = pulseIn(echoPin, HIGH);
  dist = echoT / 148.0; //microseconds to inches

  return dist;
}

Chris Crawford’s paper on interactivity was very enlightening. Although I came in understanding the term “interactive”, I was pleasantly surprised that he had to argue/explain to others about what it is because many people confused it with “reaction”. When he mentioned what the difference was between the two, I realized that I also did not have a firm understanding of interaction (based on his definition).

Something interesting that he brought up was about how an interactive product is a weak link in a chain if not all three conditions (listening, speaking, and thinking) are met regardless of how strong the other two links are. It led to think whether that is actually true; does there exist a project that only takes 2/3 of the conditions, but was still able to make it interactive.

Overall, I think the paper was a bit too strict on what qualifies as an interactive piece. I personally think as long as the user can play around with a work piece and get a response out of it, it is interactive. Whatever the work is, the project doesn’t need to have thinking involved (the response does not have to come from thinking).

This project is combining the first assignment with the second. The switch is activated by attaching a piece of foil on the bottom of my foot, which is attached to wire that is attached to 5V. Each of the colored foils will light up a colored LED if a foot steps on it.

The main goal of the project is to create a game where you copy exactly what the program does. There are 5 levels to this game and the game gets harder as you progress. The program will light up a random LED and when it finishes displaying the pattern and the player (you) will have to step on the correct colored tin foil in order to pass the round. The first round will start with one color pattern, then 2 colors if you pass, and so on and so forth. If you step on the incorrect color, you have failed and the game will restart.

Going into this project, I had trouble because the program would jump ahead and think that I’ve already finished the pattern when in fact, I haven’t. It was fixed by adding a delay and adding conditions to check whether the pattern has been stepped on already.

int level = 1;
int pattern[5];
int prevRead[] = {LOW, LOW, LOW};

void setup() {
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);
  pinMode(5, OUTPUT);
  pinMode(6, OUTPUT);
  Serial.begin(9600);
}

void loop() {
    for (int i = 0; i < level; i++) {
      int color = random(3, 6);
      digitalWrite(color, HIGH);
      delay(500);
      digitalWrite(color, LOW);
      delay(500);
      pattern[i] = color;
    }

  for (int i = 0; i < level; i++) {
    Serial.println(pattern[i]);
  }

  Serial.println("======");

  int i = 0;
  while (i < level) {
    bool prevAllClear = true;
    for (int pin = 0; pin < 3; pin++) {
      if (prevRead[pin] == HIGH) {
        prevAllClear = false;
      }
    }

    bool currentTouch = false;
    for (int pin = 0; pin < 3; pin++) {
      prevRead[pin] = digitalRead(pin + 3);
      if (prevRead[pin] == HIGH) 
        currentTouch = true;
    }

    if (prevAllClear && currentTouch) {
      if (digitalRead(pattern[i]) == HIGH) {
        i++;
        Serial.println("good job!");
      } else {
        level = 0;
        Serial.println("wrong!");
      }
    } 

    for (int pin = 0; pin < 3; pin++) {
      prevRead[pin] = digitalRead(pin + 3);
    }

    delay(100);
  }

  delay(500);

  digitalWrite(6, HIGH);
  delay(1000);
  digitalWrite(6, LOW);

  level++;
  
  if (level == 6) {
    while (1) {
      digitalWrite(3, HIGH);
      delay(200);
      digitalWrite(3, LOW);

      digitalWrite(4, HIGH);
      delay(200);
      digitalWrite(4, LOW);

      digitalWrite(5, HIGH);
      delay(200);
      digitalWrite(5, LOW);

      digitalWrite(6, HIGH);
      delay(200);
      digitalWrite(6, LOW);
    }
  }
}