Author: Ibrahim Ahmad

Reading about classic physical computing projects, I was struck by how these interactive experiences allowed creative personalization. I was greatly inspired by how simply notions of time space and senses could be creatively challenged and it is a task that I intend to do in my phyiscal computing projects going forward.

The theremin-like instruments idea resonated greatly with me. I’d love to explore creating music through hand gestures, adding subtle layers that shift tone and pitch, channeling emotions through motion. Similarly, the glove-based instruments brought to mind using gloves to play sounds with a touch or pinch, bridging the digital and physical in a poetic way. Hands are the way we interact most closely with the world, and having them be the bridge that transcends the physical and virtual is inherently poetic.

The video mirror section made me think about my interest in using computer vision thoughtfully in art. I’d love to create a mirror that captures shadows or movements subtly, making it feel like a shared, non-intrusive moment.

The yell-activated projects felt liberating, inspiring thoughts on using sound to create splashes of color, encouraging expressive, even chaotic, engagement with tech. The passion involved in a scream or a loud sound, uncaring for your environment and showing vulnerability, are all themes that I wish to explore further.

Reading about these timeless projects has me excited to experiment with ways to make them my own. Physical computing offers an amazing canvas, and I would love to take a deeper dive into these topics so that I can hopefully inspire someone too like I was inspired reading about these projects.

Tom Igoe’s article, “Making Interactive Art: Set the Stage, Then Shut Up and Listen,” emphasized that artists should let their interactive artwork speak for itself, rather than over-explaining it. According to Igoe, artists often script or interpret every part of their work, potentially limiting participants’ personal engagement. Instead, Igoe argues that interactive art should initiate a dialogue, allowing the audience to explore, interpret, and react in their own way. He compares this to a director’s approach with actors, guiding without dictating emotions, letting authentic responses emerge. For interactive art, setting up the experience thoughtfully, then stepping back, creates a collaborative process where the audience completes the piece through interaction. I realised that often in my own work, I do not allow the space for that creativity which hinders how interactive they can be. If the observer is first faced with my viewpoint and then the art itself, they will only be able to see it from my eye. This reading gives me motivation to learn to separate the art from the artist in my own and other’s art and let my work flourish and have a voice of its own.

Concept:

The idea for this project came from something I’ve always found fascinating: the transition from night to day, especially the way streetlights turn off as the new day begins and the sun begins to rise.
I’ve always been captivated by the natural beauty of a sunrise, how the sky gradually shifts colors as the day begins.  The goal was to create something interactive where turning off a “streetlight” (represented by a blue LED) would trigger a sunrise sequence using an RGB LED. I used a photoresistor that detects the change in light when the streetlight is turned off, this then turns on the RGB light sequence.

Demonstration:

Code:

const int blue_led_pin = 9;         // Blue light (streetlight)
const int switch_pin = 2;           // Switch pin
const int photo_resistor_pin = A0;  // Photoresistor pin
const int red_pin = 3;              // Red pin of RGB 
const int green_pin = 5;            // Green pin of RGB 
const int blue_pin = 6;             // Blue pin of RGB

// Variables
bool streetlight_on = true;         // bool to track if the stretlight is on
bool sunrise_started = false;       // bool to track is the sunrise sequence has started

void setup() {
  // Initialize pins
  pinMode(blue_led_pin, OUTPUT);
  pinMode(switch_pin, INPUT);

  pinMode(red_pin, OUTPUT);
  pinMode(green_pin, OUTPUT);
  pinMode(blue_pin, OUTPUT);

  // streetlight starts off as on
  digitalWrite(blue_led_pin, HIGH);
}

void loop() {
  // Check if the switch is pressed
  if (digitalRead(switch_pin) == HIGH && streetlight_on) {
    digitalWrite(blue_led_pin, LOW);   // Turn off streetlight
    streetlight_on = false;            // change the bool to reflect the streetlight being off
  }

  // Read light level from photoresistor
  int light_level = analogRead(photo_resistor_pin);

  // If light level drops below threshold, start sunrise sequence, can be if the blue light turns off or if the light is manually blocked
  if ( !sunrise_started && light_level < 500) { 
    sunrise_effect();
    sunrise_started = true;            // bool confirms that sunrise has started
  }
}

