Author: Ziya Vhora

CONCEPT:

For my final project, I want to incorporate and showcase my interests. One of these interests of mines are penguins. Therefore, I have settled on making an interactive game called ‘Pingu Pounce’. Pingu Pounce is essentially an exhilarating game where players help a plucky penguin fly through icy platforms. With simple physical controls, players will use them to make their penguin leap from one slippery platform to the next, aiming to climb as high as possible while avoiding obstacles like sharp platforms. 

A brief rant on the future of interaction design…

Victor expands on this idea by arguing that the future of interaction design should move beyond just screens and graphical user interfaces. He contends that our current reliance on touchscreens and GUIs is limiting, and that we need to explore more natural and intuitive ways for humans to interact with technology.

Victor argues that interaction design should leverage our innate abilities to manipulate physical objects and navigate three-dimensional space. He suggests that future interfaces should allow users to interact with information and digital content as if they were tangible objects, rather than abstract representations on a flat screen.

The article emphasizes the importance of incorporating more natural hand and body movements into interface design. Victor contends that touchscreens and mice are poor substitutes for the rich expressiveness and dexterity of human hands. He envisions interfaces that can interpret subtle gestures, manipulations, and movements to control digital systems more intuitively. I agree with Victor’s core argument that interaction design needs to evolve beyond just screens and GUIs to create more natural and intuitive interfaces.

However, I would add that while moving beyond touchscreens and traditional GUIs is important for pushing interaction design forward, we shouldn’t completely discard these technologies which call for the use of a single finger. This simple design he is ranting about is especially handy for users with certain disabilities or limitations.

For example, touchscreen interfaces with large, easy-to-tap buttons can be very beneficial for users with motor control issues or limited dexterity. The simplicity of tapping a screen with one finger opens up digital experiences to many who might struggle with more complex gestural interfaces. 

Tinh and I going into this were slightly stuck on the creative idea first. However, during a brainstorm session, we came across a video of a ballerina music box – inspiring us to create something similar to this whilst sticking to the ‘instrument’ concept of the assignments. As we did not have a mini ballerina, I had a mini figurine nonetheless – a small penguin rubber (Basil Jr). Now that we had a figurine, we had to figure out how to implement the ‘instrument’ concept into this, as we did not want to make it into a passive music box.

Therefore, we decided we wanted to control the movement of the penguin with the instrument. We ended up deciding that buttons could be used as the method to control movement — we decided that each button would correspond to a note, and each note has a specific rotation. Originally, we wanted to use 8 buttons to correspond to the 8 notes, however, due to the limited space on our breadboard, we chose to stick with three – C,D,E.

This is our code:

#include <Servo.h>
#include "pitches.h"


const int photoPin = A0;        // Photoresistor analog pin
const int ledPin = 6;           // LED pin
const int buttonPins[] = {2, 3, 4};  // Button pins for sound triggers
const int photoThreshold = 100; // Threshold for photoresistor reading
const int speakerPin = 8;

Servo penguinServo;             // Create servo object
const int servoPin = 9;         // Servo pin

void setup() {
    // Initialize the photoresistor, LED, and buttons
    pinMode(ledPin, OUTPUT);
    for (int i = 0; i < 3; i++) {
        pinMode(buttonPins[i], INPUT_PULLUP);  // Using internal pull-up resistor
    }

    // Attach servo to pin
    penguinServo.attach(servoPin);

    Serial.begin(9600);  // For debugging if needed
}

void loop() {
    // Read the photoresistor value
    int photoValue = analogRead(photoPin);
    Serial.println(photoValue);

    // Control the LED based on photoresistor value
    if (photoValue < photoThreshold) {
        digitalWrite(ledPin, HIGH);  // Turn on LED if it's dark
    } else {
        digitalWrite(ledPin, LOW);   // Turn off LED otherwise
    }

    // Check each button 
    for (int i = 0; i < 3; i++) {
        if (digitalRead(buttonPins[i]) == LOW) { // Button pressed
            playPitch(i);
            movePenguin(i);  // Move penguin based on button pressed
        }
    }
}

// Function to move the penguin based on the button pressed
void movePenguin(int buttonIndex) {
    switch (buttonIndex) {
        case 0:
            penguinServo.write(0);   // Move penguin in one direction
            break;
        case 1:
            penguinServo.write(90);  // Move penguin to center
            break;
        case 2:
            penguinServo.write(180); // Move penguin in the other direction
            break;
    }
    delay(1000);  // Hold position for 1 second
    penguinServo.write(90);  // Return to center
}


