Luke Nguyen – Week 10 Reading

I was particularly fascinated by the Gloves section in the Physical Computing’s Greatest Hits reading. It is interesting to learn how engineers created the gloves that could respond to the movements of fingers to make rhythm; I wondered how they created and programmed the force-sensing resistors so that when attached to the fingertips, these sensors would know what kinds of triggers to create according to how strong the forces are. A few years ago, I was amazed at how Ariana Grande could control music with her gloves during her Honeymoon Tour in 2015. Here are a few videos of the way she did it: video 1, video 2. After doing some research, I discovered that she was using the Mi.Mu Gloves developed by MI.MU GLOVES LIMITED (UK) which enables music through movement as the company advertised. During her tour, Ariana used the motions and forces of her gloved hand gestures to add effects to her live performances, for example: holding up one finger to add harmony, opening her palm to add major-sounding harmonies, etc. I didn’t know back then that this technology is called physical computing; it was physical computing that enabled her to do this. In retrospect, it is amazing how physical computing has opened up countless opportunities for musicians to create and control their music both in studio and live environment. This glove technology is a mega hit to them.

I resonate with the author’s point in the second article “Making Interactive Art: Set the Stage, Then Shut Up and Listen”. I think artists’ intentions while making the interactive artworks are important but the audience’s experience is equally important as well. Most of the time when I see an interactive artwork, it is interactive in itself but not to the spectators, which I find to be rather frustrating. One time when I was visiting the Museum of Natural Science, there was a very awesome exhibition about nature that I remembered till this day. The exhibition was showcased in a sphere. When visitors stepped inside, they would directly interact with the elements of nature through their feet. One would step on the elements, for example, water, leaves, wind, bubbles, butterflies, etc. to see how they would become interactive. I got no instructions on how to interpret the artwork but I learned how to interact with it purely through interacting with it. I felt alive; I felt that was such a unique experience; the artwork made me want to play with it again and again. In contrast, most of the interactive artworks I had seen before this one were presumably “interactive” but I wasn’t given any opportunity to interact with them. I did not know how to feel viscerally towards what I was observing, which I think made the objects hardly memorable without photography after moving on from them.

Luke Nguyen – Week 10 Assignment – Thanos Snap


Concept & Inspiration:

I thought of Thanos in Marvel Comics while I listened to a song by Beyoncé where he is referenced. Analog versus sensor seems to be a duality that reminds me of the notion of half and half that Thanos is fervent believer of. He believes that if he wipes out half of the population of the universe, he could restore its balance (half-populated and half-empty); fully populated would tip the scale. This assignment is set in that universe. I want the population of the universe to be represented by the number of LEDs; I used 4 LEDs in this case. I would play 2 roles as I operate the circuit: the creator of life and Thanos. To bring “life” to the LEDs, I would use the photocell as the analog sensor. To destroy “life” inside the LEDs, I would use the button as the digital sensor.

Circuit:

Code:

When I touch the photocell (the analog sensor), I would bring “life” to the LEDs by making them turn on. When I press the button (the digital sensor), I would wipe out half of the universe (half of the number of lives) by turning off two pre-determined LEDs. This way, I only have to code in a way so that that is possible.

int led1 = 4;
int led2 = 7;
int led3 = 8;
int led4 = 12;
int brightness = 0;

// the setup routine runs once when you press reset:
void setup() {
  // initialize serial communication at 9600 bits per second:
  Serial.begin(9600);
  pinMode(led1, OUTPUT);
  pinMode(A3, INPUT);
  pinMode(led2, OUTPUT);
  pinMode(led3, OUTPUT);
  pinMode(led4, OUTPUT);
}

// the loop routine runs over and over again forever:
void loop() {
  // read the input on analog pin 0:
  int sensorValue = analogRead(A2);
  int buttonState = digitalRead(A3);

  sensorValue = constrain(sensorValue, 500, 900);
  brightness = map(sensorValue, 500, 860, 255, 0);


  if (brightness > 0){
    analogWrite(led1, brightness);
    analogWrite(led2, brightness);
    analogWrite(led3, brightness);
    analogWrite(led4, brightness);

    if (buttonState == HIGH ){
      digitalWrite(led3, LOW);
      digitalWrite(led4, LOW);
    }

  }

  Serial.println(sensorValue);
  delay(30);  // delay in between reads for stability

}

Challenges and reflections:

