week 8- reading response

Emotion and Design, by Don Norman:

This reading made me think about how emotions affect how we interact with objects. Norman explains that people don’t just want things to work, they want them to look and feel good too. I never realized how much my own emotions influence my experience with products. Even if something is not perfectly functional, I might still like it because it looks nice or makes me feel good. It shows that good design is about balance, not just usability but also beauty.

Her Code Got Humans on the Moon, by Robert McMillan:

Her story is inspiring because it highlights how crucial software is, even in something as big as landing on the moon. It’s interesting to see how her careful programming helped avoid disaster during Apollo 11. What stood out to me most was how she had to prove herself in a male-dominated field, yet her work shaped modern software engineering. It made me appreciate how much behind-the-scenes effort goes into technological breakthroughs

week 8- unusual switch

Concept:

I created this project because I often find myself unsure whether the fridge is fully closed. Sometimes, the door looks shut, but it’s actually slightly open. Other times, I forget if I closed it at all. To solve this, I designed a simple circuit using two pieces of foil as a switch. When the fridge door is completely closed, the foil pieces touch, completing the circuit and lighting up a bulb. If the door is open, the circuit breaks, and the bulb stays off. This way, I can quickly tell if the fridge is properly closed, preventing food from spoiling.

Code:

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
void setup() {
pinMode(11, OUTPUT);
pinMode(A2, INPUT);
}
void loop() {
int switchPosition = digitalRead(A2);
if (switchPosition == HIGH) {
digitalWrite(11, HIGH); // turn the LED on (HIGH is the voltage level)
} else {
digitalWrite(11, LOW); // turn the LED off by making the voltage LOW
}
}
void setup() { pinMode(11, OUTPUT); pinMode(A2, INPUT); } void loop() { int switchPosition = digitalRead(A2); if (switchPosition == HIGH) { digitalWrite(11, HIGH); // turn the LED on (HIGH is the voltage level) } else { digitalWrite(11, LOW); // turn the LED off by making the voltage LOW } }
void setup() {
  pinMode(11, OUTPUT);
  pinMode(A2, INPUT);
}

void loop() {

  int switchPosition = digitalRead(A2);

  if (switchPosition == HIGH) {
    digitalWrite(11, HIGH);   // turn the LED on (HIGH is the voltage level)
  } else  {
    digitalWrite(11, LOW);    // turn the LED off by making the voltage LOW
  }
}

 

video: 

(I used my foot I promise)

video

Reflection and improvements:

Looking back at my project, I realize that while it works, it’s quite simple and could be improved. The basic foil switch effectively indicates whether the fridge is closed, but it doesn’t provide additional details, like how long the door has been open. I could have added more features, such as a timer that sounds an alarm if the fridge stays open too long or a small screen displaying a warning message. Adding these functions will make it more interactive.

Midterm :)

Project Concept

This project is a simple point and click game based on SpongeBob’s world. The player starts outside SpongeBob, Patrick, and Squidward’s houses and can click on them to enter different rooms. Each room has its own design and sometimes interactive elements like sounds, books, or TV screens. The goal is to explore different parts of their world and experience small interactions.

link to the sketch: https://editor.p5js.org/flipflops/full/Z69RYq4v1

To make the game feel more personal, I drew all the rooms and the background instead of using images online. I tried making it so that all the drawings blend well with the objects I coded, so everything feels like part of the same world:

How it works

The game constantly checks where the user is and updates the background based on their location. When the player clicks on a house, the game detects which house was clicked and then changes the background to the correct room image. Some rooms also have extra interactive features, like playing specific sounds or changing visuals when clicked.

For example, the TV room cycles through different screens each time the player clicks, making it feel like the TV is actually changing channels. The book room has different pages that the player can flip through, and each page includes a funny SpongeBob quote. The game also manages background music, so when the player moves between different rooms, it plays the correct theme without overlapping sounds. Another thing I focused on was making sure the back button always works properly, so the player can return outside without any weird glitches.

Code highlight

One of the coolest parts that I’m proud about is the clarinet room, where the player can actually play Squidward’s clarinet. There are seven different notes, and clicking on different parts of the clarinet will play them. It’s like a mini music feature inside the game, and it makes Squidward’s room more interesting instead of just being another background.

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
function checkClarinetHoleClick(mx, my) {
// all the clarinet holes coordinates (left to right) stored in array
let clarinetHoles = [
{ x: 174, y: 153 },
{ x: 190, y: 153 },
{ x: 205, y: 153 },
{ x: 218, y: 153 },
{ x: 245, y: 152 },
{ x: 260, y: 152 },
{ x: 274, y: 152 },
];
for (let i = 0; i < clarinetHoles.length; i++) {
//distance between mouse click and centre of each hole
let d = dist(mx, my, clarinetHoles[i].x, clarinetHoles[i].y);
if (d < 5) { // within 5 pixels
// hole clicked
playClarinetSound(i); // play note
break;
}
}
}
function checkClarinetHoleClick(mx, my) { // all the clarinet holes coordinates (left to right) stored in array let clarinetHoles = [ { x: 174, y: 153 }, { x: 190, y: 153 }, { x: 205, y: 153 }, { x: 218, y: 153 }, { x: 245, y: 152 }, { x: 260, y: 152 }, { x: 274, y: 152 }, ]; for (let i = 0; i < clarinetHoles.length; i++) { //distance between mouse click and centre of each hole let d = dist(mx, my, clarinetHoles[i].x, clarinetHoles[i].y); if (d < 5) { // within 5 pixels // hole clicked playClarinetSound(i); // play note break; } } }
function checkClarinetHoleClick(mx, my) {
  // all the clarinet holes coordinates (left to right) stored in array
  let clarinetHoles = [
    { x: 174, y: 153 },
    { x: 190, y: 153 },
    { x: 205, y: 153 },
    { x: 218, y: 153 },
    { x: 245, y: 152 },
    { x: 260, y: 152 },
    { x: 274, y: 152 },
  ];

  for (let i = 0; i < clarinetHoles.length; i++) {
    //distance between mouse click and centre of each hole
    let d = dist(mx, my, clarinetHoles[i].x, clarinetHoles[i].y);
    if (d < 5) { // within 5 pixels
      // hole clicked
      playClarinetSound(i); // play note
      break;
    }
  }
}

 

Improvement

One issue I ran into was getting the highlight effect to work when hovering over objects. I wanted players to see which items they could interact with, but at first, the effect wasn’t showing up correctly. After some testing, I made sure the game checks the mouse position and only highlights objects when the cursor is over them.

In the future, I would like to add more interactive elements, like clickable objects inside rooms that trigger animations or extra dialogues. Right now, the game works fine, but adding more details would make it feel more complete. Also, the game doesn’t have a clear goal, so maybe adding a small mission or hidden secrets to find would make it more fun.

week #5 – reading

How Computer Vision is Different from Human Vision

Computer vision and human vision work in very different ways. People can see and understand images quickly because our brains recognize patterns, shapes, and objects naturally. We also understand depth, colors, and movement easily. Computers, however, need special instructions to “see” things. They analyze images by looking at tiny dots called pixels and using math to find patterns. Unlike humans, computers have trouble with things like bad lighting, unclear backgrounds, or objects that look similar. This means computer vision needs special tricks to work well in different situations.

How We Help Computers See and Track Objects

Since computers do not see like humans, we use special techniques to help them track objects. One method is frame differencing, where the computer looks at two pictures and spots the differences to detect movement. Background subtraction helps the computer ignore things that do not change and focus only on moving objects. Another technique is brightness thresholding, where the computer finds objects based on how bright or dark they are. More advanced methods use color tracking or infrared cameras to improve accuracy. These tools help computers find and follow objects better, even in complex scenes.

How Computer Vision Affects Interactive Art and Surveillance

Computer vision is used in art to make interactive experiences where people can control things with their movements. For example, in Myron Krueger’s Videoplace, people’s shadows on a screen could interact with digital images. Artists also use computer vision to explore serious topics like surveillance. In Sorting Daemon, David Rokeby used it to study how cameras track people in public places. Another example, Suicide Box, recorded people jumping off a bridge to show how some events are ignored by society. While computer vision makes art more exciting, it also raises questions about privacy and how technology watches people without their permission.

Week #5- midterm progress

My Concept:

For my midterm project, im attempting to bring Bikini Bottom to life through an engaging and nostalgic digital experience. The project features the three iconic homes from SpongeBob SquarePants, SpongeBob’s pineapple house, Squidward’s stone home, and Patrick’s simple rock. The project is a tribute to childhood memories, capturing the essence of the beloved cartoon that many grew up watching. I plan to make it more interactive by making users solve different problems using hints, enabling them to interact with different objects.

Design:

For my design I hope to closely mirror the original aesthetic of SpongeBob SquarePants, using vibrant colors and playful elements to capture the cartoon’s distinct underwater atmosphere. The houses are placed in a scene that resembles Bikini Bottom’s sandy ocean floor, with blue gradients representing the ocean background as shown below: 

The interactive element plays a crucial role in this project. As the user moves their mouse over each house, the door lights up to indicate interactivity. When a user clicks on the door, an passcode input box pops up, where the user needs to type in the correct code to unlock it (by using hints). When a user interacts with the door, they enter the house where, depending on the house chosen, will have a different theme and interactive objects that match the vibes/themes of the character. This will also be done by changing the genre of music inside each house.

Challenges:

One of the main challenges was making the opening door action simple and easy to use. Instead of just clicking the door, I had to add an input field that only appears when needed. Managing this input box so it doesn’t always stay on the screen was tricky. Another challenge was handling incorrect passcodes. I made the program display “Incorrect” on the screen. This required making sure the message only appears when needed and resets when the user tries again.

Finally, I had to ensure that when the correct passcode is entered, the screen updates immediately. This meant making sure the input box and button disappeared at the right time while smoothly transitioning to the next screen.

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
let doorX, doorY, doorWidth, doorHeight;
let isUnlocked = false;
let correctPasscode = "1234"; //the passcode
let userInput = "";
let message = "";
function setup() {
createCanvas(300, 200);
//door position
doorX = width / 2 - 40;
doorY = height / 2;
doorWidth = 80;
doorHeight = 120;
//input box
inputBox = createInput('');
inputBox.position(width / 2 - 50, height / 2 + 50);
inputBox.hide(); //hidden at the start
//create submit button
submitButton = createButton('Enter');
submitButton.position(width / 2 + 60, height / 2 + 50);
submitButton.mousePressed(checkPasscode);
submitButton.hide(); //initially hidden
}
let doorX, doorY, doorWidth, doorHeight; let isUnlocked = false; let correctPasscode = "1234"; //the passcode let userInput = ""; let message = ""; function setup() { createCanvas(300, 200); //door position doorX = width / 2 - 40; doorY = height / 2; doorWidth = 80; doorHeight = 120; //input box inputBox = createInput(''); inputBox.position(width / 2 - 50, height / 2 + 50); inputBox.hide(); //hidden at the start //create submit button submitButton = createButton('Enter'); submitButton.position(width / 2 + 60, height / 2 + 50); submitButton.mousePressed(checkPasscode); submitButton.hide(); //initially hidden }
let doorX, doorY, doorWidth, doorHeight;
let isUnlocked = false;
let correctPasscode = "1234"; //the passcode
let userInput = "";
let message = "";

function setup() {
  createCanvas(300, 200);
  
//door position
  doorX = width / 2 - 40;
  doorY = height / 2;
  doorWidth = 80;
  doorHeight = 120;

//input box
  inputBox = createInput('');
  inputBox.position(width / 2 - 50, height / 2 + 50);
  inputBox.hide(); //hidden at the start

//create submit button
  submitButton = createButton('Enter');
  submitButton.position(width / 2 + 60, height / 2 + 50);
  submitButton.mousePressed(checkPasscode);
  submitButton.hide(); //initially hidden
}

At the moment the dimensions for clicking the door is not perfect at all, but it’s just to give an idea. (click at the bottom of the door)

passcode is “1234”

week #4- Reading

What’s something (not mentioned in the reading) that drives you crazy and how could it be improved?
One everyday design failure that drives me crazy is poorly designed TV remotes. Many remotes today have an overwhelming number of buttons with unclear labels, making simple tasks like changing the volume or input source frustrating. This problem could be improved by applying Don Norman’s principles of discoverability and mapping. For example, remotes should group related buttons more logically and use tactile or color-coded signifiers to indicate key functions. A minimalistic design, similar to Apple’s Siri Remote, which relies on fewer buttons and intuitive gestures, would make the experience much more user-friendly.

How can you apply some of the author’s principles of design to interactive media?
Interactive media, such as mobile apps and websites, can greatly benefit from Norman’s principles of affordances and signifiers. For instance, buttons in an app should clearly indicate their function through visual cues like color, shape, or animations when hovered over. Poor feedback, such as a lack of confirmation when submitting a form, can leave users confused about whether their action was successful. Applying clear feedback mechanisms, like progress indicators or subtle vibrations for mobile interactions, would improve usability and user satisfaction, making digital experiences more intuitive and engaging.



Week #4- Text display

Your concept:

My project is an interactive genie lamp simulation where bubbles of smoke rise from the spout when the user holds the “R” key. As the bubbles grow, they form a speech bubble that displays a random percentage between 1-100%. This percentage acts as a playful response from the genie lamp, making the interaction fun and unpredictable. The bubbles disappear after a few seconds, allowing for continuous engagement

Code highlight:

I thought this part would be easy, just make bubbles appear when “R” is pressed. But at first, they wouldn’t stop generating, and itd fill the whole screen. The diagonal movement also felt off, no matter how I adjusted the values.

After some trial and error, I fixed it by limiting the bubbles and refining the movement formula. It was frustrating at first, but seeing the end result made it worth the effort:

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
function draw() {
background(190, 195, 255);
drawGenieBottle();
// starts generating when r key is pressed
if (keyIsPressed && key === "r" && !generating) {
generating = true; // starts generation process
}
//generate bubbles if within limit
if (generating && bubbles.length < maxBubbles) {
let x = width / 1.35 + bubbles.length * 5; // slight diagonal movement
let y = height - 100 - bubbles.length * 15;
bubbles.push({ x, y, size: 10 + bubbles.length * 3 });
}
function draw() { background(190, 195, 255); drawGenieBottle(); // starts generating when r key is pressed if (keyIsPressed && key === "r" && !generating) { generating = true; // starts generation process } //generate bubbles if within limit if (generating && bubbles.length < maxBubbles) { let x = width / 1.35 + bubbles.length * 5; // slight diagonal movement let y = height - 100 - bubbles.length * 15; bubbles.push({ x, y, size: 10 + bubbles.length * 3 }); }
function draw() {
  background(190, 195, 255);
  drawGenieBottle();

  // starts generating when r key is pressed
  if (keyIsPressed && key === "r" && !generating) {
    generating = true; // starts generation process
  }

  //generate bubbles if within limit
  if (generating && bubbles.length < maxBubbles) {
    let x = width / 1.35 + bubbles.length * 5; // slight diagonal movement
    let y = height - 100 - bubbles.length * 15;
    bubbles.push({ x, y, size: 10 + bubbles.length * 3 });
  }

 

Press “R” key:

Reflection and future improvement:

Overall, I am happy with how my project turned out, especially the animation of the bubbles and the random percentage display. However, I think it could be improved by adding glowing effects, sound, and different animations based on the percentage shown. Adding more visuals and variety would make the experience even more engaging.

Reading Reflection – Week#3

What do you consider to be the characteristics of a strongly interactive system? 

A strongly interactive system is one where both the user and the system actively respond to each other. It’s more than just pressing a button and getting a reaction, it feels like a conversation. A good interactive system listens, processes the input, and gives meaningful feedback. Examples include video games or apps where user actions change the experience in real time.

What ideas do you have for improving the degree of user interaction in your p5 sketches?

To improve user interaction in my p5 sketches, I can incorporate elements that enhance the sense of back and forth engagement. For example, instead of just having objects that move randomly, I can allow users to manipulate them through mouse movement or keyboard input. Adding real time feedback, such as changing colors, dynamic animations, or evolving patterns based on user interaction, can make the experience more immersive.

week 3- OOP

Concept:

For this assignment, I tried incorporating OOP, arrays and functions in different ways to make it interesting. When I was first doing the assignment I wanted to keep the same theme as the last art project and go for something to do with the beach. in the beginning, I was going to make the crab move sideways while his claws open and close but I found that challenging. I still wanted to go along with the theme, so instead I took an Inspiration from a GIF I found online:

https://media.gifdb.com/crab-summer-kawaii-art-06bvdd0otf5hfr0t.gif

And from these drawings I found online:

Code Highlight:

I figured out how to make the background change after the shades hit a specific coordinate but what I found challenging was finding the right values for the rays so that it looks like the GIF. I had to do a lot of trial and error:

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
//draws sun rays from the crabs center
function drawSunRays() {
let centerX = width / 2;
let centerY = height - 120;
let numRays = 12; //number of rays
let angleStep = TWO_PI / numRays; //even spacing between rays
//loop through each ray
for (let i = 0; i < numRays; i++) {
//finding angle for this ray
let angle = i * angleStep;
let rayX = centerX + cos(angle) * width; //move in x direction
let rayY = centerY + sin(angle) * height; //move in y direction
stroke(sunRayColors[int(random(sunRayColors.length))]); //picks a random color
strokeWeight(random(4, 8))
line(centerX, centerY, rayX, rayY);
}
}
//draws sun rays from the crabs center function drawSunRays() { let centerX = width / 2; let centerY = height - 120; let numRays = 12; //number of rays let angleStep = TWO_PI / numRays; //even spacing between rays //loop through each ray for (let i = 0; i < numRays; i++) { //finding angle for this ray let angle = i * angleStep; let rayX = centerX + cos(angle) * width; //move in x direction let rayY = centerY + sin(angle) * height; //move in y direction stroke(sunRayColors[int(random(sunRayColors.length))]); //picks a random color strokeWeight(random(4, 8)) line(centerX, centerY, rayX, rayY); } }
  //draws sun rays from the crabs center
  function drawSunRays() {
    let centerX = width / 2;
    let centerY = height - 120;
    let numRays = 12; //number of rays
    let angleStep = TWO_PI / numRays; //even spacing between rays

  //loop through each ray
    for (let i = 0; i < numRays; i++) {
  //finding angle for this ray 
    let angle = i * angleStep;
    let rayX = centerX + cos(angle) * width; //move in x direction
    let rayY = centerY + sin(angle) * height; //move in y direction
    
    stroke(sunRayColors[int(random(sunRayColors.length))]); //picks a random color
    strokeWeight(random(4, 8))
    line(centerX, centerY, rayX, rayY);
  }
}

Reflection and future improvement:

It was pretty fun and challenging doing this assignment and trying to somehow incorporate randomness and arrays into making the rays. I really enjoyed trying to make my art project come close to my inspiration even though I did not fully incorporate everything. So for the future maybe I will try to make it so that another background would show up before it resets, just like the GIF, or implement interactions with the mouse.

Reading Reflection – Week#2

How are you planning to incorporate random elements into your work?

I really like how I incorporated randomness into my own work. I feel like making my art project have random color and shapes makes it more visually appealing and it makes it look more vibrant. In my lighthouse project, I integrated random stroke weights and colors in the background to represent how light dynamically illuminates the beach. This randomness supports the theme, but too much in my opinion could make the artwork unclear. While randomness adds energy, some structure is needed to keep the message strong or else it becomes too overwhelming.  

Where do you feel is the optimum balance between total randomness and complete control?

The best balance between randomness and control depends on how much structure is needed to keep the artwork clear while still feeling dynamic. In my lighthouse piece, I use random stroke weights and colors to show how light spreads, but I keep the lighthouse itself structured to maintain focus. Too much randomness would make the image chaotic, while too much control would make it feel lifeless. Casey Reas’ Eyeo talk supports this idea, explaining that rigid systems become static, while too much chaos loses meaning. For me, the key is using randomness in a way that adds energy without taking away from the main idea.