Author: Nisala Saheed

It’s not hard to understand the basic components of computer vision and be absolutely astonished by it; immediately going to your computer and trying to figure out how to make something like this work. I, of course, have not taken the lesson on computer vision with Aaron, yet, but have my interests peaked nonetheless. This fascination with computer vision, I doubt, is rare. Given the range of artworks described in the post, I can imagine many artists running to their computers (and visions.. haha) to program beautiful artworks. The crux of my reaction, however, is the notion of the gimmick.

When does something highly desirable become a gimmick?

This happens in all forms of art design so frequently. Many are aware of the Great Marbling movement of the late early 2000s, or the drop shadows of the 90s. What started as innovative became both a trademark of a time period and an annoyance.

At first, this frustrates me, but I then think of this process as cyclical. This high saturation of a particular technique, art, or design in a particular time period can desensitize us to its beauty. But we quickly find balance. Drop shadows are now a classic if you will, maybe computer vision will become one too.

As a conceptual focus for our Final Project, Jana and I are considering the complex social fabric of our university. Namely, the heavy focus on our perceptions of perfection and our ideas surrounding productivity. Vox Media created a video essay on the nature of our perceptions of productivity, describing how we often consider forms of self-care as precursors and necessary acts for the sake of our own professional, academic and all-around utilitarian productivity. This notion is frequently reproduced at NYUAD as we witness many slouched students scattered around our campus stressing about the next assignment due, or whether they have a worthwhile internship lined up for summer.

As a conceptual attendance sheet, our project would be placed one of the entrances to the exhibit, asking visitors to input data pertaining to their relationship to leisure, self-care, and perceptions and indicators of productivity.

As a way of measuring these relationships, we collect the following data from visitors: level of stress (pressure sensor), hours of sleep (typed input). We also want to understand the current state of mind an individual is experiencing upon entry to the show. To determine this, we will use Paul Ekman’s five foundational emotions (joy, sadness, disgust, fear, anger). Here we will use a keypad or coloured buttons.

 

Libraries; sound, minim.

This data, after testing, will be visualized into a live animation. The three biggest fears with anticipating are

1) coding simple data into a visually compelling form;

2) creating reliable and durable forms of input;

3) collecting cumulative data that relies on user involvement.

 

Classwork:

PImage source;
int increment=10;
float diam;
float z;
void setup() {
  size(512, 512, P3D);
  source = loadImage("baboon.png");
  noStroke();
}

void draw() {
  background(0);
  rotateY (0.5);
  source.loadPixels();
  for (int y=0; y<height; y+=increment) {
    for (int x=0; x<width; x+=increment) {
      int loc = x+(y*width);
      color pix=source.pixels[loc];
      diam = map(brightness(pix), 0, 255, 1, 5)*map(mouseX, 1, width, 10, 30);
      pushMatrix();
      translate (x, y, diam);
      fill(pix);
      box(diam/5);
      popMatrix();
    }
  }
  source.updatePixels();
  
}

 

 

Notes on Final Project:

A toggle button to see the path of movement of the objects in space, as opposed to the objects themselves. Also between showing a transparent fill, or just stroke.

Add noise to the movement path.

I connected my computer generated artwork with the potentiometer to change how lines are drawn in the circle.

//Circles and Lines_Nisala Saheed


class DrawLine {

  PVector point1;
  PVector point2;

  float angle;
  float angle2;
  float radius;

  float x;
  float y;

  float x2;
  float y2;



  DrawLine(float _angle, float _angle2, float _radius) {

    point1 = new PVector(x, y);
    point2 = new PVector(x2, y2);

    angle=_angle;
    angle2=_angle2;
    radius = _radius;
  }

  void update() {

    angle2 = angle * sin(modifier) * 4;

    x = center.x + cos(angle)*radius;
    y = center.y + sin(angle)*radius;


    x2 = center.x- cos(angle2)*radius;
    y2 = center.y- sin(angle2)*radius;

    angle += PI/120;
    angle2+=PI/90;
  }

  void display() {

    stroke(modifier, 220, 160);
    line(x, y, x2, y2);
  }
}



DrawLine myLine[];
PVector center;
float angle;
float angle2;
float radius;
int numLines = 15;
float change;
float increment;
float modifier = 0;

import processing.serial.*;

Serial myPort;