My biggest challenge has to do with the coding. I couldn’t figure out how to write the code for both the third and fourth LED, both of which are controlled by the analog sensor and the digital sensor at the same time, in a way that would make them turn on when I touched the photocell and turn off when I pressed the button.

A first few attempts resulted in these 2 LEDs not turning on at all, them only turning on when I was not touching the photocell, them turning on when I touched the photocell but not turning off when I pressed the button.

The commented-out parts are these first few attempts:

void loop() {
  // read the input on analog pin 0:
  int sensorValue = analogRead(A2);
  int buttonState = digitalRead(A3);

  sensorValue = constrain(sensorValue, 500, 900);
  brightness = map(sensorValue, 500, 860, 255, 0);

  // analogWrite(led1, brightness);
  // analogWrite(led2, brightness);
  // analogWrite(led3, brightness);
  // analogWrite(led4, brightness);



  // if (buttonState == LOW && sensorValue > 600 ){
  //   digitalWrite(led3, HIGH);
  //   digitalWrite(led4, HIGH);
  // }
  // else{
  //   digitalWrite(led3, LOW);
  //   digitalWrite(led4, LOW);
  // }


  if (brightness > 0){
    analogWrite(led1, brightness);
    analogWrite(led2, brightness);
    analogWrite(led3, brightness);
    analogWrite(led4, brightness);

    if (buttonState == HIGH ){
      digitalWrite(led3, LOW);
      digitalWrite(led4, LOW);
    }

  }
  // else{
  //   if (buttonState == LOW ){
  //     digitalWrite(led3, HIGH);
  //     digitalWrite(led4, HIGH);
  //   }
  //   else{
  //     digitalWrite(led3, LOW);
  //     digitalWrite(led4, LOW);
  //   }
  // }

  Serial.println(sensorValue);
  delay(30);  // delay in between reads for stability

}

 

Luke Nguyen – Week 9 Assignment – Lantern

 

 

Concept & Inspiration:

It’s during Ramadan and I wanted to capture the spirit and create something inspired by the month. I was working in the majlis room available in the Baraha area in C2 and I found this lamp stashed in the room corner. When I picked it up and opened the door, I noticed there was no light inside. It gave me the idea of putting a light in there with this assignment.

Circuit:

 

Demo:

Since the requirement of the assignment is creating an unusual switch that uses no hand, I thought of the idea that when the door is closed, the light will turn on. The body of the lamp besides the glass is made of metal material so it should transmit electricity almost everywhere on the surface. Taking advantage of this, I rigged the circuit inside the lamp and arranged of the placement of 2 jumper wires so that when the lamp’s door is closed, the circuit is closed and the LED will turn on thanks to the current running through it.

I created the entire circuit outside of the lamp, estimated the number of jumper wires I would need, then rigged/taped the circuit inside later though.

Challenges and reflections:

Initially, I planned to attach the 2 jumper wires in a way that when the door is closed, they would close the circuit. But that was not possible all the time because of the tape. So I took advantage of the material which the surface of the lamp is made of instead. The point is as long as their is a current running through the LED. Other than that, taping the entire circuit inside the lamp took a little bit of time because the space was too small for my hands, but I managed to do it.

Luke Nguyen – Week 8 Reading

I find it fascinating that there is this duality pertaining to how affect impacts the way humans function. Norman demonstrates that negative affect tends to have an effect on the mind that is contradictory to that of positive effect, for example, negative effect aids the focus process whereas the positive effect relaxes it; negative affect makes it harder to do easy tasks whereas positive affect makes it easier to do difficult tasks; negative affect makes simple tasks difficult whereas positive affect makes difficult tasks easier (4, 5). When it comes to a product, this duality has an even more noticeably contradictory impact on the engineers and the users. Positive affect can make the engineers design a product in a more comprehensive way, that is, to fill it with functions ranging from simple to advanced; this, however, can render some negative affects from the users especially when they cannot figure out how to operate the advanced parts of the product. Negative affect can sometimes make the engineers feel less incentivized to improve their product and only try to finish it, which can make the product become easier for users to operate. This may prime users’ minds and make them become more tolerable to trying advanced functions within the product when the engineers decide to improve it, as Norman argues, “although poor design is never excusable, when people are in a relaxed situation, the pleasant, pleasurable aspects of the design will make them more tolerant of difficulties and problems in the interface” (6).