void sunrise_effect() {
  // Gradually change colors like a sunrise
  for (int i = 0; i <= 255; i++) {
    analogWrite(red_pin, i);           // Increase red brightness first
    delay(30);                         // Adjust delay for smooth transition

    if (i > 100) {
      analogWrite(green_pin, i - 100); // Add green for yellow/orange colors
    }

    if (i > 200) {
      analogWrite(blue_pin, i - 200);   // Add blue for full white at to show noon
    }

    delay(30);
  }
}

Schematics:

Workings:

The blue led is shone directly into a photoresistor. When the switch is used to turn it off, the photoresistor reading goes down which triggers the sunrise sequence on the rgb led. It is demonstrated that the photoresistor triggers the sequence and not the button press as even when the photoresistor is covered with a finger with the blue led on, the reading goes down and the sunrise sequence is initiated.

Future Considerations:

I had tremendous fun working on this project especially learning how the rgb led works. In the future I’d like to add more leds which trigger different sequences in the rgb led or perhaps a sound aspect to it as well where a loud sound triggers the sequence.

Norman:
When I first opened the article titled “attractive things work better”, I was completely unaware that I would leave with such profound insights.
Norman’s premise—“attractive things work better”—initially appears straightforward, but as he dives deeper, it’s clear that he challenges the pure function-over-form mindset often seen in technology and design. Reading his analysis, I found myself reflecting on my own relationship with technology and my understanding of utility, aesthetics, and the human experience in design.

One example Norman uses to illustrate the power of emotional design is color screens on computers. He recalls initially perceiving color screens as unnecessary, a view that aligns with a utilitarian perspective focused on measurable, practical outcomes. However, he soon realized that, despite offering no overt advantage, color screens created a more engaging experience. I can see this reflected in my choice of smartphones, where choosing a sleeker more aesthetically pleasing model is a priority even if the it performs identically to a model that is cheaper but less aesthetically appealing. Though a basic model could perform many of the same tasks, I choose a high-end model because it simply feels right. While utilitarianism would label this decision inefficient, Norman’s work suggests that emotion has its own kind of utility.

An interesting case where Normal emphasizes utility over looks is his example of emergency doors, where design has to be immediately intuitive, especially in emergencies. It’s an example where utilitarianism, focused on maximum efficiency, clearly benefits the user. However, in low-stress situations, attractive designs with aesthetic details enhance the user’s experience. This reflects John Stuart Mill’s “higher pleasures” in qualitative utilitarian philosophy, which suggests that intellectual and emotional satisfaction are inseparable from true utility. Norman’s view implicitly critiques a rigid, form-over-function approach by suggesting that design must incorporate both utility and aesthetics to meet the full spectrum of human needs.

As a student, I see Norman’s work inspiring me to think differently about the intersection of technology, utility, and emotion.  Rather than dismissing emotional design as indulgent, Norman helps us see that “attractive things work better” not because of a superficial appeal to aesthetics but because they engage our emotions in ways that functionality alone cannot.

Hamilton:
Margaret Hamilton’s contributions to the Apollo Program and software engineering are monumental feats accomplished against all odds. Her ability to work under high pressure, to predict and plan for critical failures and her creative thinking made the moon landing a resounding success. At the same time it saddens me how little I had heard of Margaret before this article, everyone always talks about Neil Armstrong or Buzz Aldrin, and famous lines they said while diminishing the ever important work of a brilliant woman.

Hamilton built in a priority task scheduling system and robust error handling which came in handy when multiple alarms threatened to abort the Apollo 11 mission. She also coined the term software engineering, providing more legitimacy to a field which now permeates through every major and minor world avenue. As a woman leading a crucial team in a male dominated field, she broke significant barriers and paved the way for more gender diversity within STEM.
Her legacy extended beyond the Apollo Guidance System, she continued working on error prevention and development of UML  showcasing a lifelong devotion to her field and love for computers.
I am truly inspired by the immense impact that Hamilton has had on the field, contributing to one of humanity’s greatest feats while also shaping how we think of software development today. Her story is a powerful reminder to push boundaries, think creatively and to plan rigorously for every outcome even in the face of insurmountable challenges.

 

 