void setup() {
  size(600, 600);

  printArray(Serial.list());
  String portname=Serial.list()[31];
  println(portname);
  myPort = new Serial(this, portname, 9600);

  center = new PVector (width/2, height/2); // we need to know the center of the cirlce that we are drawing.
  angle = 0;
  angle2 = 0;
  radius = 100;

  change = map (mouseX, 0, width, 0, 10);
  increment = TWO_PI/numLines;
  myLine = new DrawLine[numLines];

  for (int i=0; i<numLines; i++) {
    float ang = i*increment;//this is how much the angle increments by.
    myLine [i] = new DrawLine (ang, ang*sin(3)*4, radius);
  }

  //increase i as an increment for the number of lines, until it reaches the desired number of lines
}
void draw() {
  //background(50);
  noStroke();
  fill(20, 30); 
  rect(0, 0, width, height);

  //if you want to see the center
  //ellipse(center.x, center.y, 10, 10);
  //draw the lines

  //change = map (mouseX, 0, width, 1.5, 3);


  for (int i=0; i<numLines; i++) {
    myLine[i].display();

    map(modifier, 0, 1023/4, 2, 3);
    myLine[i].update();
  }
}

void serialEvent(Serial myPort) {
  modifier = myPort.read();
  myPort.write(0);
}

void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
  Serial.write(0);
}

void loop() {
  if(Serial.available()>0){
    int inByte=Serial.read();
    int sensor = analogRead(A0);
    delay(1);
    sensor/=4;
    Serial.write(sensor);
  }
}

 

 

For my final project, I am considering creating an audio-visualizer. Most of the complexity of this should lie in coding processing, but I would need a sound sensor that can detect various frequencies. If such a sensor is not available I could create a relationship between a particular visual and how loud a sound it, or where it is coming from. This could take form in a small object that listens to music, or a larger piece that requires an individual to move within a designated space to impact a visual.

On the note of coding.

I have come to develop a particular relationship to the idea of coding. I used to consider it purely ambiguous and inscrutable numbers and words that randomly create some beautiful thing. However, after taking this class, I consider it something that is not one and the same as numbers. I think of it as a regularized, replicateable process. When we first explored processing, I wanted to begin creating graphics and beautiful images using the coding platform, despite having access to illustrator. In my frustration at my lack of skill in creating images in the software, I came to think of medium, and which medium is appropriate for what work.

As such, I consider processing and the logical nature of code and computing as a medium by which express myself.

 

One compelling idea, amongst many, stood out to me in today’s readings. The idea that digitization restructures the capitalist nature of artistic production. It’s written that “The old business saying is that ‘time is money, ‘ but what’s amazing about the modern Internet is how many people are willing to devote their time to producing online content without seeking any money in return”.

In an ever growing society, and subsequently, an expanding database of knowledge, one must consider the worth of their work. Often, as creative people, we are placed at the lower end of capital, because of monetary desire. Physical money or work to be exchanged for money become the centre of the conversation of production. What makes me happy about the process of digitization, is that people need a more sustainable resolve for producing work outside of monetary value. With the volatility of the art market, and the whims of large financial powers, the monetary value of what we produce is unstable, but the impact of work on people, their thinking, and being, transcend this instability.

 

Here is my data visualization for this week.

It takes a list of three values and uses them to create the x-position, y-position, and diameter of a series of circles.

 

//DataVisualization_Nisala

int data[];
String things[];
int radius = 200;

void setup() {

  size(600, 800);

  things = loadStrings("data.csv");
  // This array has one element because the file only has one line. 
  println(things.length);
  // Convert String into an array of integers using ',' as a delimiter
  //string array is returned, which we cast to an int array


  //println(data.length);
  noStroke();

  //noLoop();
}

void draw() {

  background(20);
  noStroke();
  strokeWeight(1);
  
  stroke(255,80);
  noFill();
  ellipse(width/2, height/2, 400, 400);


  for (int i =0; i<things.length; i++) {

    data = int(split(things[i], ',' ));

    float distance= dist(width/2, height/2, data[0], data[1]);
    if (distance<radius) {

      float c = map (data[0], 0, 600, 0, 255);
      noStroke();
      fill (50, c, c, data[2]);
      ellipse(data[0], data[1], data[2], data[2]);
    }
  }
}

 

 

“Design depends largely on constraints”. This brings up an important idea in the balance between what is aesthetic and what is functional. Pullin describes the tension in medical professionals in engaging with a medical market that places objects “in fashion” or subsequently “out of fashion”.

