Month: February 2018

Not gonna lie, this reading confused me at first. I wasn’t sure how what I was reading was relevant to the course material, even though I found it quite interesting. The link between universality in written language, such as numerals and the alphabet was interesting to me. Also, his example of pictograms started the reading in a very logical order where he continued to link this idea of universality into other fields. Moving into the context of computers, he continues the argument for universality in a coherent manner, but honestly, it was just a little confusing to me. I felt like it was super drawn out, rather than straight to the point which may have been more helpful.

I would like to start by saying that I intensely disliked this piece. I acknowledge that this chapter was part of a 270+ page book, needless to say it was lengthy. But what I disliked about it was not the length, rather the buildup to a condensed conclusion. I personally did not like history class growing up nor do I like this type of ‘academic’ writing. I’d rather read about greenies than how numbers evolved. Reading this piece felt like a 35 page drumroll with a 7 page ‘badumtiss’. Though the theme of universality is important, I wonder whether it was important to tease the reader with the  idea of this person or that one ‘almost’ making ‘the jump’.

Perhaps I am being too judgmental due to personal factors like frustration or lack of patience. But I feel as though I could have read the last two pages and the summary at the end and had a discussion that was more fruitful than the other 40 pages.

When reading this definition of interactivity, I can easily see a modification of it that clarifies it some in my mind: “two actors alternatively reacting to each other”. This clearly requires a definition to react, but that is most obviously the same as what it replaced in the original definition, input, process, output. His list of things that are not interactive are simply things that are not reacting to the person he is describing as the other actor. The scale of interactivity then boils down to the complexity of the reactions, with a twist. The twist is that one of the actors n every situation he mentions is a person, and when the other is a machine, the main target of this analysis, it is only the complexity of the reactions from the perspective of the user that matters. This is where is interactive and interface designer seem to differ. The interface designer hides the “unnecessary” parts of the reaction, while the interactive one reveals as much as possible to emphasize the complexity. By the definitions that I am using the reasons the interactive approach are obvious: making the machines reaction seem more complex make it seem more interactive, and the users reaction to this additional information actually do increase the interactivity, at the cost of efficiency of the primary task. That is unless the primary task is to get the user to think. With our definitions this could be rephrased as increase the complexity of reaction from the human user, which is a clear consequence of increasing the reactivity of the machine, an makes clear, at least to me, what makes an experience interactive and why that might be valuable.

Not much of the information in this reading was new to me, but the analysis of it certainly was. The initial analysis of the development of written language makes a lot of sense to me, though I think he glossed over a more fundamental point, the universality of spoken language. Also, while any alphabet is universal in theory, no language currently used is completely described by its rules and alphabet in any concise way. This is actually an instance of a common theme throughout the reading, where the mechanisms to achieve universality are in place but unused.

I also find it odd that when describing a number of early steps on the way to universality, in each of the categories of numbers, computers, and life-replicators, he seems disappointed that the rest of the jump to universality was not made, even saying that Babbage “should” have made the jump. While I entirely see the point that he “could” have, there seem to be strong implications of a necessity of universality being developed as soon as possible that is never quite justified. There is certainly an advantage to making the jump, but I was never convinced that it is a necessity.

Though the author states that he believes in the fluidity of the importance of definitions, his entire piece is talking about his own definition of interactivity. Therefore, my first impression is that the argument was going to be ‘wishy-washy’, not really adhering to his supposed definition of interactivity and thus making the whole argument weak. I was pleasantly surprised to not be extremely affected by his detachment from the term ‘definition’. What Chris Crawford describes seems to be more a classification and identification system rather than a concrete definition which in turn makes it more useful and in my opinion more easily understood. Especially when he concludes that this system was open to change as time progresses.

The piece itself was enjoyable as it seemed to be half scholarly argument and half extremely relatable to everyday situations. Most of his analogies made me chuckle and say “haha, yeah, true true”. Though I do not agree with the one about how the musicians do not interact with the dancing audience, what about when musician is asked for an encore or when they are able to change a set list in accordance to how the audience is reacting to the songs? Nevertheless, this relation to the everyday made his system easily understandable.

The first time I ever encountered the word ‘Interactive Media’ was during my Candidate Weekend. I was at the Farewell Dinner at Park Hyatt and Pierre came and sat at my table because all the other tables were full. While having dinner, he talked about how the style of writing has changed as what people read changed (Twitter, Facebook etc.) and many other things that I found so fascinating at the time despite the absence of speaking on our – all the candidates at the table – side other than the ‘deeply-considered “Yup”‘. Although I don’t remember a lot of the things that were said that night, I remember deciding that I want to take a course in IM if I get in.

The reading made me really nod when the writer mentioned that people often mistake reaction for interaction because I am/was definitely one of them. The example of plays especially talked to me because I have a high school friend who now studies acting at Tisch. She used to tell me all the time how acting is an interactive process  –  it’s a process in which the actors and the audience breathe and perform together. I never dared to argue with her but still sometimes wondered how interactive it actually is. Not to put her down or prove her wrong, but now when she gives me the same lecture again, I can smile to myself as I now know that this smart person who wrote a book on interactivity has asked the same question.

The chapter was a very interesting read. I liked how the writer analyzes interactivity by understanding how we ourselves speak. The writer classifies our speech to listening, thinking, and speaking. Where speaking is where the interactivity will take place (and a bit of listening too)