Concept: 

While thinking of unusual switches, the first thing that came to mind was how suitcase locks work. How setting some sort of combination and pressing a button would make that into a ‘password’ that you could repeatedly use to open the suitcase. Inspired and fascinated by the workings of such a simple concept I came up with the idea of mimicking a combination lock but instead using buttons on a breadboard. Although using our hands wasn’t technically a part of the assignment, I do believe that being able to set a combination using the code, and having the circuit only work when the correct combination is entered is a creative switch.
Code Highlight:

Approaching this problem I had to think very creatively about how the Arduino code would work with multiple switches. In the end the best solution I arrived at was setting a lock using the pins each switch was connected to and then checking if each switch pressed in order was one corresponding to its index in the combination array.

const int buttonPins[] = {2, 3, 4, 5}; // Digital pins connected to the buttons
const int ledPin = 13; // Digital pin connected to the LED
int combo[] = {0, 1, 2, 3}; // The correct sequence of button presses (in order)
int input[4]; // Array to store the user's button press sequense
int index = 0; // Keeps track of how many correct buttons have been pressed
bool isUnlocked = false; // Flag to indicate if the correct combination has been entered

void setup() {
  // Set up each button pin as an input
  for (int i = 0; i < 4; i++) {
    pinMode(buttonPins[i], INPUT);
  }
  // Set up the LED pin as an output
  pinMode(ledPin, OUTPUT);
}

void loop() {
  if (!isUnlocked) { // Only check for button presses if the lock is not yet unlocked
    for (int i = 0; i < 4; i++) { // Iterate over each button
      if (digitalRead(buttonPins[i]) == HIGH) { // Check if the current button is pressed
       delay(50) //Small delay to ensure one press is not registered multiple times
        if (digitalRead(buttonPins[i]) == HIGH) { // Confirm the button is still pressed
          if (i == combo[index]) { // Check if this button is the next in the correct sequence
            input[index] = i; // Record the correct press in the input array
            index++; // Move to the next position in the sequence
            delay(500); // Delay to avoid multiple readings from a single press
          } else {
            index = 0; // Reset if a wrong button is pressed
            break; // Exit the loop to start checking from scratch
          }
        }
      }
    }

    if (index == 4) { // If all buttons have been pressed in the correct order
      digitalWrite(ledPin, HIGH); // Turn on the LED to indicate success
      isUnlocked = true; // Set flag to indicate that the lock has been unlocked
    }
  }
}

Demonstration:

The led only lights up when the correct combination is pressed
In this case the correct combination is yellow, red, green, blue for clarity of demonstration.

Inspiration:

I’ve always had a fear of snakes. Overcoming it seemed impossible until I started working on my game. Inspired by how snakes consume food whole, I created “Going Through It”.  An obstacle course game where the obstacle course is designed in the shape of a snake. The player controls a small stick character trying to escape the snake as fast as possible. Adding my own unique twist to the game, the player cannot directly control the jumping ability of the stick figure, instead the stick is more akin to a ‘pogo stick’ where it bounces off with every obstacle it collides with and the player only controls the rotation of the stick figure using their keyboard.

Challenges Faced:

Developing “Going Through It” presented me with several challenges

• Collision Detection: One of the primary difficulties was implementing an effective collision detection system that could handle the stick’s rotation and interactions with obstacles at various angles. Ensuring that the stick responds correctly to collisions, including bouncing off surfaces at appropriate angles, required careful calculation and testing. This is one of the primary features of the game and needed to be perfect although I am always sorting out minor issues with the collision detection mechanism.
• Physics and Movement: Balancing the physics of gravity, friction, and rotational speed to create a challenging yet fun experience was another challenge. The stick couldn’t be too fast, the gravity couldn’t be too strong and the rotation had to be just right to be responsive yet precise. Fixing these problems involved a significant amount of play testing the game.
• User Interface and Feedback: Designing an intuitive user interface that provides clear feedback to players was an essential feature of the game for me. This included displaying elapsed time, providing instructions, and ensuring that game states (such as starting or ending the game) were communicated effectively. In the end I decided to go with a very minimal layout that fits with the aesthetic of the game but I do believe that it is still intuitive and someone could understand how to play and win with minimal effort.

