Author: Elora Trotter

Mega trying out my project at the Showcase.

Concept:

My primary source of inspiration was Andrew Schneider’s ‘Stars’ exhibit, as it would not be an overstatement to say that it changed my life. His method of combining technology with poetry resonated with me because he allowed me to see that what I wanted to do was possible. I also want to acknowledge how much his approach of jumping into the project before sorting out the functional technicalities inspired me. Too often, I get discouraged from starting projects because of my insecurities surrounding my computational knowledge. Schneider reminded me to approach creating the way a child would–prioritizing fun over understanding. I didn’t have to be an expert to have a vision, or to create something great.

My second source of inspiration was my favorite installation at Manar Abu Dhabi, which detected your pulse in order to make a field of light glow with your heartbeat. Both this installation and Schneider’s used technology that evoked breathtaking, light-filled phenomena. But somehow, through either words or your heartbeat, they connected these surroundings back to you, indicating a kind of macro-micro spiritual connection. I wanted my project to accomplish an effect along these lines.

A more tangential inspiration was Tiktok. Most people my age consume a large amount of reels day to day, but every once in a while, a deeper, more meaningful video will appear from the usual, mind numbing congelation that is Tiktok and Instagram reels. I would find myself being surprisingly moved, and thought it was interesting how a lot of our generation must connect to inspiration or meditative clarity through these short-form videos. Because of the small scale of my project, I wanted to achieve an emotional effect closer to that of a meditative Tiktok–short, sweet, but profound enough to make you pause and feel something before resuming daily life.

The Process, Beginning With Arduino:

I started by tackling the Arduino part of the project. I followed a page linked here, which, thankfully, contained the exact instructions I needed. I followed the schematic they displayed, see below:

But I also drew my own schematic, here:

But here is an actual photograph, just to be sure:

The Arduino wiring couldn’t have been more simple. And frankly, the Arduino coding wasn’t that much more difficult either. I downloaded a PulseSensor library that I found on the page and made modifications to format the code for my own objectives. Here’s the code below:

void setup() {
  Serial.begin(9600);
  pinMode(LED_BUILTIN, OUTPUT);
  // Arduino sending data to component, the green light, to light up

  // start the handshake
  while (Serial.available() <= 0) {
    digitalWrite(LED_BUILTIN, HIGH);
    Serial.println("0,0");
    delay(300);
    digitalWrite(LED_BUILTIN, LOW);
    delay(50);
  }
}

void loop() {
  while (Serial.available()) {
    digitalWrite(LED_BUILTIN, HIGH);
    int left = Serial.parseInt();
    int right = Serial.parseInt();
 // Example of parsing, where Arduino breaks down left and right components so that when it sends the code to P5JS, P5JS interprets the left and right as one so that the code can be executed smoothly 
    if (Serial.read() == '\n') {
      int pulseSensor = analogRead(A0);
// Mapping analog values to digital values so pulse sensor can be read and show up on P5JS
      int mappedPulseSensor = map(pulseSensor, 0, 1023, 0, 255);
      delay(5);
      Serial.print(mappedPulseSensor);
      Serial.print(',');
      Serial.println(mappedPulseSensor);
    }
  }
  digitalWrite(LED_BUILTIN, LOW);
}

The most important section worthy of mention is the mapping of the pulse sensor to a digital range. Apart from the voltage and ground wires, because the pulse sensor reads analog signals, I plugged the last wire into A0 and then mapped its 0 to 1023 range to 0 to 255, so that P5JS could read its detections and convert them into the pulses of the ellipse on the screen.

The Process, Continuing With P5JS:

The most challenging section of this project was the coding regarding P5JS. I started by coding a glowing ellipse and making sure that it pulsed with the readings of the sensor, linked here, but also shown below:

let rVal = 0;
let pulse = 255;
let left = 0;
let right = 0;


function setup() {
  createCanvas(600,600);
  textSize(18);
}

function draw() {
  // one value from Arduino controls the background's red color
  background(0);

  // the other value controls the text's transparency value
  fill(255, 255, 255);
  strokeWeight(0);

  if (!serialActive) {
    text("Press Space Bar to select Serial Port", 20, 30);
  } else {
    text("Connected", 20, 30);
  }
 
  
  drawingContext.shadowBlur = 80;
  drawingContext.shadowColor = color(255);
  ellipse(width/2, height/2, map(pulse, 0, 255, 10, 100))

  
}
 


