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.
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.
In this text, there are multiple topics that I feel the author addresses and ties in nicely with the evolution of universality. I will not address all of them as that would make this blog longer than it is already going to be.
Firstly, the author starts with an introduction to pictograms and how these evolved into our current writing system. I believe it is important to note that pictograms, while not always the most practical thing, can be universal. They just need to be used differently than the author interprets. The book
Common images used in emojis.
was published in 2012 (Deutsch), and so since then emojis have become popular. While they might not always be used to express complex ideas, there is some value to these objects. Windows even had their own style of emojis before they became mainstream and these were known as Wingdings. (Vox 2015) Throughout the reading of the pictograms evolving, all I could think of were Wingdings and emojis and how people have come full circle, back to using a type of pictogram.
Towards the end of the reading, he builds on how computers had to move into digital, as analogue would never have reached universality. This section served to denote the discrepancies between analogue and digital which were two words I have always heard but never known the distinction between. Not only that, but I gained insight on the origin of computers as well.
Overall, there is the uniting theme of universality and its implantation throughout various topics, and I quite enjoyed how he tied together the history/evolution of scripts, numerals, computers, and genetics. He took what I thought were random topics and explored a new facet of them.
Sources:
Deutsch, David. The beginning of infinity: explanations that transform the world. Penguin Books, 2012, intro.nyuad.im/wp-content/uploads/2015/08/Untitled-4.pdf.
Edwards, Phil. “Why the Wingdings font exists.” Vox, Vox, 25 Aug. 2015, www.vox.com/2015/8/25/9200801/wingdings-font-history.
To expand on my switch from the previous assignment, I decided to use one of the more basic codes that we learned in class. Wednesday, in class, was the first time that I have ever coded. After the class ended, I become pretty overwhelmed with all the new content I was learning and couldn’t really wrap my head around how each line of code was working. I asked my friend if he could go over the code with me again so that I made sure how each line worked and how they interacted with one another. The code I have used is, therefore, more simple than the one we inputted in class because I wanted to understand the really simple codes before getting into the more advanced codes (e.g. I didn’t use “bool”, only “int”).
I decided to run probably the most basic lines of code, which is to let the LEDs blink, i.e. one LED would be on initially and when the pedal was pressed, the other would light up but the initial LED would not. When let go, the newly lit LED would go off and the initial LED would light back up.
I connected my wires and LEDs in the way shown in Figure 1 below.
Figure 1: Arrangement of the Wires on the BreadBoard and Red Board
The improvement and the lines of code are simple, but in terms of its relation to the use of the foot pedal, if the second LED were to be another colour (like in the video above) and were brighter, playing the drums could become almost like a light show. Creating a light show that follows the beat of the drums could be pretty fun! Music festival-worthy, perhaps!
served to denote the discrepancies between analogue and digital which were two words I have always heard but never known the distinction between. Not only that, but I gained insight on the origin of computers as well.