Final Project:
Conclusions and Reflections:
Reflecting back on this project, developing this game has been both a creative and highly technical journey.
Looking ahead, I hope to improve many aspects of this project as it is an idea that I haven’t seen before. The following are some ideas I have for future improvements to this game.
Level Design: Expanding “Going Through It” with more levels featuring diverse obstacle layouts and increasing difficulty. Moving obstacles are also a problem I hope to tackle in the future.
Multiplayer Mode: Due to the speed-run nature of the game, a mode where players can compete in real time would greatly add to the immersion and entertaining nature of the gameOverall, this project has laid a strong foundation for further development, I am genuinely excited about the game I have created and I hope to keep working on it in the future. Plus the amount of trigonometry implemented for collisions has made me a better mathematician which is always a welcome side effect.

 

Project Concept:

I’ve always had a fear of snakes. Overcoming it seemed impossible until I started working on my game. Inspired by how snakes consume food whole, I had the idea of the game I am working on for my midterm called “Going Through It”. It is be an obstacle course game where the obstacle course is be designed in the shape of a snake. The player controls a small stick character trying to escape the snake as fast as possible. Adding my own unique twist to the game, the player cannot directly control the jumping ability of the stick figure, instead the stick is more akin to a ‘pogo stick’ where it bounces off with every obstacle it collides with and the player only controls the rotation of the stick figure using their keyboard.

User Interaction Design:

Player Input: The player uses the “A” and “D” keys to control the rotation of the stick figure. Player needs to angle the jump correctly to get through each part of the obstacle course.
Obstacles: The whole level design acts as the obstacle in this game, where the stick figure can bounce around by hitting walls or the insides of the ‘snake’ and can even get stuck in some traps laid out to make the game trickier to play.
Game Progression: As death is not an element of this game, the players race against themselves and other players to complete the level in the shortest possible time as they understand the mechanics of the game better.

Code Design: Functions, Classes, and Interactivity:

‘Going Through It’ is built using Object Oriented Programming (OOP) where every entity within the game belongs to a separate class that interact closely to make the game function.

The primary classes and their major functionalities are as follows:

Obstacle Class: The obstacle class defines the parameters for the rectangles make up the ‘snake’, it also contains functions such as display() which display the obstacles as one cohesive interactable object.

Stick Class: The Stick class defines the stick object itself and contains functions such as rotate() and update() which help establish rules for collision and input caused rotation. This serves as the biggest and most important class for the game code

Snake Level Class: The snake level class instantiates the obstacle class objects with coordinates to make one cohesive snake level and adds them to a list so collision checks can be performed.

Game Class: Game class deals with all functionality not handled by the other classes, this includes functions for pausing the game, showing the start screen, showing a lowest time, and starting the level itself. It also checks when a level has ended and displays a text with the time taken to clear the obstacle.

Identifying and Addressing Risks:
The most challenging aspect of the project is implementing accurate collision detection between the stick character and the obstacles. Since there are a multitude of angles the stick can collide with the obstacles with, figuring out accurate and responsive collision detection has involved a lot of trigonometry and I definitely believe there is more to come in order to account for all possible scenarios.

In order to mitigate the risk of the stick phasing through the level, or getting stuck at certain points I have tried to account for detection with each corner of the stick, each side vertical and horizontal and collision with vertical, horizontal and obstacle walls at diagonals. This is a tedious process and there is a lot of room for error which I am minimizing through meticulous play testing of the level.

Another risk I am trying to mitigate is the complexity of the level, as this is a single player game, a level that is too easy will make the game not enjoyable after a few playthroughs, on the contrary a level that is too complex and difficult to compete will cause players to quit and not wish to progress sooner. I hope to continue doing play testing, also involving friends who have never played the game before so that I can get input from them and adjust the level and individual paths within the level to make the game the perfect mix of complex but pushing people to beat the level in shorter and shorter times.

