Reading Response 9.b – Making Interactive Art: Set the Stage, Then Shut Up and Listen

This article covers topics like physical interaction and interaction design. The author argues that the artist should have a shift in perspective regarding the expression and interpretation of their own artwork. He argues that artists pre-describe and set their own interpretation, telling the participants how to think and act. 

However, the only primary task an artist has is the interactive framework. Once this is done, the artist should “shut up and listen”. The static artwork must shift into a dynamic performance, with the audience being the central character. The conversation doesn’t only rely on the artist letting the audience speak, but also in listening to the audience, their comments and analysis. 

This reading made me realise how much collaboration and listening is important in creating artworks. I realised that over-explaining artworks and projects really takes away from the whole experience of the audience. The true beauty in immersion and interaction lies in the audience being allowed to freely communicate with the artwork. This also allows both of us to interact and learn from each others’ interpretations, creating a wider space for creative freedom and expression. 



Reading Response – Physical Computing Greatest hits (and misses)

This article explores various themes in physical computing, their mechanisms and applications. Many different projects are shown here, including theremin-like instruments, gloves, video mirrors, dolls and pets and Scooby-Doo paintings. 

The ones that I found most interesting are definitely the mechanical pixels and the multi-touch interfaces. The mechanical pixels were very similar to many projects I saw in fashion, where there are moving parts in structured ball gowns; adding mechanical components to clothing was pretty interesting. These certainly aren’t very practical, but rather serve as a structured display of fashion and aesthetics. I wondered whether the same technique was being applied here. I have interacted with multi-touch interfaces before at art exhibitions and installations at Expo 2020 Dubai, where the movements of my hands would direct shooting stars and flying comets. This sort of physical computing has always fascinated me, it really feels fun and interactive. 

Overall, I found many of the projects very inspirational and interesting. Physical computing is a very new discipline for me, and these projects helped me see the trends and themes evolving within the broad field. These projects definitely serve as a foundation for many great projects, some hits and some misses.



Arduino: analog input & output

This week I used both an analog and a digital sensor to control two LEDs in different ways. I used the ultrasonic distance sensor to measure distance. For the digital sensor. My setup controls two LEDs: one blinks and the other changes brightness using PWM.

Here’s how it works:
LED1, connected to a regular digital pin, blinks faster when an object is closer and slower when it’s farther away. The delay between blinks is based on the distance in centimeters. So the closer the object, the faster the LED blinks. If the object is far, the LED blinks slowly.

LED2, connected to a PWM pin, changes brightness based on the same distance. But instead of getting dimmer when the object is far (which is more common), I made it do the opposite—it’s dim when the object is close and bright when it’s far away. I know it’s the reverse of what people usually do, but I wanted to try something different and see how it looked in action.

the code :

// Pin definitions
const int trigPin = 7;     // HC-SR04 trigger pin
const int echoPin = 6;     // HC-SR04 echo pin
const int led1Pin = 2;     // LED1 pin (digital)
const int led2Pin = 3;     // LED2 pin (PWM)

// Variables
const int maxDistance = 255;  // Maximum meaningful distance (cm)
int distance = 0;             // Measured distance in centimeters
int brightness = 0;           // Variable for brightness

void setup() {
  Serial.begin(9600);
  pinMode(led1Pin, OUTPUT);
  pinMode(led2Pin, OUTPUT);
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
}

long getUltrasonicDistance() {
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  return pulseIn(echoPin, HIGH);
}

