Week 10 Reading Reflection

Reflection on “Physical Computing’s Greatest Hits (and misses)”

In “Physical Computing’s Greatest Hits (and misses),” the complex interplay between user interaction and physical computing physics is masterfully broken down. The article examines the ways in which different initiatives seek to build a connection between digital response and human engagement. The investigation of technologies that aid in meditation strikes me as particularly noteworthy. Being a tech and mindfulness fan, I find it fascinating and a little frightening that an essentially qualitative experience can be quantified. Are these devices making the spiritual journey better, or are they just turning it into a set of numbers? This query calls for a more thorough examination of technology’s place in settings that are often designated for pure human experience.

“Digital Wheel Art,” another noteworthy initiative that was highlighted, demonstrates how technology may democratize the creation of art, particularly for people with restricted mobility. It serves as a sobering reminder that technological accessibility is a bridge to equality and self-expression rather than merely a feature. This, together with the creative Sign Language gloves, strengthens my conviction that technology, when used carefully, can serve as a potent force for inclusion rather than just serving a practical purpose.

These illustrations highlight a more general insight that was brought to light by the reading: interactive installations are more than just impressive technical feats; they also reveal human stories and arouse feelings. Therefore, interactive art’s value lies not only in its technological prowess but also in its capacity to speak to our common humanity and elicit a wide range of emotions.

Reflection on “Making Interactive Art: Set the Stage, Then Shut Up and Listen”

With regard to the function of the artist in the age of interactive media, “Making Interactive Art: Set the Stage, Then Shut Up and Listen” presents an interesting perspective. According to the reading, interactive art ought to be a conversation rather than a monologue—a platform for engagement rather than only observation. This speaks to me, especially when it comes to the fear that an artist may have that their creations would be misinterpreted or inappropriately used. The act of giving up control and letting the audience add their own interpretations to the work is evidence of the transformational potential of art.

The spectrum of engagement that creators struggle with is highlighted by the tension between interaction and set narrative, such as that seen in video games or visual novels. These media contest the idea that interactive equals natural, unscripted experiences, proposing instead that the audience’s interpretation and the artist’s intention are complementary elements of a nuanced dialogue.

Thinking about this makes me wonder about the fine line that all artists have to walk. In order to create an environment where art and audience can collaboratively generate meaning, curation involves more than just designing the experience. It also involves managing the lack of direction. It’s a subtle, yet audacious, gesture of faith in the audience’s ability to connect with the work of art, giving each encounter a distinct personality. My comprehension of interactive art has grown as a result of this study, and I now have a greater respect for the bravery and vulnerability that these works of art require.

Week 10 Assignment – light sensor

This projects concept is related to automatic lights, where a sensor detects the amount of light in its surroundings and according to it, it switches lights on and off. So for this assignment, I decided to implement this technique:

This is the code that I used to implement this method:

int photoSensorPin = A0;
int buttonPin = 2;
int ledPin1 = 9;
int ledPin2 = 10;
void setup() {
  pinMode(photoSensorPin, INPUT);
  pinMode(buttonPin, INPUT);
  pinMode(ledPin1, OUTPUT);
  pinMode(ledPin2, OUTPUT);
void loop() {
  int sensorValue = analogRead(photoSensorPin);
  int buttonState = digitalRead(buttonPin);
  if (buttonState == HIGH) {
    digitalWrite(ledPin1, LOW);
    digitalWrite(ledPin2, HIGH);
  } else if (sensorValue < 512) {
    digitalWrite(ledPin1, HIGH);
    digitalWrite(ledPin2, LOW);
  } else {
    digitalWrite(ledPin1, LOW);
    digitalWrite(ledPin2, LOW);


Week 9 Assignment – Unusual Switch – Cheers


I first thought that it would be hard to find a case to switch the light bulb on without my hands but then the inspiration came to me when my friend sent me this emoji: 🥂. So I thought I could use water bottles to connect the circuit and switch on the light bulb. Which resulted in this:


    • A 330-ohm resistor
    • 1 LED light
    • A breadboard
    • One red and two black jumper wires
    • An Arduino board with a 5V and GND output
    • Cooper tape
    • Water bottles

Process and Results

Assignment 6 (Week 8a) Reading Reflection

Margaret Hamilton’s narrative is more than just a historical anecdote; it’s a demonstration of the strength of fortitude, cunning, and vision in the face of personal and professional obstacles. Hamilton’s path covers a substantial progression in both her personal life and the area of technology itself. She started out as a young mathematician supporting her husband’s career and ended up being a trailblazing software engineer whose work was essential in bringing people on the moon. In spite of the 1960s social conventions discouraging women from pursuing “high-powered technical work,” Hamilton’s commitment and enthusiasm enabled her to create the contemporary notion of software. This story is interesting because it shows how important software was to the Apollo missions and how it became an essential part of current engineering and technology.

On a personal level, Hamilton’s narrative is tremendously motivating, particularly for someone navigating the complexity of contemporary technology disciplines. It serves as a reminder that prejudice and borders are frequently merely social constructions that are ready to be destroyed by anyone with the guts to question them. Hamilton’s commitment and tenacity inspire me to persevere in the face of adversity and to recognize the worth of hard effort and creativity in my own life. Her ability to manage her responsibilities as a mother and a top engineer in a field that is dominated by men forces me to reevaluate my ideas of what is possible and to pursue greatness against social norms. Her narrative inspires me to follow my goals with utmost fervor and to help break down barriers in technology and other industries, much as Hamilton’s work on the Apollo software did.

The reading “Attractive Things Work Better” explores how important aesthetics are to a product’s usefulness and efficacy. It clarifies how emotional reactions and cognitive processes are connected, implying that appealing products are not only more user-friendly but also have the potential to improve problem-solving and complicated task navigation skills. This idea contests the traditional division between form and function, contending that the two are complementary rather than mutually exclusive. The story suggests that aesthetics have a big impact on usability, transforming boring jobs into delightful experiences that boost productivity and efficiency.

This idea strongly connects with my personal experiences and observations. I’ve discovered how much aesthetics and design influence how I engage with and am satisfied with commonplace items and digital interfaces. For example, a smartphone’s slim form and user-friendly interface not only enhance its visual appeal but also revolutionize its usability by rendering complicated tasks seeming easier and more approachable. I have always thought about this as a child, where all these tasks we do using our smart devices seem so helpful and easy. As I think about this, I see how important it is to include aesthetic elements in my own efforts. The reading’s guiding ideas inspire me to think about how aesthetics and utility may work together to provide more satisfying and productive experiences, whether I’m developing a website, creating a presentation, or even just setting up my workstation.

Midterm Project – Rotten Rescue


The initial concept of this game was to be something different and unusual of the games that we already see where the “good” item is collected and the bad item is supposed to be avoided. But since I am using apples, I decided to relate this a bit to physics and the Isaac Newton apple incident that led to him discovering gravity… This makes the game more interesting and leaves a chance to improve it and make it a bit educational as well.

Full screen display of the game: https://editor.p5js.org/jana_mohsen/full/jEKauH5OR



In this game, players maneuver a trash can to catch rotten apples while avoiding the clean ones. The game is structured into several screens: an introduction, instructions, the main game, and a game-over sequence. There are multiple classes used like the Apple Class that regulates both the types of apples, the Trashcan Class which ensures the moevments of the trashcan on the horizontal axis and lastly, the Bubbles Class which is just used to regulate the number, size and speed of apples that are being displayed in the game over page.

The most important part of the code are the functions for each page of the game. The (displayIntro()) function displays the introduction page, which greets with the player with the game title and a start button. Then the second function: (displayInstructions()) teaches the player the “how-to-play” guidelines, respectively, with options to start or proceed to the game. It also allows the player to input the game before starting to play.

During the active game phase, apples of two types—“clean” and “rotten”—descend from the screen’s top. Players control the trash can, moving it left or right to catch rotten apples while avoiding the clean ones. The game keeps score and includes a countdown timer, enhancing the challenge. It manages the player’s interaction with the game through the trash can’s movements when they press keys, allowing the player to move the trash can left or right to catch falling apples, facilitated by the trashCan.display() and trashCan.move() methods.

Within its cycle, runGame() also takes charge of spawning new apples at fixed intervals, alternating between “clean” and “rotten” types, which are then added to an array for tracking. As time progresses, it continuously updates the player’s score by incrementing by 10 based on the type of apples caught and counts down the game timer, implementing a sense of urgency and challenge. The function diligently checks for end-game scenarios, such as the depletion of the timer or accumulation of too many clean apples, transitioning to a game-over state if any conditions are met. Moreover, within this loop, each apple’s position is updated, and its status is checked to determine if it has been successfully caught by the trash can or missed. Apples that are caught or fall off the screen are removed from the gameplay loop, ensuring the game’s state remains current.

When the game ends, either from catching more than 2 clean apples or because the timer ended, the game trasitions to a game over page where the players final score appears. Finally, the game employs a “bubble” effect on the game-over screen for visual appeal, where bubbles generated by the createBubbles() function move around the screen.

Challenging part: 

The most interesting and challenging part of this game is creating the logic behind it. The rest is just assembling buttons, images and creating a nice aesthetic to the game.

function runGame() {
  // Set Instruction.jpeg as the background
    image(imgInstructions, 0, 0, width, height); 

  // Displays score and timer at the top left

    // Logic for apples falling and being collected or missed
    if (frameCount % 60 === 0) {
        let type = random(['clean', 'dirty']);
        apples.push(new Apple(type));

    for (let i = apples.length - 1; i >= 0; i--) {

        if (apples[i].y + apples[i].size > trashCan.y && apples[i].x > trashCan.x && apples[i].x < trashCan.x + trashCan.width) {
            if (apples[i].type === 'dirty') {
                score += 10;
            } else {
                if (redApplesCollected >= 3) {
                    currentPage = 'gameOver';
                  // Create bubbles for game over animation
          // Remove collected or missed apple from array
            apples.splice(i, 1); 
        } else if (apples[i].y > height) {
          // Remove apple that falls off screen
            apples.splice(i, 1); 

    // Timer countdown and check for game over condition
    if (frameCount % 60 === 0 && gameTimer > 0) {
    } else if (gameTimer === 0) {
        currentPage = 'gameOver'; // Time's up
        createBubbles(20); // Prepare game over screen

    // Drawing and positioning Start Over and Back buttons

The main issue of the project was developing the logic for this game, which proved to be the most major challenge during development. The complex interactions between the various components of the game—like the falling apples, the moving garbage can, and the score system—needed to be carefully thought out and executed. To guarantee seamless gaming and compliance with the game’s regulations, the logic controlling the game’s behavior has to be strong and effective. In order to guarantee precise and reliable performance, handling edge circumstances such as identifying collisions between apples and the trash can or controlling the game’s timing required careful coding and testing.

The code consists of many parts. The trashcan is displayed and moved by the function in response to the players key press. It also shows the amount of game time left and updates the player’s score. The reasoning behind the apples falling is the most important aspect of the function. At regular intervals, it produces red apples, randomly classifying them as normal or rotten. The apple array is then iterated over, with each apple being moved and displayed as the program looks for collisions with the trash can. If an apple is detected, the apple is taken out of the array and the score is changed appropriately. On the other hand, if an apple is missed, it is removed, and if the player has missed too many and it is rotten, the game ends. Lastly, the function controls the game timer, which starts a countdown every second and enters the game over state when the allotted time is up. It also draws and arranges buttons so that you can go back to the main menu or resume the game. In order to create a compelling gaming experience, this function coordinates the interplay between game objects and player input, encapsulating the fundamental gameplay logic.

Limitations and improvements:

The game can have better ways to make it a bit competitive like adding a high score board to show the scores of all the players. Moreover, the amount of apples is random so it might be unfair between players since one can have 10 rotten apples and another only 5. All of these issues are seen as parts to be improved to make the game more appealing and competitive.

Game visuals: 

Introduction page:

Instructions page:

Game page:

Game over page:

Assignment 5 – Midterm Progress


I am creating an interactive game that revolves around collecting rotten apples in a trash can. What inspired me to do this is that most games always make you collect the “good” items and leave the “bad” items out of the box. So, I flipped this norm that we always see in kids games and I am now collecting rotten apples (bad item) and leaving the good apples (normal items). There is no specific game that inspired the apple catching game but I just thought about using an apple since apples fall from trees so it makes sense that they are falling from the sky and can be collected.


There are normal apples falling from the sky and rotten apples. The purpose of this game is to try to collect as much rotten apples into the trash can as possible. The trash can is in the bottom of the canvas and can move horizontally to catch the falling rotten apples. There is a score that is being incremented by 10 every time a rotten apple is collected in the trash can. For the design of the trash can and the apples, I uploaded pictures of a trash can and pictures of apples to make the aesthetics of this game better. I still did not design the “start” page yet but I will also be uploading pictures to make it look aesthetically pleasing. In terms of sound, I am aiming to add background music just like kids games and also a sound for every time an apple is caught in the trash can. Since the game is still in progress I did not add it to this post.


I think what will make this project interesting is adding timer to the game so that the player has limited time to collect the apples. Also I think being able to ask for a players name in the beginning and then add it to an array that holds their name and score can make this a more competitive game so when the game ends the player can see what position he has compared to his friends. I also need to add a function that allows the player to start over the whole game and go back to the home page or only start over the game without having to go to the home page. I also thought power ups can make this game more interesting but I do not know if I can achieve that yet. Lastly, I need to make the screen be as big as possible (take as much of the screen as  possible).


The images that are uploading have a white background, so, if the background is any other color than white, the frame of the image will show and it is not aesthetically pleasing. Also the apple randomizer might make the game unfair because you never know how many rotten apples you will get in the span of your turn. Another player might get more rotten apples in the screen, thus, a better chance to get a higher score. Another limitation is that the apple images might be confusing because they are small and some players might get confused between the rotten and good apple. I obviously will be working to reduce these limitations and make this game as good as possible.

Assignment 5 – Reading Reflection

It is quite thought-provoking to examine how technology is dual in nature in both art and surveillance. The books explore the philosophical and ethical implications of technology’s development, emphasizing how inventions that were first created for beneficial and creative uses might later be transformed into instruments for widespread control and surveillance. This contradiction is best illustrated by the way that facial recognition has evolved from a scientific marvel to a possible tool for privacy invasion. This should cause readers to consider the wider effects of technology progress. Furthermore, a rich field for discussion on the nature of observation and the hazy boundaries between watcher and watched is provided by the irony in works of art that criticize surveillance by using surveillance techniques themselves. This dichotomy challenges readers to consider the social values that influence technology advancement as well as the motivations behind it.

These thoughts resonate with my own experiences and opinions on technology on a personal level. Just as I was astounded when I was a child and could talk to distant relatives via video chats, I have always been in awe of the advances made possible by digital innovation. However, this nostalgia is now flavored with a cautionary tale about the invisible eyes that could be hiding behind any gadget. I’ve been forced by the reading to reevaluate how I use technology and to acknowledge the fine line that separates convenience from invasion. It speaks to my growing knowledge of privacy issues and the covert, frequently undetectable methods that I could be monitored. The aforementioned artworks function as a reminder of the ubiquitous nature of monitoring and the necessity of maintaining awareness of the trade-offs between the advantages of technology and individual privacy. My grasp of the societal effects of technology has grown as a result of this thinking, which has also motivated me to handle my digital imprint more carefully.

Assignment 4 – Reading Reflection

The excerpt from Don Norman’s “The Design of Everyday Things” offers a perceptive look at the psychology of commonplace objects and their designs. In his discussion of frequent problems with doors, light switches, and technology, Norman highlights the significance of design features like affordances and signifiers. He contends that effective design should be intuitive, enabling people to utilize a product without the need for manuals, mostly by means of obvious and sensible hints included into the design itself.

When I think about it, Norman’s emphasis on user-friendly design resonates even more. From my own experience, I have come across a lot of non-intuitive products and interfaces, which has caused annoyance and mistakes. I’m more conscious of the importance of user-centered design now that I’ve read this, and it’s inspired me to think about how the systems and items around me may be made clearer and easier to use. Norman’s concept of “affordances,” which refers to the potential interactions between people and their surroundings, has altered my understanding of how products should be made to fit naturally with human use rather than requiring users to adjust to complicated or counterintuitive systems.

Assignment 4 (production 4) Word Search

The concept of this assignment is a word search. I was inspired to do this because of how much I help my younger brother with his word search activities at home. So I immediately started working on the idea.

I started y creating a grid and then have randomized letters in the grid. There are three specific words that you need to find: “WOW” “FUN” “CAT”. Obviously there are more extra and bonus words that you will find in the grid. The process was long but this is what I ended up with. Please mouse click on the letter that you want to highlight:

A big part of the code that I am proud, which was the most challenging part is the WordGrid Class that I created to have many different functions.

class WordGrid {
    // Constructor 
    constructor(gridSize, cellSize) {
      // Number of cells along one edge of grid 
        this.gridSize = gridSize; 
      // Size of each cell in pixels
        this.cellSize = cellSize; 
        this.words = ['FUN', 'WOW', 'CAT']; 
      // Initialize grid layout
        this.grid = this.initGrid(); 
      // Place words in the grid
      // Fill empty spaces in grid

    // Initializes grid with empty values.
    initGrid() {
      // Array to hold grid data 
        let grid = []; 
      // Iterate over each row 
        for (let i = 0; i < this.gridSize; i++) { 
          // Initialize an empty row
            grid[i] = []; 
          // Iterate over each column in row
            for (let j = 0; j < this.gridSize; j++) { 
      // Set each cell to default state with no letter and not colored
                grid[i][j] = { letter: '-', colored: false };
        return grid; 

    // Places words from 'words' array into grid 
    placeWords() {
        // Iterate over each word and its index in the array
        this.words.forEach((word, index) => {
    // Calculate row number based on word's index to space out words
            let row = index * 2; 
            // Place each letter of the word into grid.
            for (let i = 0; i < word.length; i++) {
       // Set cell at calculated row and current column to letter of word
                this.grid[row][i] = { letter: word[i], colored: false };

    // Fills empty cells of grid with random letters
    fillGrid() {
        // Iterate over each cell in grid
        for (let i = 0; i < this.gridSize; i++) {
            for (let j = 0; j < this.gridSize; j++) {
                // Check if cell is empty (marked by '-') 
                if (this.grid[i][j].letter === '-') {
                    // Set the cell to random letter
                    this.grid[i][j].letter = this.getRandomLetter();

    // Returns random letter from the alphabet
    getRandomLetter() {
      // String containing all letters 
        const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; 
        // Return random letter from alphabet string 
        return alphabet[Math.floor(Math.random() * alphabet.length)];

    // Toggles color state of specific cell
    toggleCell(row, col) {
        // Check if cell contains a valid letter (not '-')
        if (this.grid[row][col].letter !== '-') {
            // Toggle 'colored' state of cell
            this.grid[row][col].colored = !this.grid[row][col].colored;

    // Draws grid on screen
    draw() {
        // Iterate over each cell in grid
        for (let i = 0; i < this.gridSize; i++) {
            for (let j = 0; j < this.gridSize; j++) {
              // Set fill color based on cell's 'colored' state
                fill(this.grid[i][j].colored ? 'red' : 255);
                // Draw border around cell 
                // Draw cell as rectangle
                rect(j * this.cellSize, i * this.cellSize, this.cellSize, this.cellSize);
                // Set fill color for text (letter) to black
              // Align text to center of cell and draw letter
                textAlign(CENTER, CENTER);
                text(this.grid[i][j].letter, j * this.cellSize + this.cellSize / 2, i * this.cellSize + this.cellSize / 2);

initGrid(): This function creates a two-dimensional array with objects that correspond to each cell in order to set up the grid’s basic structure. At first, I had trouble seeing the grid as an arrangement of objects instead than just letters or empty spaces. But structuring every cell as an object with letter and color characteristics made managing the state of the grid more adaptable.

placeWords(): It was difficult to arrange the words on the grid, especially to make sure they matched and did not overlap. Every word in this condensed form is arranged horizontally and separated by rows. This function established the foundation for comprehending how words interact with the grid, even though the true problem lay in creating more sophisticated placement algorithms.

fillGrid(): To finish the setup of a standard word search puzzle, random letters had to be placed into the remaining vacant cells of the grid. This method iterates across the grid, substituting random letters for unassigned cells. It filled all the cells that had “-” instead of letters of the words that we placed in the grid.

getRandomLetter(): This function selects a letter at random from the alphabet. It fills in the blank cells in the grid, completing the word search problem and enabling gameplay. It’s a little but essential component of the code. It works directly with the function before it.

toggleCell(row, col): The requirement for grid interaction made this function difficult to implement. Users can choose which cells to change color by clicking them. The gameplay revolves around this interaction, which lets players highlight words they come across.

draw(): Lastly, the draw method gives the word grid a visual representation of each cell’s condition, bringing it to life. For the game to be visually appealing and functional, it was essential that every cell’s content—a letter—and state—colored or not—be shown clearly.


There are a couple of limitations for my assignment though. First of all the function that places the words in the grid is placing them all horizontally and under each other which makes the word search game less interesting. Moreover, I only chose three words all with three letters only which again makes this game easy and will end fast. From the technical side, you are required to press on every letter of the grid when you find a word which makes it harder and less appealing to play the game. Making it more realistic like striking through the letters when the correct word is found will make the game more realistic and more appealing to the player. However, overall, I think I did a good job with the representation of the grid and creating a separate  file for the WordGrid class to make the code more organized.


Week 3 Reflection

As I consider the various viewpoints that the text have presented on the topic of interaction, I find myself drawn to the complex dance that takes place between user input and system response. Fundamentally, interaction is a dynamic exchange in which the user and the system participate in an ongoing cycle of input and feedback. This link forces us to reevaluate how we engage with commonplace items and technology, as well as how we understand interactive media.

As the reading demonstrates, the notion of interactivity encompasses more than just user participation; it also refers to a more profound and significant conversation between people and technology. It challenges us to reflect on the nature of our interactions, asking us to take into account not only the mechanics but also the purpose and result of these exchanges. Echoing the observations of my peers, I find the subjective character of interaction and the way it adjusts to the capabilities and requirements of its audience to be quite fascinating. This flexibility emphasizes how important careful design is to making experiences that appeal to a wide range of users and are both accessible and meaningful. Furthermore, the classification of interactive media into low, medium, and high levels of interaction provides a helpful framework for analysis. From the straightforward act of clicking a button at a pedestrian crossing to the intricate conversation with AI chatbots, it enables us to classify and assess interactions based on their depth and complexity. Every degree of interactivity presents different difficulties and chances for participation, highlighting the need for a sophisticated approach to interactivity design.

To sum up, the contemplations and illustrations presented throughout the class discussion enhance our comprehension of interaction. They force us to think about how our designs and interactions affect society more broadly, highlighting the importance of approaching interactive media with consideration and user-centered design. Our conceptual framework is expanded by this investigation, which also motivates us to innovate and push the limits of interactive design.