Another point that Norman makes to which I find worth mentioning is the harmony between beauty and usability. Obviously, the product is useless when it is beautiful but not functional; similarly, the product is also hard to use design and appeal-wise if it is highly functional but not beautiful. However, I do not fully agree with him there has to be a balance between beauty and usability. This should be dependent on the purpose of the product itself and how it is going to be used. If users choose the product because of its functions, then there is no point that the product’s level of beauty should match its functionality; the product then only needs to be decent looking enough. Vice versa, if the beauty of the product is the main selling point, then that should be the manufacturer’s main focus in design and production.

As for the story about Margaret Hamilton and how her codes help the astronauts successfully land their mission, I really admire her determination to finish up the product that she helped start. It is about her integrity and not to give in when she has more to offer. When designing and creating a product, it is important to be as thorough as possible in terms of codes and functions. It is fine if the users decide not to use it, as in the case for most computers and laptops and their users these days. However, when the users want to maximize their laptops and computers, they will really need to use what is on the table, hard.

Luke Nguyen – Midterm

 

 

Overall concept:

When I was a kid, I was obsessed with the game Chicken Invaders. I remembered spending 2-3 hours playing it every time I was free from school and homework. It was a way of life for my PC back then. And so, I wanted to emulate the engine of that game for this mid-term project and have fun creating it. I call my interactive game “Alien Slayer.”This is my initial sketch/design for the game. I ended up not following up in terms of arranging the aliens. This is because I approached designing the game using arrays and randomness. And creating lines of aliens did not feel realistic at all.

 

How the project works:

Here are the images of the game that use:

I found a sprite sheet for the spaceship and edited it down into just 4 basic movement directions.

The rules of the game are very intuitive: to kill all the aliens. That said, the number of aliens generated and the speeds at which they ascend down the screen are randomized using this:

if (random(1) < 0.008) {
    aliens.push(
      new alien(
        width / 10,
        width / 10,
        random(width - 40),
        random(-10, 0),
        random(1, 3)
      )
    );
  }

So the difficulty of the game is randomized throughout the game.

The spaceship is first created and placed at the starting position using the class:

class spaceship {
  constructor(w, h, x, y, direction, speed) {
    this.w = width/10;
    this.h = height/10;
    this.x = width/2;
    this.y = height - 60;
    this.direction = 0;
    this.speed = 5;
  }

  move() {
    if (keyIsPressed) {
      if (keyCode == UP_ARROW) {
        if (0 < this.y) {
          this.direction = 0;
          this.y -= this.speed;
        }
      }

      if (keyCode == DOWN_ARROW) {
        if (this.y < height - this.h) {
          this.direction = 1;
          this.y += this.speed;
        }
      }

      if (keyCode == LEFT_ARROW) {
        if (0 < this.x) {
          this.direction = 2;
          this.x -= this.speed;
        }
      }

      if (keyCode == RIGHT_ARROW) {
        if (this.x < width - this.w) {
          this.direction = 3;
          this.x += this.speed;
        }
      }
    }
  }

  display() {
    if (this.direction == 0) {
      image(spaceshipUP, this.x, this.y, this.w, this.h);
    }

    if (this.direction == 1) {
      image(spaceshipDOWN, this.x, this.y, this.w, this.h);
    }

    if (this.direction == 2) {
      image(spaceshipLEFT, this.x, this.y, this.w, this.h);
    }

    if (this.direction == 3) {
      image(spaceshipRIGHT, this.x, this.y, this.w, this.h);
    }
  }
  
  setW(w){
    this.w=w;
  }
  
  setH(h){
    this.h=h;
  }
  
  setX(x){
    this.x=x;
  }
  setY(y){
    this.y=y;}
  
  setDir(direction){
    this.direction = direction;
  }
}

The laser beams are also created using class:

class laser {
  constructor(w, h, x, y, direction) {
    this.w = w;
    this.h = h;
    this.x = x;
    this.y = y;
    this.direction = direction;
    this.speed = 5;
  }

  display() {
    if (this.direction == 0) {
      image(laservertical, this.x, this.y, this.w, this.h);
    }

    if (this.direction == 1) {
      image(laservertical, this.x, this.y, this.w, this.h);
    }
  }

  move() {
    if (this.direction == 0) {
      this.y -= this.speed;
    }
    if (this.direction == 1) {
      this.y += this.speed;
    }
  }
}

And the aliens are also PRE-created using class:

class alien {
  constructor(w, h, x, y, speed) {
    this.w = w;
    this.h = h;
    this.x = x;
    this.y = y;
    this.speed = random(1, 3);
  }