Snapshots from the game and further steps:

 

This is the design of the Snake Level, the time is shown in the top left corner and stops running once the level is completed

Next Steps:

Adding a Lowest Score: I want to keep a track of the lowest time achieved which is displayed on the game start screen and is meant to be an initial challenge for new players  to beat.

Start Screen: I want to add a start screen which shows, the level itself, the tutorial for the game and lowest time someone has taken to complete the level.

 

After watching Casey Reas’ talk, I’ve found my randomness and controlled chaos held within art. The way he intertwined randomness with controlled elements presented me with a unique perspective on creating art, showing how seemingly chaotic processes could yield meaningful and structured outcomes.

One of the standout examples from his talk was his work with cancer cell data, where he uses controlled randomness to produce distinctive visual patterns. This application of data not only served an artistic purpose but also pushed the boundaries of the interpretation of scientific information. It sparked a realization in me: the artistic process can be deeply intertwined with scientific exploration, leading to new interpretations and insights.

It was remarkable to see how even simple elements like dashes could serve as building blocks for more complex patterns. This idea compelled me to reconsider my creative practices. Instead of getting overwhelmed by the complexity of my projects, I now have the ability to start small and hopefully snowball into a project that I can be proud of.

Moreover, his talk provoked a deeper philosophical inquiry into the nature of creativity itself. If art can emerge from a system of randomness and algorithms, it challenges our conventional understanding of ownership and intentionality. In a time when machines contribute more and more to the artistic and creative process, is there a line we can draw regarding owning a piece of art or even whether something can be called art itself?

After Reas’ talk, I’m inspired to experiment more freely with randomness and tiptoe within the lines of control and chaos.

Golan Levin’s article on Computer Vision opened my eyes to the fascinating world of computer vision in art. As a computer science major also delving into the visual arts, I found this piece incredibly relevant to my studies and personal interests.
The historical overview of computer vision in interactive art was eye-opening. I was unaware of the fact that artists have been experimenting with this technology since Myron Kruger’s work in the 1970s. It’s amazing to see how far society has progressed in the past half a century and how artists continue to push the boundaries of what’s possible with these tools.
One thing that really stuck with me was the explanation of basic computer vision techniques. I’ve always been curious about how interactive installations work, and learning about motion detection and object tracking was akin to getting a peek behind the curtain. It was fascinating to think that these fundamental concepts are behind so many of the interactive artworks in galleries and online.
The article made me think a lot about the difference between human and machine vision. I never realized how much work goes into making a computer “see” things that we take for granted. The fact that algorithms have to assign meaning to visual data is mind-blowing. It makes me appreciate the complexity of human perception even more.
I was particularly intrigued by the ethical implications of using computer vision in art. The example of the Suicide Box by the Bureau of Inverse Technology made me think about the fine line between art and surveillance. As someone who wants to create interactive pieces, I’m now more aware of the responsibility that comes with using these technologies. How do we make sure we’re not invading people’s privacy while still creating engaging experiences? It’s definitely something I’ll be considering in my future projects.
I appreciated that Levin included code examples, so I could see firsthand the effort and technique that went into creating such pieces. In conclusion, this article has changed the way I think about interactive art. It’s not just about creating engaging and fun experiences anymore; it’s about understanding the technology behind it and using it responsibly. I’m looking forward to experimenting with computer vision in my own work, but I hope to be more mindful of the ethical considerations involved.

Inspiration:

In this project, I aimed to create a dynamic visualization of baby names by ethnicity, year, and gender using data from a CSV file. The inspiration for this project came from the realization that names are not just identifiers; they often carry cultural significance and reflect societal trends. By exploring how different ethnicities and genders influence naming patterns over time, I wanted to highlight the diversity and richness of society. This interactive visualization allows users to engage with the data, making it easier to understand how names evolve and resonate within various communities within the US. The data for the USA was readily available and organized, and thus I decided to pick that as my dataset.

Code that I am particularly proud of:

One of the sections of my code that I am particularly proud of is the get_top_names function. This function processes the CSV data to extract the top ten baby names based on user selected criteria including ethnicity, year, and gender. This code tallies the occurrences of each name and sorts them to ensure that the most popular names are displayed in the visualization.

// This function processes the provided data to get the top 10 names
function get_top_names(ethnicity, year, gender) {
  let names = {};
  for (let row of table.rows) {
    // filters the data based on our current selection
    if (row.get('Year of Birth') === year && row.get('Ethnicity') === ethnicity && row.get('Gender') === gender) {
      let name = row.get("Child's First Name");
      let count = parseInt(row.get('Count'));
      // sums up counts for each name to account for duplicates
      if (name in names) {
        names[name] += count;
      } else {
        names[name] = count;
      }
    }
  }

Final Product:

Conclusions and Reflections:

Reflecting on this project, I recognize the power data visualization holds in uncovering trends and fostering human understanding and comprehension. I learned how to manipulate data and create interactive elements that allow users to explore and compare information. However, there are several areas for improvement. For instance I hope to incorporate additional features such as user-input filters or a broader range of years. I hope to also include an overlay feature where two separate bar charts can be compared on the same canvas, this could be useful for example if someone wants to more clearly see the trend of a certain name through time. Additionally, I plan to improve the aesthetics of the visualization by experimenting with different color palettes and designs to make it more appealing. Overall, this project has been a valuable learning experience, and I look forward to applying these insights in later projects.

 

Norman’s exploration of everyday objects like doors, switches, and scissors turns the mundane into a reflection of hidden complexities and subtle interactions. As I dove into his ideas about affordances and signifiers, I began seeing my surroundings in a different light. The handle of my coffee mug, the curve of my desk lamp, and even the layout of my keyboard buttons weren’t just functional anymore; they became silent storytellers, each with their own design narrative.

As a left-handed person, Norman’s ideas on affordances and signifiers took on an even deeper meaning for me. I’ve often struggled with objects clearly not designed with me in mind can openers, scissors, and the constant smudging when I write. These frustrations were aptly highlighted in Norman’s push for more inclusive, human-centered design. His arguments about making design accessible to everyone, not just the majority, struck me on a personal level.

The concept of discoverability really stood out during the time I spent reading the chapter. I’ve often found myself baffled by unfamiliar appliances, caught between curiosity and confusion. Norman helped explain why some objects feel intuitive and welcoming, while others seem to thrive on leaving us puzzled. I think back to my experiences with the university printers, with poorly labelled buttons, and an digital interface buried in endless menus. Something as simple as scanning a document became a frustrating guessing game, all because there were no clear signifiers to guide me. In contrast, a well-designed printer would have had intuitive, clearly marked buttons or icons, making the process straightforward and stress free. It was a perfect illustration of Norman’s design principles or lack thereof.

Norman’s “paradox of technology” also resonated with me. As our devices become more advanced, they often become harder to understand. It’s ironic how progress can make us feel more disconnected. I think about my grandmother struggling with her new smartphone, a device that’s supposed to make life easier but instead leaves her feeling lost. It’s a clear example of how our pursuit of innovation can create barriers instead of breaking them down.

The emphasis on feedback also struck me as important. In our world of touchscreens and voice commands, clear feedback is more necessary than ever. I find myself missing the click of a button – the small but essential signal that something has actually happened. Without feedback, it’s easy to feel disconnected from the technology I am using.

Norman’s idea of conceptual models made me reflect on my own assumptions. How often do I approach a new device or system with a flawed understanding of how it works? It’s humbling to realize that many of my mental models are incomplete, and that much of what I think I know is just a simplified version of reality.

After finishing the chapter, I felt both inspired and responsible. Norman reveals how design influences every interaction we have, and as someone studying interactive media, I realize I might one day contribute to shaping these interactions. Norman’s call for human-centered design isn’t just about convenience – it’s about honoring the complexity and diversity of the human experience.

In the end, his message reminds us that between people and objects lies a world of potential – and that good design is about more than just solving problems. It’s about understanding what it means to be human.