What this tension tells us is of the significance in art and, in this case, design in creating and shifting the zeitgeist. A topic we touched upon in class, we now see that the zeitgeist is closely referenced in the medical field which attempts to make disability invisible. But as our notions of what should and shouldn’t be invisible, we see eyewear, a marker of disability, move from the realm of the invisible to visible, and s marker of something more than disability.

Here we see an intersection in the politically rooted nature of art, and the functionality of design. Spectacle designs take a stance on the nature of disabiilty and then create a specific experience with its use that exist outside of its original and inherent function. Wearing well design glasses express wealth, at some point in time is represented intelligence. These are factors influenced by design.  Ultimately, someone can engineer a fantastic set of spectacles, but what purpose does it serve if the experience of an individual is out of their control.

 

Additionally, here is my sketch for the week using objects.

//Circles and Lines_Nisala Saheed

DrawLine myLine[];
PVector center;
float angle;
float angle2;
float radius;
int numLines = 15;

void setup() {
  size(600, 600);
  
  center = new PVector (width/2, height/2); // we need to know the center of the cirlce that we are drawing.
  angle = 0;
  angle2 = 0;
  radius = 100;
  float increment = TWO_PI/numLines;
  myLine = new DrawLine[numLines];

  //increase i as an increment for the number of lines, until it reaches the desired number of lines
  for (int i=0; i<numLines; i++) {
    float ang = i*increment;//this is how much the angle increments by.
    myLine [i] = new DrawLine (ang, ang*sin(3)*4, radius);
  }
}
void draw() {
//background(50);
noStroke();
fill(20,30); 
rect(0,0, width,height);

  //if you want to see the center
  //ellipse(center.x, center.y, 10, 10);
//draw the lines
  for (int i=0; i<numLines; i++) {
    myLine[i].display();
    myLine[i].update();
  }
}

class DrawLine {

  PVector point1;
  PVector point2;

  float angle;
  float angle2;
  float radius;

  float x;
  float y;

  float x2;
  float y2;



  DrawLine(float _angle, float _angle2, float _radius) {

    point1 = new PVector(x, y);
    point2 = new PVector(x2, y2);

    angle=_angle;
    angle2=_angle2;
    radius = _radius;
  }

  void update() {

    x = center.x + cos(angle)*radius;
    y = center.y + sin(angle)*radius;


    x2 = center.x- cos(angle2)*radius;
    y2 = center.y- sin(angle2)*radius;

    angle += PI/120;
    angle2+=PI/90;
  }

  void display() {
    
    stroke(21, 220,160);
    line(x, y, x2, y2);
  }
}

 

Casey Reas, amongst other things, presents works like “Signals” in which he explores how proteins communicate positive and negative signals within a cancer cell.

Randomness. A.I.. Control. Art. Design.

These are all words that exist in the conversation initiated by Raes of and by his work. his talk proceeds to describe the beauty and complexity of randomness in art, and a lot of his own creations, especially in using randomness and “jittering” come to represent much of the organic movements and behaviours we witness in day-to-day life, but cannot quite point to directly.

In describing his works he comes to an interesting notion: that, in creating randomness and behavioural traits, he is not interested in the particular position of an object and any given moment, rather the path of how they organize themselves. Not a moment, but the collection of moments. This idea translates to many tiers of the human experience, whether it be ideological and a way of conceptualizing how paradigms shift, or people and their movement in space.

For me, however, his work represented an important focus in the way we visualize data. How do we collect a point of interest and make it significant for an audience? It is not just Reas using a gimmick to make a pretty object move on a page. Rather the particular movement and the way that he represents that data provided us insight into an aspect of this simulated movement that is unseen to the naked eye.

This is one of my passions in design: to make the unseen, seen. To consider medium, process, and output. To create interaction. Such ideas of visual data and data processing applied in graphics, 2D, and static images. This, in some ways, describes interaction engagement and the exchange of knowledge as things that transcend literal physical interaction.

For the assignment, I recreated “Phase Pattern” by Manfred More with some movement.

//p145 "Phase Pattern" by Manfred Mohr

int w = 400;
int heightDisplacement= 90;
int lineSpacing=6;
float granulation = 0.002;

void setup() {

  size(600, 800);

  //noLoop();
  noFill();
}