I am more into the backend and how the system works with algorithms and coding rather than a designer of the front-end so this was an interesting read for me as the front-end is a very important part of every product and I need to improve my, “Interactive designing” skills. Let me end my post with a quote from Steve Jobs:

“Design is not just what it looks like and feels like. Design is how it works.”

So I wanted to make use of the dusty LCD Display that we had in our kits, I searched for some tutorials on how to connect it, and did a simple hello world.

The next day, I started tapping on my desk to a beat, and felt like I wanted to make a “beat boxing machine”. But, I didn’t have a proximity sensor to detect movements and I didn’t want to use buttons as that seemed counterintuitive. What I did find in our kit though, was a photo resistor. I figured if I could connect it and detect when the light intensity is low(when you wave ur hand over the resistor) I could set up some arbitrary values and make the buzzer make some sounds.

It was relatively straightforward setting up the breadboard with all the components with the help of the tutorials. I learned that we need a potentiometer for an LCD to adjust the brightness so that it can be made visible in any light environment.

I found a function on the sparkfun website that converts frequencies into keys so I could actually play organ keys on the buzzer which was really cool. I also used code from the sparkfun examples to detect the light intensity from the photo resistor.

https://learn.sparkfun.com/tutorials/sik-experiment-guide-for-arduino—v32/experiment-11-using-a-piezo-buzzer 

https://learn.sparkfun.com/tutorials/sik-experiment-guide-for-arduino—v32/experiment-6-reading-a-photoresistor

I initially started with a system where I had to manually check the maximum light intensity and then manually enter it as the, ‘startVal’ variable. Then every decrease by 5 units from the startVal frequency would result in a different note being played in the buzzer. Later I improved the function so it keeps detecting the light intensity and updating a, ‘high’ variable so I knew the max intensity without the need of manually entering it. So now it had auto calibration.

Here’s a video of how it worked (I used my phone to bring it closer and further from the photo resistor to vary the light intensity):

I’ve also attached the code here:

#include <LiquidCrystal.h>

const int jumpVal=5;


const int sensorPin = 0;
const int buzzerPin = 9;
const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
int lightLevel, high = 0, low = 1023;

const int songLength = 1;
int starterVal;

char notes[] = "c";//dfda ag cdfdg gf "; 

int beats[] = {1,1,1,1,1,1,4,4,2,1,1,1,1,1,1,4,4,2};

int tempo = 113;

LiquidCrystal lcd(2,3,4,5,6,7);

void setup() {
 
  lcd.begin(16, 2);
  pinMode(sensorPin, INPUT);
  pinMode(buzzerPin, OUTPUT);
  
 
}

void loop() {

   lightLevel = analogRead(sensorPin);
   manualTune();
   starterVal=map(high, 0, 1023, 0, 255);
   lcd.setCursor(0, 0);
   lcd.print(lightLevel);
   lcd.setCursor(0, 1);
    
    int i,j, duration, prox;
    char noteNames[] = { 'c', 'd', 'e', 'f', 'g', 'a', 'b', 'C' };
    if(lightLevel<(starterVal-(jumpVal))) {
  for (j = 0; j < 8; j++)
  {
    int num=starterVal-(jumpVal*j);
    if (lightLevel<num) {
      notes[0]=noteNames[j-1];
      lcd.clear();
      lcd.setCursor(0, 0);
   lcd.print(lightLevel);
   lcd.setCursor(0, 1);
      lcd.print(noteNames[j-1]);
      
      } 
    }
  for (i = 0; i < songLength; i++) 
  {
    duration = beats[i] * tempo;  

    if (notes[i] == ' ')          
    {
      delay(duration);            
    }
    else                          
    {
      tone(buzzerPin, frequency(notes[i]), duration);
      delay(duration);            
    }
    delay(tempo/5);              
  }
} else {
        lcd.clear();
      lcd.setCursor(0, 0);
   lcd.print(lightLevel);
   delay(100);
        }
 
}

void manualTune()
{
 if (lightLevel < low)
  {
    low = lightLevel;
  }

 
  if (lightLevel > high)
  {
    high = lightLevel;
  }
  lightLevel = map(lightLevel, 0, 1023, 0, 255);
  lightLevel = constrain(lightLevel, 0, 255);

} 

int frequency(char note) 
{
 
  int i;
  const int numNotes = 8;  
  char names[] = { 'c', 'd', 'e', 'f', 'g', 'a', 'b', 'C' };
  int frequencies[] = {262, 294, 330, 349, 392, 440, 494, 523};



  for (i = 0; i < numNotes; i++)  
  {
    if (names[i] == note)        
    {
      return(frequencies[i]);    
    }
  }
  return(0);  
              
}

Building onto my project from last week, I’ve decided to give the brave souls that successfully complete my insanely difficult maze a sweeter reward than just LEDs lighting up. I originally hoped that I could somehow have Arduino play a short tune (mp3) but then I realized that it actually isn’t that simple. I’d have to utilize this device called “the shield” — which I had no clue how to put together.

I opted for the next best thing: have the LEDs blink out the rhythm of the song I intended to play while I manually produce it with my mouth. (#lol)

The “song” begins the moment the player reaches the end of the maze.

Excuse me for my bad singing: