This chapter was a very insightful read in terms of showing me a different way to look at IT advancements in regards to economy and profit.
The interaction between computers was of particular interest to me. We tend to frame the discussion about interaction just around people and objects – not between two objects. That’s why the experiment regarding the searches for housing and consequent increase in the prices introduced a new way to look at it for me. It sounded a way too familiar to the experience I – and pretty much everyone – keeps encountering when buying flight tickets.
Under no circumstances can I let the algorithms know that I need the tickets for a specific day, to a specific destination – otherwise the prices always skyrocket the next time I search for the same thing. Therefore I always feel like an ultimate criminal, using a different browser in an incognito window to look for and compare flights. I never looked at it from the perspective of interaction – that pretty much with no human interference whatsoever, the portals are able to communicate and exchange the information of when and where I want to go and make a profit out of it. This a force that was not even thought of a couple of years ago.
It’s fascinating how such advancements in the field of IT can be transferred into the advantage of economic profit. This is also reflected in the approach the authors take at the beginning of the chapter when describing how innovations in software can be costly initially, but replicated and reproduced with almost no cost. The analogy of atoms in products and products made of bits made it very easy to understand.
What is more, the redefinition of “time is money” really resonated with me. As discussed in the chapter, since people can publish anything pretty much anywhere online, a lot of them do it without seeking profit and produce information freely. However, the world of the internet created new conditions that laws have troubles adjusting to – especially in terms of copyrights. Since anyone can create, copy and share, when it comes to actually claiming what is supposed to be yours, it becomes increasingly more difficult.
This week’s assignment offered a lot of freedom in terms of what to do. Maybe, for my indecisive soul, a little too much of it. Coming up with an ‘art piece’ from scratch was above my end-of-the-semester exhausted creative capabilities – so I decided to take on a slightly different direction and make an already existing art piece interactive. I also wanted to learn to work with images, so this was a perfect opportunity to do so.
I took the most mainstream piece of artwork you can find – Mona Lisa- and gave her hands that move with the cursor. I started with slicing existing images in Photoshop, getting rid of the background and creating a png. The code is very similar to what we did in class- but writing it on my own and mending it to what I needed to achieve with this assignment actually helped to contextualize and understand Object Oriented Programming a lot more. I did not want to research much and attempted to write the code with as little outside help as possible.
The only issues I encountered was figuring out how to place and rotate the hand images. I knew how to do it with small objects that were drawn in Processing, and it took me a lot of trials and errors until I got a hang of it. What is more, I wanted to make the disco lights a little more interesting by adding some randomized blur to them, but using the filter(BLUR) function slowed down the image so much that the hands stopped moving smoothly- and I rather dropped the idea.
Another difficult part was getting used to thinking in terms of classes and not linear lines of codes. But, to be honest, it made the code incredibly neat and clean and made it very easy to change things up (especially pictures), whenever I wanted to trie or change something. Now I really can see why there is so much hype around it!
Here is the main code followed by the class code:
Hands handL;
Hands handR;
PImage Mona;
void setup() {
size(640, 460);
//loading the image of Mona from a folder
Mona = loadImage("hey mona final.png");
//locating where the cookies will be when cut out of the cookie cutter
handL = new Hands(150, 500);
handR = new Hands(400, 600);
}
void draw () {
background(0);
//Disco lights that follow the cursor - there is a little randomness in strokeweight, colors and lenght
for ( int i = 0; i < 5; i++) {
pushMatrix();
strokeWeight(random(1, 3));
stroke(random(255), random(255), random(255));
line((random(width)), random(height), mouseX, mouseY);
popMatrix();
}
//locating Mona to her spot on the screen
image(Mona, 0, 0);
//cutting the exact cookies out
handL.update();
handL.displayL();
handR.update();
handR.displayR();
}
Thinking of design as depending largely on constraints – as quoted in Pullin’s chapter, was a very negative perspective to look at it through. Though I consider myself to be a person with a tendency to view things rather negatively, surprisingly, I tend to think of design through all the possibilities that it can open. This negative way, however, implies that all of us are ‘disabled’ in a way and that good design helps us navigate through life with more simplicity and ease.
Yet I understand the point Pullin was making – the framework of thinking about design through constraints illuminates the border between design for functionality and design for visual pleasure. This, however, poses the questions of balance and how exactly to maintain it without compromising one or the other. But, as Pullin further develops, designing for actual disabilities, can have immense formative factors on how the disability is perceived by the society in the first place. Quite a big responsibility, isn’t it?
What, however, strongly resonated with me was an implication of capitalism and how some of the benefits of modern research in design cannot be applied to the research in design for disabilities – simply because it would not be financially profitable as not as many people would buy it.
It reminded of a certain group of pharmaceuticals called ‘orphan drugs’ – drugs for diseases, that however, are not commercially developed and sold as companies are concerned about the level of profitability. Therefore, people with real conditions cannot get them treated because their condition is rare, and there would simply not be enough demand on the market to motivate the companies to satisfy it.
Though this is stretching it a little too far, the fact that designing for a disability is affected by such twisted forces of capitalism too, really makes me question the society as a whole – and what it is able to sacrifice in order to make a profit. There is so much potential, as Pullin vividly discusses, to destigmatize disabilities and integrate people of all needs through design. Yet the development and research of such are severely limited by ridiculous constraints of capitalism.
This week’s assignment was to recreate one of some older computer arts from the Triangulation webpage. I decided to make the Gaussian Distribution one – which seemed simple at first but turned out to be quite challenging to replicate. It’s just a bunch of dots distributed in different densities- well yeah, but… maybe not for me.
My first instinct was that all the dots are densely located around a horizontal line and gradually decrease density the further you get from the line. Yet I failed spectacularly trying to approach this logic – also rethinking that now, it would not reflect a small degree of wavy imperfection in the distribution.
Plan B was to define certain segments of the background to which I will assign a certain number of dots. Through layering them on each other and overlapping them I could imitate the distribution effect – though not perfectly. I played around with different segment sizes and numbers, as well as the number of dots in each.
The problem I encountered using this approach, was that the segments started showing in straight almost fully defined lines, which caused the gradual distributive effect to disappear. To “blend” these segments more I was thinking of defining them within a curvy segment rather than a rectangular one. Which worked in theory, but I could not make it work by myself. Yay.
Therefore I tried blending it through decreasing the dot number but increasing the number of segments. Not perfect, but the best I could do. Fake it till you make it does not always apply.
This is the original version:
And this is my replication:
In addition, I also played a little bit with interaction. I was interested in what happens when I delete the noLooop() command, and the result made me feel actually really uncomfortable- a bunch of tiny little objects moving quickly and uncontrollably. It almost reminded me of a hive of bees.
That’s why I made the highest concentration of dots to follow the mouse cursor (similarly to what bees do) and if the space bar is pressed, the number, as well as the size of dots, start increasing until they pretty much consume the whole screen.
Sound on for an extra experience:
And last but not least, the code:
//setting up the number of dots used in different segments
int numberCirclesA = 700;
int numberCirclesB = 1000;
int numberCirclesC = 3000;
int numberCirclesD = 5000;
//setting up variables for x, y locations, and width of the dots
float x;
float y;
float w = 3;
void setup() {
size (800, 390);
//noLoop(); // to be activated only to see the exact replica of the original image
}
void draw () {
background (255);
noStroke();
fill(0);
//if the space key is pressed then the number of circles and their size increase
if (keyPressed) {
if (key == ' ') {
w = w + .5;
numberCirclesA = numberCirclesA + 2000 ;
numberCirclesB = numberCirclesB + 1000;
numberCirclesC = numberCirclesC + 1000;
numberCirclesD = numberCirclesD + 1000;
}
//if space bar not pressed, their return to their original values
} else {
w = 3;
numberCirclesA = 700;
numberCirclesB = 1000;
numberCirclesC = 3000;
numberCirclesD = 5000;
}
// different segments in which the dots are being drawn
//mouseY is added to the Y location to make the segment follow the mouse cursor
for (int i = 0; i < numberCirclesA; i++) {
pushMatrix();
x = random(0, width);
y =random(0, height-15);
ellipse (x, y, w, w);
popMatrix();
}
for (int i = 0; i < numberCirclesB; i++) {
pushMatrix();
y = (random(110, 150) + mouseY);
x = (random(0, width));
ellipse(x, y, w, w);
popMatrix();
}
//
for (int i = 0; i < numberCirclesA; i++) {
pushMatrix();
x = random(0, width);
y = (random(0, height -30)+ mouseY);
ellipse (x, y, w, w);
popMatrix();
}
for (int i = 0; i < numberCirclesB; i++) {
pushMatrix();
y = (random(40, height - 70) + mouseY);
x = random(0, width);
ellipse(x, y, w, w);
popMatrix();
}
for (int i = 0; i < numberCirclesC; i++) {
pushMatrix();
y = (random(20, height - 150)+ mouseY);
x = random(0, width);
ellipse(x, y, w, w);
popMatrix();
}
for (int i = 0; i < numberCirclesD; i++) {
pushMatrix();
y = (random(60, height - 200)+ mouseY);
x = random(0, width);
ellipse(x, y, w, w);
popMatrix();
}
for (int i = 0; i < numberCirclesD; i++) {
pushMatrix();
y = (random(40, height - 175) + mouseY);
x = random(0, width);
ellipse(x, y, w, w);
popMatrix();
}
//tracking the mouser cursor
print(mouseX);
print (" ");
println(mouseY);
}
The discussion on what is art and what is not is a very slippery slope- and I was very happy that the presentation did not take the course of trying to prove that computer art is legitimate, but already spoke of it as such without an inch of doubt. Instead, he introduced a couple of mesmerizing and inspiring ideas that made me question the way I look at creating art, ideas behind it but also the way I design things.
One of such things was the idea of imprecision within symmetry. It made me think that I use these kind tricks without even realizing it- just adding one slight element off-grid, using a color outside the palette or a different shape. Because making something stand out is difficult to achieve by 100% symmetry. What you achieve with perfect symmetry is an expected satisfaction, but you miss out on an element of surprise that catches attention. And in the case that Reas discusses with the receptors that are wired in three different ways but each of them is a little imprecise (which causes them to move similarly but slightly different)- it not only makes it more interesting but unveils a completely new way of behavior and patterns.
It reminded me of what we were talking about in class- and that is the difference between random and noise and how noise adds the “off-grid” element by still maintaining a sense of symmetry and order.
But who makes the decision about the amount of randomness that we include/should we include? And, as discussed on the example of dots within a perfect grid that move by an increasing number of pixels- where is the line between what is clearly in order/symmetrical with a slight deviation and what is completely chaotic with no sense of order, symmetry or patter whatsoever? Can it be generalized or is it based on how individual brains are wired?
This week’s assignment was to create a self-portrait in Processing. It felt a little counterintuitive to draw using lines of code, especially regarding time. Why should I draw a shape for like 5 minutes coding the exact position of vertices, while I can open Illustrator and have the same shape done it a matter of seconds? The answer came when I wanted to add some cool effects. And that got me very excited for all the possibilities that opened with this initial exercise.
For this assignment, I mostly I used the beginShape() endShape() function but to get some practice, I experimented with triangles, rectangles, ellipses and all sorts of shapes. Definitely the hardest one to crack were arcs and its angles – though they are very simple, I had to revisit high school trigonometry for that which opened some painful memories. I also googled a lot and the game-changing hack was to track your mouse cursor using “print” so you know the exact coordinates. Cannot even say how much time this has saved me. Also smooth() function is very great as it makes the corners look less robotic and more finessed!
Overall I created a very simplified version of me with some pastel colours and lazy triangular pseudo shadows to add some structure. And when you put your cursor to my necklace my hair (and eyebrows) go crazy. Yay.
I can’t even imagine what it must have felt like to be a woman working in IT in 1960s. Great amount of prejudice, underrepresentation, pushback, judgement or any other form of sexism are still extremely pressing issues nowadays not only in IT and STEM fields but in any working environment in general. And although the article only subtly touches the gender related struggles of Hamilton’s experience and mostly advocates for retrospective recognition of her great achievements, it still strikes me of how far we have come and how far we still have to go regarding this matter.
After finishing the article, I felt a strong sense of admiration for Hamilton. Her story is very similar to thousands of other women who had to get out of the rigid boxes that society put them in. It captures the struggles they, equally qualified employees, had to go through while their male colleagues did not. And how much less space they had for creating any mistakes. Let’s say Hamilton was male. Would they have still considered the code she wanted to add as unnecessary?
What is more, Hamilton achieved a breakthrough in a field that did not even exist at the time – she succeeded in it before they managed to declare it a male dominated industry that she would have no place in. And the fact that her, and probably many other women helped set foundations to software as we know it today, puts the whole “IT is a man’s world” argument into question.
I must admit that prior to reading Norman’s chapter, I was thinking of attractiveness of design as a bonus – something that makes some people feel more comfortable using it, but never as something that has direct biological ties. That beautiful design is perceived to be easier to use (almost like a placebo effect – which is still a valuable one) rather than to actually be easier to use. Therefore, to me, it was quite eye-opening to read Norman’s scientific reasoning (communicated in a very simple and approachable way) on why, from evolutionary perspective, making people feel good and relaxed or stressed and tense has an effect on how they use and experience the product. And in result, how it shapes the usability of the product itself.
Yet it all sounded a way too good, a way too simple and I got very skeptical. As if there was a general pattern based on the way all of our brains are wired to follow when designing. Then Norman saved it a little and added crucial points about how some of these mechanisms are “predispositions rather than full-pledges systems” and “one person’s acceptance is another one’s rejection.” And though the points on visceral, behavioural, reflective experience introduce a new, more strategic and thoughtful way of designing not only the product but the experience with it as well, the conclusion is left very open.
To me, it raised many more questions: if there is a clash, is it the fault of the product or of the individual using it? Where is the line and what is the extent to which the designer is supposed to predict one’s affect and adjust the final product to it? Is it even possible to do it? And while Norman’s chapter offered really great points and fresh perspective for consideration, it feels like another extra kilo was added to the burden that designers carry. Norman introduced more factors (though very crucial ones) to consider, which make a designer’s job even more impossible than it was before because humans are diverse and confusing.
This was very entertaining to read (the LED Fetishism category was my favourite)- as I was scrolling down the individual projects, I could find so many similarities with the projects that have been done in the class already (I am guilty of the gloves and dancing mat). And reading a line “What took me several weeks when I made it in 1999, could be done in about an hour today” also made very grateful for the technology that enables us to create, so much faster and push the boundaries further.
However, it’s so easy to slip into thinking that when we get an idea, we are the first ones ever to get it. And unless it’s original, we should not do it. At this point, creating something completely original and from scratch is close to impossible. It’s not shameful to make a thing that was already made before- the problem is not adding anything new and unique to it. Though the essence of an idea stays the same, there are limitless possibilities of how to implement it – yet, the balance between originality and plagiarism is again very fragile.
I was also pleasantly surprised by the consideration of inclusivity – and how flat black screen does not provide any feedback whatsoever to a blind person, as well as inclusivity in “the body-as-cursor” section. This is not a topic that I would find often in relation to arts. Designers are more inclined to be more inclusive when it comes designing interaction of everyday objects and technology. Yet for interactive art, which heavily relies on a typical anatomy of human bodies without any challenges, it’s an implication that is often not considered. It really made me think whether is it even possible to be inclusive for all within one interaction and how to keep this in mind when designing.
The article written by Tigoe was very short, but consisted of very crucial points. When I saw the title, I got a little scared because I get easily irritated by meaningless debates about what is art and what is not, yet this one offered a good insight into the world of Interactive Art.
I loved the analogy to theatre and the working process between an actor and a director – though I had some directing experience, it never occurred to me that the nature of such interaction can be so easily projected to designing an interaction and made me think of the process a little differently. You can suggest through various hints, but you cannot tell them what exactly are they supposed to feel, do and experience (in both theatre and interactive art).
What I also agree with is Tigoe’s argument of giving hints, and proving basic context for the user to get them started. This should eventually made the user actively listen, start and successfully continue the conversation without a designer’s intervention . Yet this is communicated very simplistically, as if it was implying that the process of making interactive art is simple and black and white: either done right or done wrong. Yet the lines between what is a sufficient of a hint enough are very blurry and thin. This applies also to providing “basic context” which differs significantly from person to person, consequently making it very difficult to establish such hints and context that would work perfectly for every single user. User testing, adjustment and compromises are needed along the way. This, however, is not a critique- it’s more of an implication that I missed in the article, which does not contradict the argument whatsoever, but rather extends it.