void draw() {

  background(20);
  stroke(255);
  strokeWeight(1);
  float prevlengthAdjustment=0;

  for (int y =0; y<height; y=y+lineSpacing) {

    //noise(frequency) , sin a(x+b)

    line(0, y, height, y);
  }
  pushStyle();
  stroke(255, 255, 255);
  fill(0);
  beginShape();
  vertex(1, height);
  for (int x =0; x<width; x=x+8) {
    float frequency2 = frameCount*0.005- granulation*x;
    //-0.002 is granulation. It is to make the noise a little bit smaller. If it wasnt there it would look more random.
    //you multiply by 0.005 to slow down the frame. Otherwise its super fast
    //we multiply by x because it is changing by 1 everytime. If we didnt multiply it, all of the objects will do the same thing.
    float amplitude = 600;
    float adjustedNoise2 = (noise(frequency2));
    float lengthAdjustment2 = adjustedNoise2*amplitude;
    //noise(frequency) , sin a(x+b)




    vertex(x+1, heightDisplacement+lengthAdjustment2);
    //stroke(255, 255, 255);
  }
  vertex(width-8, height);
  endShape();
  popStyle();




  for (int x =0; x<width; x=x+lineSpacing) {
    float frequency = frameCount*0.001+ granulation*x;
    float frequency2 = frameCount*0.005- granulation*x;
    float amplitude = 600;
    float adjustedNoise = (noise(frequency));
    float adjustedNoise2 = (noise(frequency2));
    float lengthAdjustment = adjustedNoise*amplitude;
    float lengthAdjustment2 = adjustedNoise2*amplitude;

    line(x, 0, x, lengthAdjustment);
    line(x+1, 800, x+1, heightDisplacement+lengthAdjustment2);
  }
}

 

So, first of all, I am obsessed with processing. Second, here is my portrait for the class. I was interested in capitalizing on something distinct about my portrait. I decided to focus on my glasses and vest. I ended up mapping my mouse movement to a range of colours on my glasses, and then a series of colours in the background upon a mouse click. I’m excited to see what else I can do with this platform.

int r, g, b, vestColor, vestColor2;
int br, bg, bb;
int[] backgroundColor ={ color(237,234,212), color(65,175,175), color(107,79,138)};
int whichBG = 0;

  void setup () {

  size (600, 600);

  r = color (215);
  g = color (245);
  b = color (255);

  br = 237;
  bg = 234;
  bb = 212;




  vestColor = color (100);
  vestColor2 = color (65);
}

void draw() {
    background (backgroundColor[whichBG]);
//you need to reference the backgroundColor, because it is an array. so Always put in brackets for which value you are calling.
//generally you call color 1 by saying backgroud (backGroundColor[0]). but this time we want to call the color based on the click
//this is why we place the modulus in mousePressed, so that everytime you click, the modulus adds one. And when referenced by the array, is calls the right number.


  //   NECK
  strokeWeight (0);
  fill (163, 117, 67);
  rect (280, 300, 20, 150);

  fill (137, 99, 61);
  rect (300, 300, 20, 150);

  //   HEAD
  //   pt. 1
  strokeWeight (0);
  fill (188, 133, 63);
  rect (200, 160, 100, 170);
  triangle(200, 330, 300, 370, 300, 330);
  //   pt. 2
  fill (163, 117, 67);
  rect (300, 160, 100, 170);
  triangle(400, 330, 300, 370, 300, 330);

  //   EARS
  strokeWeight (0);
  fill (163, 117, 67);
  rect (190, 260, 10, 33);
  fill (137, 99, 61);
  rect (400, 260, 10, 33);

  // EARINGS
  strokeWeight (0);
  fill (80);
  rect (189, 280, 5, 10);
  rect (189, 270, 5, 7);
  fill (0);
  rect (406, 280, 5, 10);
  rect (406, 270, 5, 7);


  //   GLASSES

  //Scale the mouse Y value from 0 to 600 to a range between 215 and 105 
  //If the mouse moves down, the color changes
  float cRed = map(mouseY, 0, width, 215, 105);
  float cRed2L = map(mouseX, 0, width, 245, 100);
  float cRed2R = map(mouseX, 0, width, 100, 245);


  fill (cRed, cRed2L, 255);
  stroke (10);
  strokeWeight (10);
  ellipse (250, 250, 80, 80);

  fill (cRed, cRed2R, 255);
  ellipse (350, 250, 80, 80);
  stroke (10);
  line (310, 250, 290, 250);

  //   HAIR
  //   top
  strokeWeight (0);
  fill (0);
  beginShape ();
  vertex (200, 180);
  vertex (200, 130);
  vertex (320, 100);
  vertex (400, 100);
  vertex (400, 160);
  vertex (400, 180);
  vertex (380, 160);
  vertex (220, 160);
  endShape (CLOSE);
  //   sides
  rect (190, 130, 10, 130);
  rect (400, 100, 10, 160);

  //   SHIRT
  //   side I
  noStroke();
  fill (255);
  beginShape ();
  vertex (280, 400);
  vertex (300, 420);
  vertex (300, 520);
  vertex (190, 520);
  vertex (190, 420);
  endShape (CLOSE);
  //   side II
  fill (220);
  beginShape ();
  vertex (320, 400);
  vertex (300, 420);
  vertex (300, 520);
  vertex (410, 520);
  vertex (410, 420);
  endShape (CLOSE);



  //   VEST
  fill (vestColor);
  beginShape ();
  vertex (270, 397);
  vertex (270, 520);
  vertex (200, 520);
  vertex (200, 410);
  endShape (CLOSE);

  fill (vestColor2);
  beginShape ();
  vertex (330, 397);
  vertex (330, 520);
  vertex (400, 520);
  vertex (400, 410);
  endShape (CLOSE);

  if (mousePressed) {
    vestColor = 50;
    vestColor2 =0;
  } else {
    vestColor=100; 
    vestColor2=65;
  }


  //   BEARD
  //   partI
  fill (30, 200);
  beginShape ();
  vertex (200, 300);
  vertex (250, 340);
  vertex (300, 340);
  vertex (300, 370);
  vertex (200, 330);
  endShape (CLOSE);
  //   part II
  fill (0, 200);
  beginShape ();
  vertex (300, 340);
  vertex (300, 370);
  vertex (400, 330);
  vertex (400, 300);
  vertex (350, 340);
  endShape (CLOSE);

  //   mustache
  fill (30, 200);
  rect (270, 310, 30, 10);
  // rect (270, 315, 10, 10)
  fill (0, 200);
  rect (300, 310, 30, 10);
  // rect (320, 315, 10, 10)

}


