Reading Reflection – Week 8

The reading “Emotion & Design: Attractive Things Work Together” presents a compelling argument about the interplay between emotion, design, and usability, particularly emphasizing that attractive things work better. This resonates with my own experiences and observations in various contexts, such as product design and user interfaces. For instance, I have noticed that when using a software like a food delivery app with a visually appealing interface, I tend to feel more satisfied with the experience, even if the functionality is similar to less attractive alternatives.

On the other hand, the reading “Her Code Got Humans on the Moon” has shifted my perspective on the historical significance of software engineering. I had previously viewed software as a more modern development, but the article illustrates how foundational work was being done as early as the 1960s. Additionally, the reading raises several questions for me. How did Hamilton’s experiences as a working mother in a male-dominated field influence her approach to software development? Furthermore, how can we ensure that the contributions of women and other underrepresented groups in technology are recognized and celebrated in contemporary narratives? These questions highlight the need for a more inclusive history of technology that acknowledges diverse contributions.

Midterm – Interactive Zoo

Concept

I created an interactive zoo-themed game where players get to dive into the fun of feeding different animals. The game features a variety of enclosures, each housing unique animals like a Lion, Elephant, Giraffe, and Bear, along with their distinctive images and sounds. The main goal is to correctly feed each animal their preferred food while managing a limited number of attempts. It’s all about exploring the zoo, having fun, and seeing how well you can feed the animals! The gameplay is designed to be engaging and straightforward. Players drag and drop food items into the enclosures, trying to match the right food with the right animal. It’s a lively experience that captures the excitement of a day at the zoo while keeping players entertained and challenged.

What I’m proud of the most is how the zoo home looks like:

Code Snippets

I’m proud of the code for the feedback system; it plays distinct sounds for correct and incorrect food choices, while also displaying visual messages. This helps the player learn from their mistakes in real time.

checkFood(chosenFood) {
  if (chosenFood.name === this.correctFood) {
    correctSound.play(); // Play the correct sound if food is right
    correctFeeds++; // Increment correct feeds count
    gameWon = (correctFeeds === zoo.length); // Check if all animals have been fed correctly
    showCorrectMessage = true; // Show correct message

    // Stop the sound for the current enclosure
    for (let enclosure of zoo) {
      if (enclosure.name === currentEnclosure) {
        enclosure.stopSound();
      }
    }
  } 
    else {
    wrongSound.play(); // Play the wrong sound if food is wrong
    lives--; // Decrement lives
    
    // Check for loss condition
    if (lives <= 0) {
      gameOver = true; // Set gameOver to true if lives reach zero
    }
  }
 }

Another code snippet I’m proud of is the mousePressed function because it lets the player easily move from the instruction screen to exploring the zoo, and if they win or lose, it resets everything for a fresh start. The way it checks if an enclosure was clicked and responds to player actions keeps the gameplay fluid and intuitive, making it simple for anyone to jump in and play without getting stuck.