  move() {
    this.y += this.speed;
  }

  display() {
    image(alien_image, this.x, this.y, this.w, this.h);
  }

  hits(obj) {
    return (
      obj && 
      obj.x > (this.x - obj.w) + 10 &&
      obj.x < (this.x + this.w) - 10 &&
      obj.y > (this.y - obj.h) + 12 &&
      obj.y < (this.y + this.h) - 15 
    );
  }
}

When the user presses the space bar, a laser beam is released. The user can press the space bar multiple times. The number of laser beams released correspond to the number of times the space bar is hit.

//   Display laser beams
  for (let i = lasers.length - 1; i >= 0; i--) {
    drawingContext.shadowBlur = 10;
    drawingContext.shadowColor = color("rgb(181,0,255))");
    lasers[i].display();
    drawingContext.shadowBlur = 0;
    lasers[i].move();

  }
}

// Add the laser beams to an array to shoot with sound
function keyPressed() {
  if (key == " ") {
    lasers.push(
      new laser(
        width / 12,
        width / 12,
        spaceship1.x + spaceship1.w / 10,
        spaceship1.y - spaceship1.h / 1.4,
        spaceship1.direction
      )
    );
    beam.play();
  }
}

When the laser beam hits the alien:

for (let j = 0; j < lasers.length; j++) {
      if (aliens[i].hits(lasers[j])) {
        aliens.splice(i, 1);
        lasers.splice(j, 1);
        counter_scores++;
        break;
      }
    }

When the alien hits the spaceship:

if (aliens[i].hits(spaceship1)) {
      counter_lives--;
      aliens.splice(i, 1);
      continue;
    }

I am particularly proud of these two code snippets because I had such a hard time figuring out how to slice and make either the laser beam or the obliterated alien disappear on the screen. The hardest part was to figure out the loop using continue() and break so as the game can continue. I spent a lot of time fixing the errors relating to this.

The final rule is when the alien hits the Earth, at which point there is no return and the player will automatically lose:

if (aliens[i].y > height) {
      console.log("Game Over");
      textStyle(BOLD);
      textAlign(CENTER);
      aliens.splice(i, 1);
      gameState = "stop";
      continue;
    }

In terms of statistics, there is a score counter and a lives counter. Lives counter determines how the player progresses through out the game.

Besides checking the hit conditions, other parts that I’m proud of include coding the movement of the spaceship, coding the reset of the game, figuring out the coordinates where the spaceship meets the alien and the coordinates where the laser beam hits the alien, and creating the backgrounds and images that I use:

Creating the game start, instructions, and game restart screens also took me a lot of time. I had to refer the example sketch “Ramsha Bilal” by Save the Ocean from last year given by you to figure it out. It took me a lot of time until I could do it right, ie. creating user input before starting and creating a new session start after the previous session is completed.

Areas for improvement and problems:

In terms of using arrays, I want to make some aliens appear next to one another and move down the screen at the same time. It will vary the difficulty of the game even more. I also wanted to make the buttons for getting user’s input more aesthetic and varied, instead of what I have now.

Problems I ran into:

I couldn’t generate the stars properly so I had to refer to this YouTube tutorial from Back to Code: https://www.youtube.com/watch?v=xbmwfg5U9-s

I couldn’t make the game run in full screen properly without the elements shifting around although it still run:

https://editor.p5js.org/luke.s.ng/full/g7Hnh5lV4

There was a minor break error. If the user shoots many lasers at the same time to kill the alien, sometimes this error will pop up. During testing, the error appeared with a random number of lasers, REGARDLESS of the high score (or number of aliens killed) and the number of aliens on screen. It was a random bug while playing. But I figured out I had to add “break” to the checking condition when the laser beam hits the alien.


The lives counter initially didn’t display the number of lives when it reaches 0 properly.

I also had a lot of problems creating the starting/restarting user input pages mainly because of the buttons’ coordinates. It took me a lot of time to figure out.

Overall, it has been a fun process with lots of trial and error. I learned a lot about Object-Oriented Programming as well as debugging.

Luke Nguyen – Week 5 Reading