void loop() {
  // Measure distance
  distance = 0.01723 * getUltrasonicDistance();
  
  // Cap the distance reading
  if(distance > maxDistance) distance = maxDistance;
  if(distance < 2) distance = 2;  // HC-SR04 minimum range
  
  // Serial output
  Serial.print(distance);
  Serial.println(" cm");
  
  // LED1: Blink with distance-dependent delay (capped)
  digitalWrite(led1Pin, HIGH);
  delay(distance);
  digitalWrite(led1Pin, LOW);
  delay(distance);
  
  // LED2: Brighter when closer, dimmer when farther
  //brightness = map(distance, 2, maxDistance, 255, 0); // Inverted mapping
  //brightness = constrain(brightness, 0, 255); // Ensure valid PWM
  //Serial.println(brightness);
  brightness = distance;
  analogWrite(led2Pin, brightness);

video:

https://drive.google.com/drive/u/0/folders/1Kk2lkQgoAyybXSYWVmY2Dog9uQVX_DMq

future improvement:

In the future, I’d like to add sound that reacts to distance, like pitch changes as you move closer or farther. I also want to make the project more interactive overall—maybe by adding more sensors or letting users trigger different responses through movement or touch. This would make the experience feel more playful and alive.

schematic:

Week- 9 reading

This week’s readings made me think about how important it is to be okay with things not always working out. In Physical Computing’s Greatest Hits and Misses, I liked how it showed both the successful projects and the ones that didn’t go as planned. That felt real. I often feel like everything I make has to be perfect, but this reminded me that trying new things and failing is part of the process. It also made me wonder—what really makes something a “failure”? If people still interact with it or feel something from it, maybe it still has value. I want to be more open to things going wrong, because those moments can lead to better ideas.

The second reading, Making Interactive Art: Set the Stage, Then Shut Up and Listen, really stayed with me. I’m used to explaining my work a lot or trying to get people to understand exactly what I meant. But this reading made me realize that sometimes the best thing I can do is let go and let the audience explore for themselves. I don’t fully agree with the idea that artists should just “shut up,” because I think some guidance can help people connect. Still, I like the idea of trusting people more. It made me think about how I can make work that gives people space to feel, move, and react in their own way, without me controlling every part of the experience.

Week 9 Reading

One of the most interseting concepts found in “Physical Computing’s Greatest Hits” I found was the tilty tables. While the concept of tilting and how it can alter the objects on a surface is so very intuitive to us, the tilting table adds a degree of complexity compared to something live a wave wall. The tilting allows for another, interesting way for audiences to interact with art in a non-conventional way that is still very rooted in modern day physics.

One of the most out there ideas was also the meditation helpers; devices designed to take away stimulus. This also struck me as very counter-intuitive yet fascinating. Normally, we think about taking away stimulus when it comes to being in a state to meditate, yet this machine attempts to connect the user to the compuation through the interpretation of a series of sensors in a way I think fuses technology and biopsyhcology in a fascinating way.

 

From the other article, I found the message to be very important and true. Similar to how Norman said doors that need signs are poorly designed, I think an artwork being able to stand alone with less surrounding context is in some shape or form a testament to its thoughtful design. Because the truth is, if one designs their artwork well enough, operation should be intuitive to the user.

The way the article says to indicate what the user should do with the art is so obvious, but when we ourselves are creating art, from an opposing perspective, it is definitely true that these things are just not as obvious as they would if we were not the artist.

Another important note from the article is to listen for feedback. Unlike other mediums, this one is more able to changed over time with feedback. So when for users there is a disconnect in what needs to be done and what they are trying to do, the artist should really take that into account to improve their work.

Week 9 – Production

Initial Idea

The goal of this project was to explore the interaction between analog and digital sensors and how they can be used to control outputs creatively. Specifically, the task was to use at least one analog sensor and one digital sensor to control two LEDs, one through digital means (on/off) and the other through analog means (brightness control). The initial idea was to keep the components simple but effective: a push-button as a digital switch and a potentiometer as an analog input, controlling a red and green LED, respectively.

Video demonstration

Execution

The red LED was connected in series with a 330-ohm resistor and controlled by a push-button, which toggled it on or off based on the button state. The green LED was also connected with a 330-ohm resistor and its brightness was adjusted using a 10k potentiometer wired to an analog input pin. The analog value was read from the potentiometer and mapped to a PWM value to vary the green LED’s brightness.

Here is a diagram:

 

const int potPin = A0;
const int buttonPin = 2;
const int ledDigital = 10;
const int ledAnalog = 9;

bool ledState = false;

void setup() {
  pinMode(buttonPin, INPUT_PULLUP); // button active LOW
  pinMode(ledDigital, OUTPUT);
  pinMode(ledAnalog, OUTPUT);
}

void loop() {
  // Read potentiometer value
  int potValue = analogRead(potPin); // 0 - 1023

  // Map it to PWM range
  int brightness = map(potValue, 0, 1023, 0, 255);
  analogWrite(ledAnalog, brightness);

  // Read button
  if (digitalRead(buttonPin) == LOW) {
    delay(200); // debounce
    ledState = !ledState;
    digitalWrite(ledDigital, ledState);
  }

  delay(50); // loop delay
}

 

Highlights 

  • The logic worked exactly as planned: the button cleanly toggled the red LED, and the potentiometer provided smooth brightness control for the green LED.

  • The circuit was clean, and the schematic clearly represents the wiring and design intent.

  • I’m proud of how the components were chosen and integrated in a way that’s both simple and pedagogically effective, perfect for demonstrating basic input/output handling on Arduino.

What Could Be Improved

  • Debouncing the push-button in code could be refined further to prevent unintended toggles.

  • A creative twist (e.g., combining analog and digital inputs for more complex LED behaviors or using a different type of analog sensor like an LDR) could elevate the interactivity.

  • Next time, I might also add a small OLED screen or serial output for live feedback on sensor values for better debugging and visualization.

Week 9 Reading Response

Reading Tom Igoe’s “Physical Computing’s Greatest Hits (and Misses)” honestly made me feel a lot more relaxed about project ideas. At first, it seemed like a list of all the things people have already done too many times, like gloves that make music, video mirrors, or floors that light up when you step on them. But then Igoe flips that idea. He basically says it’s okay to revisit these themes because what makes them interesting isn’t the concept itself, but how you approach it. That felt very refreshing. It reminded me that originality doesn’t mean starting from nothing every time. It can come from how you add your own twist to something familiar.

What I also appreciated was how much these themes connect to actions we already do in real life, like tapping, dancing, waving, tilting, or even yelling. It’s amazing how intuitive some of these interactions are, and how physical computing works with that. You don’t have to explain much when someone naturally knows how to interact with your piece.

In “Making Interactive Art: Set the Stage, Then Shut Up and Listen”, Igoe talks more about the role of the artist or designer in this kind of work. The main idea that stood out to me was that we shouldn’t try to control how people respond or tell them exactly what to think. Interactive work is more like setting up a space or a situation and then letting people figure it out on their own. I liked the comparison to a theater director. You can give actors tools and a setting, but the emotional part of the performance has to come from them. The same thing goes for interactive art. It only works when people bring something of themselves to it.

Both readings helped shift the way I think about making interactive projects. It’s not just about cool tech or trying to be the most unique. It’s really about creating something that invites people to participate and explore. Ideally, they leave with their own story or feeling from it, not just the one I imagined in advance.

Reading Response 5 – Design & Foresight (Week 8)

Reading 1: “Attractive Things Work Better” by Don Norman
I really liked Norman’s idea that attractive things don’t just look good—they actually change how we feel and behave. Before reading this, I used to think usability was all that mattered, but now I see how a beautiful design can make me more patient and forgiving. For example, there’s an app on my phone with a super sleek interface. Even when it glitches, I’m willing to give it another chance because it looks so appealing. On the other hand, if an app looks outdated or dull, I find myself deleting it right away. It’s fascinating how aesthetics can create a kind of emotional “cushion” that keeps us calm and curious, which then helps us solve problems more easily.

Reading 2: Margaret Hamilton and the Apollo 11 Mission
Margaret Hamilton’s story reminded me that critical work often happens behind the scenes and doesn’t always get the attention it deserves. Her software literally helped save the Apollo 11 mission by planning for things that might go wrong—something no one else seemed to think about at the time. I love how she pushed for software to be taken seriously as an engineering field. Back then, many people saw coding as less important than other parts of spaceflight, but her hard work proved otherwise. It’s really inspiring to see how her ability to anticipate mistakes changed everything for the mission. I think we can all learn from that: even if other people don’t immediately see the value in what we do, persistence and foresight can make a huge impact—sometimes, it can even save the day.

Week 8 – Unusual Switch

Concept

The idea is straightforward: use the AirPods case itself as a physical mechanism to connect or disconnect two wires.

  • When the AirPods are open: The two green wires make contact. This allows current to flow in such a way that the LED turns on.

  • When the AirPods are closed: The two green wires are pushed apart (or pulled apart), so the circuit is broken, and the LED turns off.

Of course, your exact implementation may depend on how you place the wires on the AirPods case—some people prefer taping them near the hinge or using a small piece of foam to press them apart. But the principle remains the same: open case = wires connected, closed case = wires disconnected (or vice versa).

What You’ll Need

  • Arduino Uno

  • Red wire (5V supply)

  • Black wire (GND)

  • Blue LED

  • 330 Ω resistor

  • Two green wires (these become the AirPods “switch” leads)

    Demo:

Week 8 Reading Responses

Norman, “Emotion & Design: Attractive things work better”

In this reading, Norman’s idea of “attractive things work better” really struck me because I didn’t realize how forgiving I was of things that were more aesthetically pleasing. This plays a huge role when it comes to marketing because brands that are marketed as much more luxury and aesthetic have a positive affect on people compared to cheaper, less aesthetic brands. This made me reflect on my own experiences, like how I’m more patient with my prettier jewelry pieces even if the clasp is annoying, whereas I quickly become irritated with an cheaper and less aesthetic jewelry, even if it technically functions well. Norman also discusses how anxiety can interfere with usability by causing stress, which narrows a person’s ability to think flexibly and adapt. I found it fascinating that aesthetics can influence not just perception but also actual performance, as users who feel calm and engaged are much better equipped to navigate challenges that come with items.

Her Code Got Humans on the Moon:

I found the dedication that Margaret Hamilton had to her work incredible. As a working mother during a time when women would often stay at home, finding time to balance work and home is truly applause worthy and showcases her dedication and passion for her work. Her meticulous approach to programming, combined with her insistence on rigorous testing and error prevention, was absolutely crucial in ensuring the success of the moon landing. I was particularly struck by her emphasis on anticipating potential errors, a mindset that transformed how mission-critical software was developed which is something we could use in our coding as well. Her work demonstrates how careful planning and foresight can mitigate human errors, which, in high-stakes environments like space travel, could really mean the difference between life and death.