function mousePressed() {
  if (instructionScreen) {
    instructionScreen = false; // Exit instruction screen when clicked
  } else if (gameOver || gameWon) {
    // Reset game state and go to instruction screen
    lives = 3;
    correctFeeds = 0; // Reset correct feeds count
    gameOver = false;
    gameWon = false;
    instructionScreen = true; // Reset to instruction screen
    currentEnclosure = null;
    for (let enclosure of zoo) {
      enclosure.stopSound();
    }
  } else if (currentEnclosure === null) {
    // Check if an enclosure is clicked
    for (let enclosure of zoo) {
      enclosure.checkClick();
    }
  } else {
    // Reset showCorrectMessage for the next animal
    showCorrectMessage = false;
  }

The Good Parts

The game runs on a combination of object-oriented programming and easy-to-understand mechanics. Each animal enclosure is an instance of the Enclosure class, complete with its own attributes like size, name, images, sounds, and the specific food it needs. Players simply drag and drop food items into the right enclosures, and the game gives instant feedback on whether they made the correct choice or not.

I’m really proud of how I integrated audio into the game. Each time players make a correct or incorrect choice, they hear distinct sound effects that add a fun layer to the experience. Plus, I included on-screen messages that help players understand what they did right or wrong, making it easy to learn and improve. I also love how the design encourages players to explore different enclosures and challenges, creating a loop of fun that keeps them engaged. The restart feature is a nice touch too, allowing players to jump right back in if they want to try again after finishing a round.

The Not So Good Parts

Even though I’m happy with how the project turned out, there are definitely areas where I could improve. For instance, the user interface could use a bit more flair to make it visually appealing. Sprucing up the background and button designs would enhance the overall experience. I also want to fine-tune the drag-and-drop mechanics to make them even smoother, as some players might find it tricky to place the food just right.

During the development process, I faced a few challenges along the way. One significant issue is that there are still some bugs that I didn’t have time to fix. For example, players can exploit a loophole where feeding the same animal the correct food four times counts as a win, which isn’t the intended gameplay experience. Additionally, if players don’t drag the incorrect food item away before placing the correct one, both the correct and wrong sounds will play simultaneously, which can be confusing. I also noticed that the food items tend to stick together when they touch, almost like magnets, which adds an unintended dynamic to the dragging mechanic. However, when players switch to another enclosure, the food items reset as intended, which is a positive aspect. These challenges highlighted the importance of thorough testing and debugging, and I plan to address them in future iterations of the game.

Reading Reflection – Week 5

Reflecting on the reading “Computer Vision for Artists and Designers,” it’s clear that computer vision techniques have found a meaningful place in the world of art. The text highlights a variety of artistic applications, showcasing everything from abstract creations to works addressing sociopolitical themes. Golan Levin does a great job of illustrating this diversity by mentioning numerous artists and their projects that incorporate computer vision, which really underscores the potential of this medium.

When it comes to how computer vision differs from human vision, the distinctions are pretty significant. While our visual system is adaptable and can interpret a wide range of visual stimuli effortlessly, computer vision is limited by its programming and the specific conditions it can handle. Unlike us, computers can’t easily generalize or grasp context, which are essential parts of how we see. Lastly, the potential for tracking and surveillance through computer vision has a mixed impact on interactive art. On one hand, it opens up new avenues for artists to engage audiences and create immersive experiences. On the other hand, it raises important privacy concerns and the risk of misuse in monitoring behavior. In the end, artists need to find a careful balance, using computer vision to explore their creativity while also being aware of ethical concerns.

Midterm Progress Report

Concept: For my midterm project, I created an interactive zoo where users can virtually visit different animal enclosures and experience their sounds in a visually engaging way. The idea behind the project is to give users a simple, intuitive interface to explore various animal exhibits within a zoo environment. The user can click on an enclosure to hear the animal and see a more detailed visual of it.

Frightening Aspect: One of the key challenges I faced was managing sound playback. If I don’t handle this properly, sounds could overlap or continue playing when I switch enclosures which would make the experience messy.

Risk Management:

  • I added stopSound to stop the sound when I leave an enclosure. This makes sure that as soon as I press ‘R’, the sound for the current enclosure stops, avoiding any overlap with future sounds.
  • When I press ‘R’ to return to the zoo home screen, I use a loop to stop all the sounds from the enclosures. This guarantees that no sound continues playing when I leave an enclosure.

Reading Reflection – Week 4

Norman’s idea behind how design should be approached is compelling. Indeed, when designing a product, you need to create it with human behavior in mind because humans are going to be the consumers of your product. This might sound obvious, but in reality, engineers do not consider it. This becomes clear when you look at Norman’s examples in his book. Reading through them felt very validating; finally, someone understands the frustration that comes with bad design.

An example of something that frustrates me that Norman didn’t mention is air conditioning. Back at home, we have this AC controller embedded in the wall that has many buttons and symbols, and none of them make sense. There is no signifier to tell what each button does, and the symbols are vague and arbitrary. The only buttons I know how to use are the temperature and fan. So much of the extra effort by the engineers and the cost of the unusable buttons is wasted because of unclear design. The overall design could be improved if there were signifiers to dictate what each button does or streamlining the settings to make it more simple and clean.

Week 4 – Generative Text

Concept: I really liked the example of using generative text to make poems so I decided to apply a similar approach to stories instead. The story randomly generates by pressing the mouse.

Code: The code I was proud of is that I found a way to simplify the example in the lecture notes. I did that by splitting the data once in setup to make things clearer then I used trim so any accidental extra spaces in the data is removed.

function setup() {
  createCanvas(500, 500);
  textAlign(CENTER);
  textFont('New Courier')
  
  // Split into different categories
  characters = split(words[0], ',');
  actions = split(words[1], ',');
  objects = split(words[2], ',');
  settings = split(words[3], ',');
  
  generateStory();
}
function generateStory() {
  let character = trim(random(characters));
  let action = trim(random(actions));
  let object = trim(random(objects));
  let setting = trim(random(settings));

Reflection and improvements: I really am proud of how things turned out. I wish I could have added more to the sketch to make it more entertaining. For example, I could replace the ellipse with a book to make it seem like the story is written on it.

Week 3 – Object-Oriented Programming

Concept: I wanted to create an interactive art piece while challenging myself code-wise. I settled on a little game of popping balloons. I used class to make the circles. I also randomized colors from a set of specific colors in an array. The interactive part of the art is when a circle is clicked, it disappears, giving the popping effect.

Code: I’m specifically proud of this line of code because I used the not condition to check whether to continue growing based on a mouse click.

grow() {
    if (!this.clicked) { // Only grow if not clicked
      this.radius += this.growthRate;
      if (this.radius > this.maxRadius) {
        this.radius = this.maxRadius; // Capping the radius
      }

Problems: A problem I faced was having the circles overlap the text, hiding it from sight. Another one was needing to refresh the sketch to repeat the art. I wish I could have implemented a way that when all balloons are popped, it regenerates them by itself.

 

Reading Reflection – Week 3

Crawford argues that big ideas are elusive and hard to capture in a sentence-long definition, and I agree. However, he then proceeds to do this and limit what can be considered interactive. He argues that books, movies, and performance art are not interactive, but I beg to differ. Consider a choose-your-own-adventure movie or book; is this not regarded as interactive? One could argue that Crawford’s book was published in the early 2000s, so he might not have heard of such media. Yet those interactive forms, specifically books, were famous in the 90s.

Another example that he fails to consider is stand-up comedy. The comic interacts with the audience, listening, thinking, and speaking, all of which Crawford states are part of an interactive piece. Add to that, many of the jokes in a set come from the ability of the comic to improvise based on the audience, further proving the point that performance art is interactive. Putting that aside, I agree with him that interactivity relies on good listening, thinking, and speaking. This could be applied to p5 by implementing real-time feedback mechanisms that respond to user input—for example, having the sketch change based on whether the mouse is pressed.

Week 2 – Art Piece

Concept: It took me a while to decide on what to create. I had so many ideas but couldn’t implement them without very complicated code that I didn’t understand. I decided to make the following art piece, using the for loop, inspired by the Olympics logo since I’ve been watching it recently.

Code: I was proud of figuring out how to randomize the colors by making it choose randomly any value between 0-255 for red, green, and blue.

stroke(random(255), random(255), random(255));

Reflection and ideas for improvements: I wish I could make the stroke choose out of a set of specific colors instead of choosing randomly because some colors aren’t that appealing. Having a certain color scheme might help make it look more pretty.

Reading Reflection – Week 2

Casey Reas’s talk on chance operations made me reflect on an issue I deeply care about, AI art. As an aspiring artist, seeing how far AI has come truly worries me about the future of this field. One can argue that AI can never take over art because the human touch and emotion cannot be replicated. However, when randomness is introduced to art pieces, what is the line that divides what is human and what is AI? If an artwork primarily uses randomness, does that make it AI? What about replication? Would having more chance elements in a piece make it easier or harder for AI to replicate?

I believe that randomness has value, yet I can’t help but wonder whether the artists who have designed these chance art pieces have thought of the implications of their work. Sure, at the end of the day, the person is creating the code and setting the limits for randomness, but what happens afterward, the actual conception of the work, is out of their hand. Using that logic, one could argue that the artwork isn’t original. In my own work, I’m not against using randomness, but I will limit it to simple things like choosing color or text from a certain array. That makes an art piece more human; therefore, I believe the optimum balance is having more control than randomness.