I find the Suicide Box project that surveyed the suicide jumpers from the Golden Gate Bridge to be very intriguing. Jeremijenko stated that the project was able to monitor real data and formulate a database for this. What I, as well as other people who thought the project was controversial, would like to know is how it was programmed to capture such data to the point where it could be called “real.” Usually machines/softwares are prone to the black box issue, which makes them very susceptible to making inexplicable mistakes while they are working. Obviously, this project faced the controversy for the right reason regarding the ethics of technology, that is using it to measure something very tragic. Nevertheless, the authors had good intention, but the way the data was recorded needed to be examined carefully.

In regard to computer vision techniques, detection through brightness thresholding mainly deals with illumination or contrast. The computer does some very simple comparison to figure out if objects are darker or lighter than the surroundings. But I would like to learn more about this aspect in terms of color vibrance and saturation. Say for example, can the computer compare the vibrance in at least 8-bit RGB color between a given object and the surrounding? Or between different objects?

As for computer vision in multimedia authoring tools, in addition to Java-based scripting, live video input and fast pixel manipulation these days can also be done with other languages. Art-based softwares are having a prime time given how much these languages are being developed. However, the more advanced processing a software is written in, the more complicated the interaction between users and computers will become, which entails a detailed and almost error-free instruction designs.

Luke Nguyen – Week 5 Mid-term Progress

Concept and design:

When I was a kid, I was obsessed with the game Chicken Invaders. I remembered spending 2-3 hours playing it every time I was free from school and homework. It was a way of life for my PC back then. And so, I wanted to emulate the engine of that game for this mid-term project and have fun creating it. I call my interactive game “Alien Slayer.”

Here’s my design:

Here’s the overall structure of the code design:

let spritesheet;
// example spritesheet: https://png.toolxox.com/vhv?p=imRwRx_top-down-spaceship-sprite-hd-png-download/
// i'll edit the spritesheet so that the spaceship can only move left, right, up, down
let sprites = [];
let direction = 1;
let step = 0;
let x; //the spaceship's x position
let y; //the spaceship's y position
let speed = 4; //the animation speed, image moving on canvas

function setup() {
  createCanvas(400, 400);
}

function preload()
  loadImage()
  spaceship = loadImage ("spaceship.png")
//   or create a pixelated spaceship

function draw() {
  background(220);
  
// create a cosmos background
// 1. gradient color
// 2. use loops (for/while loops) to create stars scattered across the space
  
// create evil aliens
// 1. create a class for show() and move() the evil aliens, with loops (for/while loops). The number of evil aliens is random, from 2 to 10. They will appear at the top of the canvas
// 2. use loops (for/while loops) to make the evil aliens start moving down 5 steps every time the frame is refreshed.
// 3. the evil aliens will randomly drop bombs.

//   use sprite sheet animation for the spaceship
//   1. use (for loops) to create a nested array for the spaceship sprite sheet
//   2. use get() to get different tiles of the sprite sheet
//   3. use function keyPressed() and if conditions to make the spaceship move each step
  
// create a laser beam attack for the spaceship
//   1. create a class to draw the laser beam and use the show() to call out the beam
//   2. use function mousePressed() {} to shoot the laser beam that can only go up
  
// gameplay
// game screen gives instructions and waits for user input
// The spaceship needs to be moved around using the keys on the keyboard, to the location vertically under an evil alien to attack it (sprite sheet animation)
// if (){} the laser beam hits the evil alien, the alien is obliterated
// if (){} the bombs dropped by the evil alien hit the spaceship, it will lose one life.
// keep playing until all evil aliens are obliterated.
// if (){} one evil alien touches the spaceship, the player loses.
  
// displaying score
// user gets one score everytime an evil alien is obliterated.
// user receives 5 lives per game. if the number of lives == 0, the user loses and the game will end.
}

The most frightening or complex part of the project is to match the coordinate of the aliens’ bombs so that when they touch the spaceship, it will lose one life. Similarly, the laser beam’s coordinate has to match that of the alien so that the spaceship can kill it. Also, I still need to figure out how to make the aliens erratically drop bombs for the spaceship to dodge. I also still need to figure out how to display the score and the spaceship’s lives in a translucent board at the top of the canvas.

What I’ve been doing is I’ve been trying to write the algorithm for matching coordinates. It’s mostly about using the if function. I’ve also been testing the algorithm for randomly creating bombs from the aliens. This game is essentially about two objects having the same coordinates and randomness.

I’m also going to implement a sound library into the project (for example, a laser beam sounds, the alien dropping a bomb, the sound of the spaceship’s moving, etc.).

 

Luke Nguyen – Week 4 Reading

