At first, I didn’t understand where the author was going with this text. However, his example of the Waze app really clarified the ‘digitization’ dialogue of the text, that due to it, we have new ways of acquiring knowledge and also, higher rates of innovation. These are two things that will form the next generation of the digital age. However, I think the most interesting part of the text for me was that as humans, our science will get better and better as digitization improves. This possibility seems so exciting for the future of research as it gives us more and more access to answering questions we never thought we would have the ability to answer. This made me wonder if/to what extent computers will ever reach the speed, depth and complexity of the human mind?
I found this reading extremely interesting because I had never given much thought to how applicable design (in terms of fashion not just functionality) is thought of in specialist products. To me, it seemed intuitive to focus on functionality as opposed to aesthetics when talking in context of disability. However, now that I’ve read this, it makes so much sense to me that fashion should be an integral part of a good design as it truly does explore freedoms beyond the constraints society may hold. Moreover, I strongly agreed with the authors point that discretion in such things just means we are ashamed of them, which should not be the case, e.g. the example of eyewear. I think functionality is of course very important but aesthetics are key too. Many specialist products are extremely intimate to their owners and are part of their identity and experiences.
Lastly, I really liked the author’s point about simple design not necessarily meaning easy design. I think this is something that I overlook a lot. A lot of work can appear simple on the surface but the mechanics behind it run very deep, inversely, some things may appear very complex but are in fact simple and I think that’s all up to how good the design is.
For this week’s assignment, we were supposed to create something with OOP. I wanted to create some sort of meditative art work (e.g. snow/rain falling) but along the process of learning how to form a “class” and other programming, I made this. I kind of ended up liking this more (despite its lack of clear purpose).
Drop [] dropCollection = new Drop [70];
void setup() {
size(400, 400);
smooth();
for ( int n = 0; n < 70; n++) {
dropCollection[n] = new Drop (random(0,width), random(0,height));
}
}
void draw() {
background(187, 178, 255);
for (int n = 0; n < 70; n++) {
dropCollection[n].run();
}
}
I decided to recreate the cover from August 1977 called ‘Random Squares’ by Bill Kolomyjec:
My recreation:
I made my recreation using line(), A LOT of rect(), translate() and push/popMatrix(). I feel like there most definitely must be an easier way to create this but (knowing my lack of programming skills) this was the method I chose to go through. I also decided to play around a little with what we learned in class with keyPressed(), and the different functions associated with float, and I definitely did not get what I wanted to achieve but I liked my ‘happy accident’ anyway and I was pretty proud of it.
Reas’ talk deals with the concepts of ‘order’ and ‘chaos’ in the artistic world – both these elements provide an exhaustive range of possibilities that can exist. Many digital artists within the last half millennia and specifically the last decade have really expanded this field of idiosyncratic designs and abstraction. I really liked Reas’ installation of turning something artificial into an organic art form at 3:2o as this art form really appeals to me as I’m someone who always seeks to find patterns in nature. I also found the movement and emergent growth portrayed by his later work (as portrayed at 29:00) to also be very appealing.
I really liked his concept about ‘using a rational machine to do something random’ and taking the time to understand this form of digital art as a ‘sum of the whole’ (looking at the last decade) as it made me gain more respect for abstract art as a whole, which I previously found arbitrary and futile.
I can’t decide if I really enjoy processing or find it really frustrating (probably both). Although, I played around with with the beginShape() endShape() functions and also the vertex() function, I couldn’t make them nice enough to include in the final sketch. So instead, I decided to stick to a simple version of myself made with all sorts of shapes (this part was fun).
#1: Her Code Got Humans on the Moon—And Invented Software Itself
Software engineering, a concept Hamilton pioneered, has found its way from the moon landing to nearly every human endeavor.
The article introduces Margaret Hamilton, mother of software engineering, and one of the most prominent figures that were part of the Apollo space mission. Two main points I got from this article were:
1). Hamilton is a renowned source of inspiration for all women in the tech industry, an industry that’s predominantly male (even more so during her time). Her uniquely ambitious life and undeniable robustness is pretty amazing and she is definitely not given enough recognition in the programming world. I found it very interesting reading about her story of the pilot01 issue where she was told that the issue “would never happen” and yet it did. Her intuition to debug is such a critical aspect of being a modern programmer, portraying how ahead of her time she was. I think being prepared for any crashes is a very important part of this work.
2). The concept of the ‘software’ didn’t really exist until then. I found it really interesting that the budget for the Apollo hadn’t even accounted for such a thing to a be a part of the project – and yet, it probably ended up being the most important factor of the mission.
#2: Attractive Things Work Better
The author explains why attractive things work better (they produce positive emotions which in turn make it easier to negate minor errors or difficulties). I found it really interesting that the author broke the though processes down into three fundamental levels:
Visceral: at this level, we are at our simplest and most primitive. As we are incapable of reasoning and building upon our schemas, the appearance of design and the creation of good first impressions matter the most. I think this is the level that amateur designers (me, personally) tend to focus on the most without regarding the next two.
Behavioral: here we are able to alter our actions according to some level of analysis.
Reflective: by far, I think this is the most important level for designers. At this level, humans are very sensitive to experiences, training and education. We are also most vulnerable to variability through our different cultures and our experience/usability can have many individual differences. I think the factor of attraction also becomes relevant at this level as reflection also requires the awakening of long-lasting emotions and emotions are what we associate with beauty. Thus, any successful product will provoke reflection in the long term.
However, in general, I believe a designer must know his/her audience well in order to comply with the demands that come with all three levels of processing. Although, fundamentally each is important, the reflective element is the most sensitive to humans and should therefore be given as much thought.
#1: Making Interactive Art: Set the Stage, Then Shut Up and Listen
This blog post’s main message is to not “interpret your own work”. The author argues that interactive art does not require an explanation from the creator as this takes away from the interactive element of the art in the first place. It should be the audience’s decision and interpretation of your art that allows the ‘conversation’ to occur between them, you and the art.
Personally, I agree with this sentiment to some extent. I think a very important part of interactive art is its ability to be understood and performed by everyone without the need of too much interaction or explanation on the creator’s part, as its goal should be to allow its own interpretation to take place without interference. However, I also think that some art works may need some sort of introduction to them – not to interfere with the perspectives of the audience – but maybe as a form of introduction and aims. Although, if this could be done in a discrete way in which the creator is not involved, it would be ideal.
Looking at all the examples of physical computing in the author’s list made me super excited for the endless possibilities that computing opens into the world of interactive art. Most forms of work that were listed did seem the typical projects that most of us have seen before (either on the internet, art galleries etc.); however, I agree very much with the author when he says that although these projects have been done multiple times, people shouldn’t give up as they still “allow a lot of room for originality”. I felt this constructing many of my own projects for the class as they felt “unoriginal” sometimes but adding my own layer of creativity or perspective to them is what made the projects so personal and fun to make still.
My inspiration for this project was a painting by my favorite artist Van Gogh (the Sunflowers) and I also wanted to create something that I would want to keep in my personal space. Therefore, my midterm project was a mimic of a ‘sunflower’ – a flower that would follow the direction of light.
I initially also wanted to make a flower that would open and close (as recommended by Aaron but despite trying to different methods – I felt as if I would be limited by time if I continued. So instead, I created my final one using two photoresistors and a servo.
For my code, since I used only one pin for both my photoresistors, the code was not too complicated. I used the sensor value (servoValue) to produce the values for which the servo should turn (servoTurn) and initially let this begin at a 90 degree angle. I also added a delay at the end so that allows the servo to reach the position indicated before the sensor senses anymore changes.
#include <Servo.h>
int sensorPin = A0;
int servoPin = 9;
int sensorValue = 0;
int servoTurn = 90;
int tolerance = 20;
Servo myservo;
void setup() {
Serial.begin(9600);
pinMode(sensorPin, INPUT);
myservo.attach(servoPin);
myservo.write(servoTurn);
// sets the degrees to which the servo is to be positioned
}
void loop() {
sensorValue = analogRead(sensorPin);
Serial.println(sensorValue);
// print the sensor values
if (sensorValue < (340-tolerance) )
// perform the first check if the value read from before is less than the difference between 340
{
if (servoTurn < 180) servoTurn++;
// ++ increments x by one and returns the old value of x
// perform a further check that the servo is not > 180
}
if (sensorValue > (340+tolerance) )
// value read by the sensor is compared with the sum of 340 + tolerance
{
if (servoTurn > 0) servoTurn--;
// check that the angle the servo is located is not less than 0
}
myservo.write(servoTurn);
delay(50);
// allows the servo to reach the position indicated before sensor sensing changes
}
For my midterm project, I want to create some sort of arrangement that imitates the relationship between sunflowers and the sun, an ode to my favorite artist. I am aiming to use servos, LEDs and photoresistors (and hopefully either a motion detector / humidity sensor too).