void playPitch(int buttonIndex) {
    switch (buttonIndex) {
        case 0:
            tone(speakerPin, NOTE_C4, 300); // Play note C4
            break;
        case 1:
            tone(speakerPin, NOTE_D4, 300); // Play note D4
            break;
        case 2:
            tone(speakerPin, NOTE_E4, 300); // Play note E4
            break;
    }
    delay(300);
    noTone(speakerPin);
}

Physical Computing’s Greatest Hits (and misses)

This reading was insightful as it helped me to demystify some of my own misconceptions regarding making works that have already been done before. He tells us that it is okay to make something which has already been made before, as long as we apply our own ideas into it – add that unique touch. For example, he discusses a work made in the theme of music instruments. . The examples he shared with us, tells us that while recreating existing projects is a common starting point, it’s crucial for designers to innovate by incorporating their unique perspectives. Key elements for creating meaningful interactions include considering the context and purpose of the interaction, designing physical structures that complement intended use, and developing natural gestures that feel significant to users. Analyzing both successful and unsuccessful projects reveals important lessons: simplicity can be powerful, user experience is paramount, and innovation often arises through iteration. By understanding these principles, creators can develop more impactful physical computing projects, pushing the boundaries of interactive technology while learning from the successes and failures of their predecessors.

Making Interactive Art: Set the Stage, Then Shut Up and Listen

When I read this, I came to understand that an interactive project is a performance. When it comes to the works I make, especially the ones I have made for this class. I often find myself explaining a lot before the person gets to interact with it. But now I came to understand why that can be harmful for the user. Our work itself should be intuitive to the extent where we don’t have to explain anything — if a button is supposed to be pressed, make it approachable. Essentially, the essence of interactive art lies in its ability to engage users without extensive explanation. Just as a well-designed stage set can convey the mood and context of a play before a single word is spoken, an interactive piece should invite engagement through its visual cues, layout, and interface design By minimizing verbal instructions and allowing users to approach the work with fresh eyes, we empower them to become active participants rather than passive observers. This approach not only enhances the sense of discovery and exploration but also opens the door to unexpected and delightful interactions. The joy of interactive art often resides in the process of figuring out how to engage with it, much like solving a puzzle or exploring a new environment. As artists, our role shifts from being explainers to becoming facilitators of experiences. We set the stage, carefully crafting the environment to encourage exploration and interaction. Then, we step back, observe, and listen. This process of watching users interact with our work without intervention provides valuable insights for refining and improving the intuitive aspects of our designs.

Attractive things work better

I found this reading particularly intriguing because it introduced a concept I hadn’t considered before: the significance of “mindspace” in our interactions with objects. As the text points out, when users are in a relaxed state, they are more likely to successfully complete tasks, such as unlocking a door.

Additionally, the reading thoughtfully explores the idea that an object’s beauty extends beyond mere aesthetics; its functionality plays a crucial role as well. This connection between emotion and design is fascinating—attractive objects not only draw us in but also enhance our overall experience and effectiveness in using them.

Her Code Got People on the Moon

Hamilton has made imperative and remarkable contributions to the field of space. As the director of the Software Engineering Division at MIT’s Instrumentation Laboratory, Hamilton led the team that developed the on-board flight software for NASA’s Apollo missions, including the historic Apollo 11 moon landing. 

Margaret Hamilton’s contributions to the Apollo program and computer science have been widely recognized and celebrated. She coined the term “software engineering” to elevate the field and give it the respect it deserved alongside other engineering disciplines. Hamilton’s story not only highlights the crucial importance of software development in the success of the Apollo missions but also sheds light on the often-overlooked contributions of women in the early days of computer science and space exploration. Her pioneering work and leadership helped pave the way for future generations of software engineers and computer scientists.

PROJECT: UNUSUAL SWITCH

For this unusual switch project, I conceptualized a system where clicking or snapping my fingers would activate an LED light. This idea explores novel ways of interacting with electronic devices using natural gestures.

Components Used:

Arduino board: Used to control the circuit and process inputs

LED: The light source activated by the finger snap

Resistor (330 ohm): To limit current flow and protect the LED

Jumper wires: For making connections between components

Copper tape: Used as a sensor to detect the finger snap without a traditional button

REFLECTION: 

• Importance of resistors: I initially forgot to add a resistor, which resulted in the LED burning out. This made me understand the critical role of resistors in protecting sensitive components.

IMG_7912