I like how the author points out the fact that no matter how much knowledge the machines’ operators accumulate over the years and how well-versed they are in their field, they still have to make the construction and/or programming simple. It’s all about precision and accuracy, or perfection in the process in other words, which humans are not prone to. But it’s fascinating how, given the contradictory nature between machines and humans, humans have managed to churn out some very advanced technology that requires high level of precision and accuracy and to minimize the number of errors as much as possible merely through experimentation and testing! But that said, added complexities equate increased difficulty in use and frustration. High-tech machines/gadgets today require a lot of knowledge from users, and not every form of knowledge is easy to be acquired.

Another point from the author with which I resonate is about the relationship between affordance and signifier. This kind of relationship is not very clear-cut as one would say, as the author points out, “some affordances are perceivable, others are not” and “perceived affordances often act as signifiers, but they can be ambiguous” (19). Despite the fact that signifiers are more important than affordances, I’ve seen some terrible signifiers that do not fulfil their duty at all, which leaves users to figure out affordances all on their own and hence, suffer from frustration. The more high-tech and more complex machines, the more effort operators should put into curating the signifiers for a more effective affordance from the users.

Luke Nguyen – Assignment 4 – Top 20 Movies of 2023

I went to the cinema a lot so I was fascinated about the box office of the movies released in 2023 (mainstream movies only as their box offices are always reported with accurate data from cinemas). I wanted to make a data visualization of the top box office of movies released last year. I searched on Kaggle and came across a CSV files compiling the US Domestic box office of top 200 movies in 2023 (https://www.kaggle.com/datasets/mohammadrizwansajjad/top-200-movies-of-2023). I edited the dataset a little bit, removing unnecessary data columns and reducing the dataset down to 20 to reflect the top 20 movies with the highest box office. The chart displays the movies’ box offices as well as the month they were released while also vertically ranking them according the box offices.

Snippets of code:

//Retrieving data from the table
  let Month = movies.getColumn("Release Date");
  let Name = movies.getColumn("Title");
  let Rank = movies.getColumn("Rank");
  let Boxoffice = movies.getColumn("Total Gross");

  for (let i = 0; i < img.length; i++) {
    // split data into string
    let splitString = split(Month[i], "/");

    //     displaying data
    image(
      img[i],
      12.5 + ((int(splitString[0]) - 1) * (width - 20)) / 12,
      map(Rank[i], 1, 22, 50, height - 20),
      53,
      23
    );
  }

Embedded Sketch (hover mouse diagonally to see all box offices):

The chart essentially displays the movies’ logos according to their box offices using the Map function. We can eyeball and compare one movie’s box office with another’s. The hardest part is to figure out the placements of the movies’ logos. But more importantly, it is also about extracting the data from the dataset and come up with a way to graph them.

For future improvement, I want to come up with a way to display the movies’ logos in a more visible manner. As of now, because of the size of the chart, the logos are pretty small and the accompanying hover number for the box offices are also small. I also want to display the box office number separately as well, i.e. it only shows when the mouse hover on the image. The challenge here is to figure out the coordinate of mouseX and mouseY.

Luke Nguyen – Week 3 Reading

I resonate with the interaction that the author proposes. Interaction is a “cyclic process” in which two actors alternately listen, think, and speak; it’s a back-and-forth listening, thinking, and speaking process indeed. The key is more than one, irrefutably. But I entertain his idea that we should think of interactivity as a “variable with relative measures.” Sometimes, defining whether an object as either interactive or non-interactive seems reductive and regressive. Things are more than what they seem and they certainly belong in the grey area of interactivity definition. Aiming to discuss the degree of interactivity seems to be a legitimate approach.

The author thinks that movies are non-interactive. However, in today’s context, this is not true entirely anymore, given the rise of interactive content on streaming platforms such as Netflix, with shows or movies like Carmen Sandiego: To Steal Of Not To Steal, Black Mirror Bandersnatch, etc.. Sure, the end result is pretty much very pre-determined, these programs are scripted anyway, but the concept and operation of the interactivity is successfully implemented. Pretty soon in the future, there will be interactive movie made for VR glass devices such as the newly released Apple Vision Pro.

I also find the idea about the contention between user interface and interactivity design to be fascinating. User interface from what I understand is all about front-end and the interactivity design back-end. But I’ve never thought about the tense relation between the interactivity designers and the user interface designers who detest the intrusion of interactivity designers into their work. I’ve always thought that each of these two aspects cannot exist without the other!