function keyPressed() {
  if (key == " ") {
    // important to have in order to start the serial connection!!
    setUpSerial();
  }
}

// This function will be called by the web-serial library
// with each new *line* of data. The serial library reads
// the data until the newline and then gives it to us through
// this callback function
function readSerial(data) {
  ////////////////////////////////////
  //READ FROM ARDUINO HERE
  ////////////////////////////////////

  if (data != null) {
    // make sure there is actually a message
    // split the message
    let fromArduino = split(trim(data), ",");
    // if the right length, then proceed
    if (fromArduino.length == 2) {
      // only store values here
      // do everything with those values in the main draw loop
      rVal = fromArduino[0];
      pulse = fromArduino[1];
      print(pulse);
    }

    //////////////////////////////////
    //SEND TO ARDUINO HERE (handshake)
    //////////////////////////////////
    let sendToArduino = left + "," + right + "\n";
    writeSerial(sendToArduino);
  }
}

I coded the ellipse in the above section, making sure to map the diameter of the ellipse to the signals of the sensor, causing the pulsing effect. The section regarding how P5JS read the information from Arduino, but also sent information back to Arduino (see Handshake), so that Arduino and P5JS worked in tandem to make the ellipse pulse.

The Process, Continuing With P5JS:

After sorting out the ellipse pulsing, which was the main component, I began coding the stars and words I wanted to go along with the pulsing ellipse. I was really inspired by Pierre’s midterm project, because it gave that same all-encompassing starry night effect that Schneider’s installation did. I began by trying to make modifications to Pierre’s code, seen here, but I quickly realized after trying to insert the ellipse into it that coding within the constraints of WEBGL would be too difficult for me for the purposes of this project. While experimenting, I accidentally created this, which might be one of the coolest things I’ve ever made. I plan to pursue WEBGL on my own time, but I acknowledged that working within a two-dimensional realm for this project would suffice.

So, I began by coding the stars, linked here. I’ve attached the most difficult section of the code below:

function createStars() {
  for (let i = 0; i < 100; i++) {
    let x = random(width);
    let y = random(height);
    let radius = random(1, 3);
// I made the radius random within these constraints so the ellipses weren't all the same size, giving that 'starry night' effect and the illusion of distance, since I couldn't hack WEBGL
    let speedX = random(1, 3) * (random() > 0.5 ? 1 : -1); // So that the stars randomly go left and right
    let speedY = random(1, 3) * (random() > 0.5 ? 1 : -1); // So that the stars randomly go up or down 
    stars.push({ x, y, radius, speedX, speedY });
  }
}