void mousePressed () {

   whichBG = (whichBG + 1) % 3;
  
  
}

 

As someone who is very expressive about their emotional state, I found today’s article a valuable framework for how to process my flurry of feelings. In the context of interactivity and user interfaces, Visceral, Behavioral, and Reflective states of mind are useful concepts in directing an experience between a product and human. How do we ensure that an individual is aware of the functions of any given thing, and is in the right state of mind to use it? How can we change the way someone uses it depending on their state of mind?

Norman describes this in the context of a nuclear plant, describing the larger environmental design. When reflective processes are necessary for a sensitive area, humans require particular environments. If that area becomes the location of a high stakes situation, we must create just the right amount of stress to promote focus.

My only issue, one that Norman acknowledges, is diversity. What is stressful for one person is not for another, and vice versa. Along these lines, I pose the same question as before: How do we ensure that an individual is aware of the functions of any given thing, and is in the right state of mind to use it? But also, how do we account for this diversity. Diversity in ability, in psychological and linguistic associations, etc. My short answer is context and asking: Who uses what in what context? Or the more sinister and marginalizing question: Who do we want to use what in the contexts we choose? This question has most likely been asked in many political and institutional contexts and has come to deeply affect how we use our world, and how we view people and things that are undesirable. Doors on this campus are but one example, while the racially and ethnic segregation of the larger metropolitan area of Abu Dhabi is another.

Designers have the power to do good and include, but also marginalize. I only hope to do the former over the latter.

 

 

 

 

I have become increasingly interested in organic movement and mimicking it via mechanical means. Considering the skills I have come to develop with servos, my first thoughts moved towards a peacock or lizard. As I began to think of materiality and found that I might enjoy the cardboard texture on a lizard as compared to a peacock, an animal meant to be stunning and pristine.

The goal was to create a simple creature that would respond to an approaching “threat”. First, at a safe distance, the creature would light up, establishing discomfort. As one walks closer, it would growl, and when too close it would flare its fan to assert its dominance over the situation.

These reactions were centred around an IR Distance Sensor, which would calculate proximity. A series of LEDs would construct the eyes, a small piezo buzzer for the growl, and two servos connected to an difficult-to-glue set of fans.

The following is the code that organizes the system.

#include <Servo.h>

//For distance sensor: Establish which pin sends the signal, and which pin will recive it.

const int trigPin = 7;
const int echoPin = 6;


const int ledPinR1 = 13;
const int ledPinR2 = 12;
const int ledPinR3 = 9;