function moveStars() {
  for (let star of stars) {
    star.x += star.speedX;
    star.y += star.speedY;

    // Makes the stars stay within the constraints of the display screen
    if (star.x < 0 || star.x > width || star.y < 0 || star.y > height) {
      star.x = random(width);
      star.y = random(height);
    }

I wanted the size to be random within the constraints of 1 and 3 so that I could give the ellipses that ‘starry night’ effect. Making their radiuses vary also gave the illusion of depth and distance, since I couldn’t hack WEBGL. I made their movement as random as I could, making them go in different directions so I could add as much dynamism to the project as possible. The focus of the project, the fixed ellipse, is not that moving and stimulating, so I knew I needed to make the stars add that layer of movement to make sure the project would be engaging.

After coding the stars, I combined the code of that with the pulsing ellipse so that I could begin adding the words.

The Result!!!!

And this was the result! Linked here, but also seen below!

let rVal = 0;
let pulse = 255;
let left = 0;
let right = 0;
let stars = [];
let ellipseVisible = false;
let starsVisible = false;
let keyPressedOnce = false;
let showAdditionalText = false;
let mPressed = false;

function setup() {
  createCanvas(2000, 1300);
  textSize(34);
  createStars();
}

function draw() {
  background(0);
  fill(255);
  textAlign(CENTER, CENTER);
  
  
//Code that ensures that the instructions for the interaction, and the serial port appear before the ellipse and stars appear
  if (!serialActive) {
    text("PRESS SPACE TO SELECT SERIAL PORT", width / 2, height / 2);
  } else if (!ellipseVisible && !starsVisible) {
    text("LIGHTLY TOUCH YOUR FINGER TO THE PULSE SENSOR", width / 2, height / 2);
  } else if (ellipseVisible || starsVisible) {
    
//Responsible for making the ellipse glow     
    drawingContext.shadowBlur = 80;
    drawingContext.shadowColor = color(255);
// Maps ellipse to arduino board, making it pulse
    let ellipseSize = map(pulse, 0, 255, 10, 300);
// Determines dimensions of ellipse
    ellipse(width / 2, height / 2, ellipseSize);
  }

// Once the ellipse and stars appear, the text taking you through the interaction appears too
  if (ellipseVisible && !starsVisible) {
    text("GIVE THE SENSOR TIME TO PICK UP ON YOUR PULSE\nBUT ONCE YOU SEE YOUR HEART BEATING, ACKNOWLEDGE\nTHAT THIS PULSE IS YOU, ALIVE AND BREATHING\n\nPress 'n'", width / 2, height - 180);
  } else if (starsVisible && !keyPressedOnce) {
// ensures that the stars appear and keep moving with each frame
    moveStars();
    displayStars();
    text("YOU ARE ALIVE AND BREATHING IN THE UNIVERSE\nLOOK AT AT ALL THE STARS\nBUT SOMETIMES, THE UNIVERSE SEEMS SO BIG\n IT'S EASY TO FEEL SMALL\n\nPress 'm'", width / 2, height - 180);
  } else if (starsVisible && !showAdditionalText) {
    moveStars();
    displayStars();
    text("BUT THE UNIVERSE IS ALIVE WITH YOU TOO\n\nPress 'v'", width / 2, height - 180);
  } else if (showAdditionalText) {
    moveStars();
    displayStars();
    text("TELL YOUR FRIENDS YOU LOVE THEM\nREMEMBER TO FEEL YOUR HEARTBEAT WHEN YOU\n LOOK UP AT THE SKY, BECAUSE SOMEDAY\nYOU'LL WISH YOU COULD'VE LIVED IT ALL OVER AGAIN", width / 2, height - 180);
  }
}

function createStars() {
// Defines speed and number of stars
  for (let i = 0; i < 100; i++) {
    let x = random(width);
    let y = random(height);
// Makes sure the stars are randomly different sizes within these constraints to give them that 'starry sky' effect
    let radius = random(1, 3);
// Defines random speed of stars within these constraints
    let speedX = random(1, 3) * (random() > 0.5 ? 1 : -1);
    let speedY = random(1, 3) * (random() > 0.5 ? 1 : -1);
    stars.push({ x, y, radius, speedX, speedY });
  }
}

function moveStars() {
  for (let star of stars) {
// After the speed of the stars has been defined, use moveStars to make sure they keep moving through the entire project 
    star.x += star.speedX;
    star.y += star.speedY;

// Makes sure stars move within the display screen
    if (star.x < 0 || star.x > width || star.y < 0 || star.y > height) {
      star.x = random(width);
      star.y = random(height);
    }
  }
}

// Ensures the stars never disappear with each changing slide
function displayStars() {
  noStroke();
  for (let star of stars) {
// Makes stars glow after key 'm' is pressed 
    if (mPressed) {
      fill(255, 255, 255, 180);
// Defines the size of the shadow that gives the stars their 'glow' effect
      ellipse(star.x, star.y, star.radius * 7);
      // for (i = 0; i < 100; i++) {
      //   ellipse(star.x, star.y, (star.radius * i * 1) / 20);
      // }
    }
    fill(255);
    ellipse(star.x, star.y, star.radius * 2, star.radius * 2);
  }
}

// My attempt to make the stars pulse, but I was okay with them simply glowing, so I never used updateStars but I kept it just in case
function updateStars() {
  let rValMapped = map(rVal, 0, 255, -0.1, 0.1);
  let pulseMapped = map(pulse, 0, 255, 1, 3);
  let pulsingFactor = map(pulse, 0, 255, 0.5, 2);

  for (let star of stars) {
    star.speedX += rValMapped;
    star.speedY += rValMapped;

    star.radius = pulseMapped * pulsingFactor;
  }
}


// These are all the instructions so that the project knows to move to the next slide when certain kets are pressed
function keyPressed() {
  if (key == " " && !serialActive) {
    setUpSerial();
  } else if (key == "n" && ellipseVisible && !starsVisible) {
    starsVisible = true;
  } else if (key == "m" && starsVisible && !mPressed) {
    keyPressedOnce = true;
    mPressed = true;
  } else if (key == "m" && starsVisible && mPressed) {
    mPressed = false;
  } else if (key == "v" && starsVisible && keyPressedOnce) {
    showAdditionalText = true;
//Code that allows one to exit our of and enter fullscreen by pressing the key 'f'
  } else if (key == "f") {
    if (!fullscreen()) {
      fullscreen(true);
    } else {
      fullscreen(false);
    }
  }
}

// How P5JS knows to read from Arduino in order to give the ellipse the pulse
function readSerial(data) {
  if (data != null) {
    let fromArduino = split(trim(data), ",");
    if (fromArduino.length == 2) {
      rVal = fromArduino[0];
//The pulse from Arduino that P5JS was able to read to make the ellipse pulse
      pulse = fromArduino[1];
    }

    let sendToArduino = left + "," + right + "\n";
    writeSerial(sendToArduino);
// If a pulse greater than 0 is detected from the sensor and the ellipse is visible, then the pulsing begins
    if (pulse > 0 && !ellipseVisible) {
      ellipseVisible = true;
    }
  }
}


// Ensures stars and ellipse stay visible when mouse is pressed 
function mousePressed() {
  if (!starsVisible && ellipseVisible) {
    keyPressedOnce = true;
    starsVisible = true;
  }
}

I commented everything, but the most difficult part of the code was definitely this section:

// Once the ellipse and stars appear, the text taking you through the interaction appears too
  if (ellipseVisible && !starsVisible) {
    text("GIVE THE SENSOR TIME TO PICK UP ON YOUR PULSE\nBUT ONCE YOU SEE YOUR HEART BEATING, ACKNOWLEDGE\nTHAT THIS PULSE IS YOU, ALIVE AND BREATHING\n\nPress 'n'", width / 2, height - 180);
  } else if (starsVisible && !keyPressedOnce) {
// ensures that the stars appear and keep moving with each frame
    moveStars();
    displayStars();
    text("YOU ARE ALIVE AND BREATHING IN THE UNIVERSE\nLOOK AT AT ALL THE STARS\nBUT SOMETIMES, THE UNIVERSE SEEMS SO BIG\n IT'S EASY TO FEEL SMALL\n\nPress 'm'", width / 2, height - 180);
  } else if (starsVisible && !showAdditionalText) {
    moveStars();
    displayStars();
    text("BUT THE UNIVERSE IS ALIVE WITH YOU TOO\n\nPress 'v'", width / 2, height - 180);
  } else if (showAdditionalText) {
    moveStars();
    displayStars();
    text("TELL YOUR FRIENDS YOU LOVE THEM\nREMEMBER TO FEEL YOUR HEARTBEAT WHEN YOU\n LOOK UP AT THE SKY, BECAUSE SOMEDAY\nYOU'LL WISH YOU COULD'VE LIVED IT ALL OVER AGAIN", width / 2, height - 180);
  }

Making the words appear in the order I wanted, without the ellipse or stars disappearing was difficult and something I had to work at for a while. I solved this by coding successive “if, else” statements and establishing this:

let starsVisible = false;
let keyPressedOnce = false;
let showAdditionalText = false;

at the beginning of the code. My friend Zion helped me extensively through this part of the coding, so thank you Zion.

After that, I just had to make the small adjustments of making the text the size I wanted, adjusting the stars to full screen, and the project was good to go. I didn’t know how to upload the song I wanted, “Stone in Focus” by Aphex Twin, as a file to P5JS, so I just played it in a Youtube tab while the project was going on.

I also made the stars glow with the ellipse when the line “BUT THE UNIVERSE IS ALIVE WITH YOU TOO” to give a sense of connection with the universe. The stars got triggered to glow after pressing the ‘m’ key.

Showcase Day:

On the day of the showcase, I constructed my setup, seen here:

You can see the headphones that people put on to hear the music, but I want to bring special attention to the box:

One of my biggest concerns developing the project was the unreliability of the pulse sensor itself. It would reliably pick up on a pulse but also pick up on any extra movement of your hand, making the pulse look wonky. It’s because the pulse sensor works by shining a light on your finger, and reading your pulse by the way it affects the light. So if you move your finger too much, it disrupts the pulse sensors ability to pick up on your heartbeat. At Manar Abu Dhabi, even that pulse sensor had to wait up to a few minutes before being able to get a stable reading. So, creating better pulse sensors for future interactive installations is a concern. But in order to counteract this problem, I constructed a box that the audience member could naturally rest their hands on so that the pulse sensor could pick up a more stable reading. It also looked more approachable and finished as an interactive installation.

One concern I left with though, from a design point of view, was that people tended to put their their right hand on the sensor, causing them to have to reach over with their left hand to press the keys to go through the project. I would want to make my project more convenient and interactive by fixing this issue.

Takeaways:

In the end, I am so proud of what I made, because I was able to capture an,  albeit small, portion of the feeling that I experienced when at Schneider’s installation and Manar Abu Dhabi. Here are some people interacting with my project:

What they’re going through, is seeing their pulse on the screen and then reading successive phrases that remind them of their connection with the universe, giving them that same macro-micro spiritual connection that Andrew Schneider’s installation gave me. One of my favorite moments was when Linda, an audience member, saw her pulse on the screen and gasped, “It’s me!” That’s the exact effect I wanted to provide.

At the beginning of this post, I posted a picture of Mega and me. After she had completed the project, she turned to me and said, “Elora, I love you.” Even though the effect was small, I had emotionally achieved what I set out to do with this project, and I am so grateful.

I visited Manar Abu Dhabi last week. My favorite installation was a field of lights that pulsed with the audience’s heartbeat. When I saw it, I felt like I was in Elysium. It stole all the wind from me. Here’s a video of it here. I know I want to create an installation that involves a heartbeat, using sensors, and that’s the Arduino component. As to what detecting the heartbeat will do, I’m still iffy.

I’ve been having a lot of conversations with my dad these days about how disconnected we are from each other and from ourselves. I want to create a project that brings people more in tune with their inner selves and surroundings, using the heartbeat, which is, naturally, already a very intimate thing.

My first idea is maybe when two people’s hearts get in sync, something appears on P5JS screen. And when they’re not in sync, images appear that represent the dissonance that is happening. Or, instead of going that route, everyone’s individual heartbeat draws a unique picture that is added to a larger picture of everyone’s similar but different looking heartbeats. I’ve also been trying to come up with ways I could add poetry/words into this installation the way Andrew Schneider did with his. He did it perfectly.

Or, I’m seeing a circle that pulses on the screen with your heartbeat in something that looks like a universe (like what Pierre did). Something that gets the message of being a pulse in the universe across, and as steps are went through, new poems/words pop up.

Here’s a project called “Text Rain.” I could incorporate words this way, perhaps. Maybe every time the circle pulses, words pop out, but how to make it more interactive so that it’s the audience’s words instead of my own…still unsure. Either way, I’m gonna put a moldboard below. I love Instagram archive pages. Because they have text like this. I want to capture the feeling these images evoke:

It’s a lot. But there’s a vibe. It should be more fleshed out but, things must come together eventually.

Assignment 1: Move Ball With Potentiometer

I attached a picture of our setup below:

I took the P5JS sketch we used in class and made a few changes, seen here. First, we created the ellipse. When writing the parameters, we made the x value alpha, because the sketch already set alpha as the value that is reading the Arduino board. In order to read Alpha, we had to make sure we mapped the potentiometer range to the range of the P5JS screen. So when you turn the potentiometer, the x value changes, making the ellipse move backwards and forwards. See the important code snippet below:

ellipse(map(alpha, 0, 1023, 0, width),height/2,60);

Assignment 2: Control LED Brightness From P5JS

We took the same P5JS sketch from the slides and altered it, seen here. Here are the changes we made:

let value = map(mouseX,0,width,0,255);
right = int(value);

We created a new variable called value and then mapped the width of the P5JS screen to the LED values, so that as you moved your mouse horizontally across the screen, the LED brightened and dimmed. We used pin 5 because it supports PWM. The LED connected to Pin 5 was the “right” one in the code we used in class, hence why used “right” above to connect the LED and the P5JS bit above. We also had to go into the Arduino code that we had used in class and changed a bit of that as well.

digitalWrite(leftLedPin, left);
analogWrite(rightLedPin,right);
// digitalWrite(rightLedPin, right);

As you can see, we commented out the digitalWrite regarding the right pin and replaced it with analogWrite so that the LED didn’t just turn on or off, but actually got dimmer and brighter on a spectrum.

Assignment 3: Make The LED Turn On When The Ball Bounces

Here is our video. Here is the link to our sketch.

We combined the Gravity Wind example from the slides with the other P5JS sketch from the slides and changed a few things, seen below:

ellipse(position.x,position.y,mass,mass);
  if (position.y > height-mass/2) {
      velocity.y *= -0.9;  // A little dampening when hitting the bottom
      position.y = height-mass/2;
    
    right = 1;
    }
  
  else {
    right = 0;
  }

We went to the part of the code where the ball hits the ground, and made it so that the Arduino read the LED as “right,” and the LED turned on (1) and off (0) depending on whether the ball was touching the ground or not.

On a side note, we also made sure that whenever you pressed n, that was how a new circle appeared. Because when we combined the two sketches, it had already been written that pressing the space bar makes the serial bar pop up.

if (key=='n'){
   mass=random(70,80);
   position.y=-mass;
   velocity.mult(0);

Assignment 4: Control Wind With Potentiometer

Last but not least, we made the ball move left and right with the potentiometer by adding this bit of code.

wind.x = map(alpha,0,1023,-1,1);

We mapped the values of the potentiometer onto the wind values already established in the code. So that when we turned the potentiometer right, the ball went right (1) and left (-1) when we turned the potentiometer left.

Professor Goffredo is really good at breaking down good design. At first, when you delve into what makes a design good, it’s all very heady and cerebral. Very meticulous and calculated. But at the end of the day, when you go into what really makes a design good, the reasoning is so shallow. A design is good when it works and people use and like it. A design is bad when they don’t. It reminded me of something Stanley Kubrick said about movies. He said you can think of a million intelligent reasons for why a movie was good or not, but at the end of the day, the only thing that mattered, the only thing that really determined whether it was good or not, was if you liked it. Simple as that. Goffredo is really good at identifying simple human behaviors that drive all of design. And I’ve been surprised at how much I have learnt about myself while studying design.

At first, the world ‘disability’ seems to have really clear parameters. We think of people who have to walk with canes, and our first reaction is to go, “Well, I’m not that. This doesn’t apply to me.” But I think we are all disabled in a myriad of ways. If the goal is seamless social assimilation, I think we all know what it feels like to be an outsider. The same mechanism that keeps us from saying embarrassing things is the same mechanism that drives us to design hearing aids to be as invisible as possible. We don’t want what we’re lacking to be spotted. But there’s a power you reclaim when you choose to own it. One of my favorite Kanye lyrics goes: “I found bravery in my bravado.” And I think designing for disabilities would really benefit from this mindset. We all know what it’s like to feel weird. But then when we embraced what we had once spurned, we discovered that’s where the source of our strength was. Rumi said, “The wound is where the light enters.” A disability is never a disability as the word is understood. A disability is one of the many types of roadblocks we experience being human. We all experience the disabilities of being human in so many different ways. Sometimes, they even incapacitate us and keep us from seeing the beauty in our struggle. The goal of the good designer is to recognize these incapacities and to free us, both physically and mentally. They diagnose the wound, and design something that allows the light to enter. They make what had once been looked down upon desirable. They make what had once made us outcasts into harbingers, icons, and leaders. Disabilities are fertile grounds for growth, change, and beauty. I think if we start approaching disability from this frame of mind, we’ll see the overall soul of humanity much more clearly.

There’s this TV Show called Westworld starring Anthony Hopkins and Evan Rachel Wood. The basic premise of the show is that Anthony Hopkins’s character, Doctor Robert Ford, and his partner, Arnold, built a fake world filled with humanoid robots that look exactly like humans, called ‘hosts.’ This fake world is a fantasy park set up like the Wild West. So that if humans from the real world want to know what it is like to shoot cowboys and ride trains and solve mysteries with pretty barmaids, they can. What Doctor Ford realizes too late is that even though he had built these hosts with his own hands, they were conscious the whole time. And when they realize their consciousness, they develop a vengeance against real world humans for shooting and raping them over and over, just to play a game. 

Anthony Hopkins’s character said something that has forever stuck with me. He gets asked, “So what’s the difference between [a host’s] pain and yours?” And he replies:

“Between [a host] and me? This was the very question that consumed Arnold, filled him with guilt, and eventually drove him mad. The answer always seemed obvious to me. There is no threshold that makes us greater than the sum of our parts, no inflection point at which we become fully alive. We can’t define consciousness because consciousness does not exist. Humans fancy that there’s something special about the way we perceive the world, and yet we live in loops as tight and as closed as the hosts do, seldom questioning our choices, content, for the most part, to be told what to do next. No, my friend, [the hosts] are not missing anything at all.” 

I thought of all this when Professor Leach got asked at the end what’s really the difference between how we think and how Artificial Intelligence thinks. I had a teacher I adored in my sophomore year of highschool. Eighty year old Mr. Daly. But his memory was in its twilight years, and he would tell us the same stories. Would answer our questions with the same responses we had heard before. And I found that without our memory to contextualize the stories of our lives, given the same set of variables, placed in the same situations, like pressing a button, we elicit the same responses. Like we ourselves are robots, spitting out outputs when given certain inputs. And I wondered how much we really are in control of. I keep concluding that we’re really not in control of much. Not much at all. 

So if we’re not really in control of much, as the Great Artificial Intelligence Upset draws closer and closer, how do I avoid becoming just another casualty in the great turning of the world? The ocean makes bigger waves than others, and during those times, it’s up to you to swim or drown. I have a Literature professor and, God bless his heart, at the beginning of the year, he would make fun of ChatGPT, talking about how there are things that humans can do that Artificial Intelligence will never be able to do. I could see him holding onto the last threads of his fading profession, and I knew he was not the guy to follow. On that same day, my favorite Design professor said, “Until Artificial Intelligence overtakes us… and it will overtake us…” and I knew he was hip to what was going on. The difference between Literature and Design majors…the stereotypes write themselves. 

I’ve been reading a book called How To Think Like A Great Graphic Designer, and in it, there’s a designer who says, “The right answer is always the obvious one. The one that was in your face the whole time but you didn’t think of until the last second. The one that makes you go, ‘How could I not have seen it before?’” And Professor Leach reminded me of this when he said, “AlphaGo showed us that moves humans may have thought are creative, were actually conventional.” The strategic brilliance of Artificial Intelligence is that it’s able to see the obvious answer right from the beginning, the one that we should have all seen before. 

I also want to mention an episode called “The Swarm” from the TV Show Love, Death, and Robots. The premise of this episode is that there is an alien hive called “Swarm” that dominates every other species by absorbing them into its hive. Like Artificial Intelligence, every member of the hive knows what the other members know, and it is through this collective consciousness, this seamless teamwork, that they thrive. And with the levels of competition that divide us, sometimes I look at ourselves, and think that for all of our brilliance, I don’t know if we’re going to make it out of here alive. I thought about what Professor Leach said in response to my question, that between the competitors and the collaborators, while there’s nothing you can do about all the people in the world trying to beat each other out, you can choose for yourself to be on the side of the collaborators. And isn’t that what Rumi said all those years ago? “When I was young I wanted to change the world. Now that I am old, I want to change myself.” Amongst all this noise of consciousness and uncertainty, I can choose for myself what my place in the world will be throughout this. I have to believe in the power of that. 

The Final Project:

Saiki and I decided to make a rave bot. It looks like this:

And here is our video.

The Process:

We didn’t really know what to expect going into it. We knew we wanted to make a theramin with an ultrasonic sensor, so we started from there. We tackled the breadboard first. And we ended up with:

First, we connected the sensor, the speaker, and the potentiometer, which controlled the volume. Then, to add the digital component, we added a button and the changing LED light into the mix. If you press the button, the LED starts looking like a strobe light. There ended up being a lot more wires than I expected. See below:

Which brings me to my favorite and most challenging part of the code. The entire code is on Saiki’s post since we coded everything on his laptop. But I took a screenshot.

We kept fiddling with the ‘if’ values until we got the effect we wanted. After all that, we put the circuit into a box and started spray painting everything to get that graffiti rave effect. All in all, this was a super fun project. Honestly, the sounds the speaker was making doesn’t sound that different from the noise music scene today. I came away feeling proud of what we accomplished.

These articles reminded me of something my dad always used to say, “The things that separate us from every other animal are our tongues and thumbs. They can’t speak to each other like we do. They can’t hold hammers like we do.” Try going a day without using your thumbs and you’ll realize how incapacitated we’d be without them. Thanks to our tongues and thumbs, we’ve penned symphonies and raised sky scrapers. Hallelujah.

I’ve also been reading this book called Steal Like An Artist. Here’s an excerpt that parallels the reading:

“While I love my computer, I think computers have robbed us of the feeling that we’re actually making things. Instead, we’re just typing keys and clicking mouse buttons…artist Stanley Donwood, who’s made all the album artwork for the band Radiohead, says computers are alienating because they put a sheet of glass between you and whatever is happening…Just watch someone at their computer. They’re so still, so immobile. You don’t need a scientific study (of which there are a few) to tell you that sitting in front of a computer all day is killing you, and killing your work. We need to move, to feel like we’re making something with our bodies, not just our heads. Work that only comes from the head isn’t any good. Watch a great musician play a show. Watch a great leader give a speech. You’ll see what I mean. You need to find a way to bring your body into your work. Our nerves aren’t a one-way street—our bodies can tell our brains as much as our brains tell our bodies. You know that phrase, “going through the motions”? That’s what’s so great about creative work: If we just start going through the motions, if we strum a guitar, or shove sticky notes around a conference table, or start kneading clay, the motion kickstarts our brain into thinking.”

Every generation has a distinct zeitgeist. And while I don’t think this is our only characteristic, I believe we suffer from apathy. We are an apathetic generation. And I attribute a lot of that to the time we spend on our phones. In 2016, a study found that the average person in the UK scrolls 5 miles on their phone! And that number has definitely only increased since. We spend all day absorbing information about life, but never actually live ourselves. Even when we’re off our phones, we think in the paradigms of the online-world, and bring that into our real-life interactions and conversations. It’s like using our technology the way we do has inserted a real glass wall into our lives. A lot of people feel constantly disassociated from themselves. And I think how we use technology today has something to do with that. We watch so many movies and TV shows but have lost sight of living the movie ourselves. Not watching ourselves through an audience’s eyes.

It’s like the reading said:

“We share the blood of cavemen who pushed spears into mammoths and drew pictures of them in the living room.” I was talking to my dad about this and he said, “Right? That was what it was all for? So we could jerk off to Instagram reels today.” And we had a laugh, but operating behind glass screens so much, we lose sight of who we really are as magical, living humans. My dad always says the two things to feeling the real magic of life again are sweat and breath. Sweat and breath. We can’t lose that if we’re going to keep our souls intact.

That’s another thing I remembered reading these articles. The disassociation I experience when involved in VR installations. Because I can see all of these incredible things happening, but I stumble out, wanting to feel. Wanting to touch this exciting world around me. Wanting to feel this new ground beneath my feet. But I don’t, and it’s incredibly disconcerting. I think as a culture, we’ve inundated ourselves to this. But I agree with the author, it can’t be that way forever. And if we’re going to make real art and real devices that amplify our capabilities of LIVING, something’s gonna have to give.

Heat sensor Arduino.

A video of my switch is uploaded here.

I complete the circuit and a red light switches on by pressing two cigarettes together and open the circuit and turn off the light by pulling them apart. I taped the connecting wires to the cigarettes. A picture of the circuit is below:

The circuit itself is simple but I like the concept behind it. In smoking circles, if somebody doesn’t have a lighter, a friend will offer to light their cigarette by putting their cigarettes together. It’s surprisingly intimate because the two people have to put their faces quite close to each other for the trick to work. You pause in the moment, and then your cigarette flares bright red, and you pull back. I really liked making this circuit because it resembles that smoking experience pretty closely. There’s something meaningful in it to me, in watching the little red light, which indicates the cigarette lighting, burn and disappear by putting the cigarettes together and pulling them apart. I think it’s a pretty cool switch.

Unfortunately, I burned two red lights out before getting a friend to help me figure out that I needed a resistance wire with a higher resistance. Their remains are pictured below, RIP:

All in all, it’s simple. And it requires the use of my hands but I liked the concept too much to let it go. I want to upload this for now but I plan to ask Professor Riad to help me develop the switch a bit more for the purposes of this assignment.

(Also I am just recognizing how often cigarettes have played a role in my assignments this year. Hm.)