const int ledPinL1 = 8;
const int ledPinL2 = 5;
const int ledPinL3 = 4;


const int buzzer = 3;
#define ROAR 100

//Declare the servos
Servo servo1;
Servo servo2;

int servoPin1 = 10;
int servoPin2 = 11;

void setup() {
  // put your setup code here, to run once:


//The trigger pin sends the signal. THe echo pin recieves it.
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);

  pinMode (ledPinR1, OUTPUT);
  pinMode (ledPinR2, OUTPUT);
  pinMode (ledPinR3, OUTPUT);

  pinMode (ledPinL1, OUTPUT);
  pinMode (ledPinL2, OUTPUT);
  pinMode (ledPinL3, OUTPUT);


  pinMode (buzzer, OUTPUT);


  servo1.attach(servoPin1);
  servo2.attach(servoPin2);

  Serial.begin (9600);
}

void loop() {
  // put your main code here, to run repeatedly:

//  Send a signal, the stop sending a signal.
  long duration, distance;

  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(20);
  digitalWrite(trigPin, LOW);

//  Detect the signal sent.

  duration = pulseIn(echoPin, HIGH);
  distance = duration / 29 / 2 ;

  Serial.println (distance);


//Establish when each thing (LED, buzzer, Servos) does what, and when.

  if (distance <= 20) { // If at a CLOSE distance move the servos.
    servo1.write(100);
    servo2.write(100);
  } else {
    servo1.write(0);
    servo2.write(0);
  }


  if (distance <= 50) { // If at a MED distance move the servos.
    tone(3, ROAR);
  } else {
    noTone(3);
  }


  if (distance <= 100) { // If at a FAR distance move the servos.
    digitalWrite(ledPinR1, HIGH);
    digitalWrite(ledPinR2, HIGH);
    digitalWrite(ledPinR3, HIGH);

    digitalWrite(ledPinL1, HIGH);
    digitalWrite(ledPinL2, HIGH);
    digitalWrite(ledPinL3, HIGH);
  } else {
    digitalWrite(ledPinR1, LOW);
    digitalWrite(ledPinR2, LOW);
    digitalWrite(ledPinR3, LOW);

    digitalWrite(ledPinL1, LOW);
    digitalWrite(ledPinL2, LOW);
    digitalWrite(ledPinL3, LOW);
  }




  delay(100);

}

 

 

 

 

We also had to do some readings on physical computing and interactive art. Texts like these are always able to provide me with comfort in the notion of creativity as iteration. No ideas are original, but all ideas are unique.

Out readings on affordance and signalling speak to this idea, in that technology can be additive. Naturally occurring objects have particular forms of affordance, and as humans we add signals. Primitive hatchets and blades were mere sharp rocks many centuries ago. Now, however, we find ourselves in an intense era of weaponry. Of course, weapons aren’t the most advisable artistic creation, but creativity within the small scope of the 20th and 21st century can function the same way.

Instead of attempting to steal an idea, I hope to build off of others’ work. I also hope that we come to create a climate under the assumption of goodwill. If a work looks similar to another, we should praise dialogue between them. However, such ideas will take time to manifest in a capitalist structure. But I expect that we as artists, designers, and creatives reach this space.

I’m interested in mimicking organic movement. As such, I was thinking about creating a small bearded dragon model which fans in tandem with motion.

In exploring not only code but also how to create interesting sounds, Jana and I designed a small instrument that turns and creates noise as you play a note.

 

Our reading has been about converting what we can do into what we want to do. I find this a compelling idea, especially in the context of affordance and signifiers from the previous readings.

Within the context of their abilities, humans have innately, design, technology, and interaction become choices in the human world. We are able to decide how we translate what we can do into what we want. I find screens an interesting example in the text, as the screen is a flat surface. But in many modern phone applications, we find a reflection of physical affordances within the 2D frame. Sliding/swiping, turning, vibrating are forms of feedback that can be ways of mimicking less screen-based interaction. As technology becomes more and more a part of human life and experiences, what type of interaction and feedback become inherent characteristics of a world that we have regularly chosen to create.

A common trope in media is children in our generation not understanding the meaning of the save button on Microsoft programs. In a generation of humans that have never experienced floppy disks, the save button becomes the point of reference. What does the world look like when a simple analogue interaction is not the reference for new technology, but a screen-based gesture becomes the reference?

In the context of the capabilities of people, how do we design our world and translate these ideas, when newer generations don’t have access to older technologies that are viewed as outdated.