Written Component 3 (18/05/2021)
Author: Mario Alejandro De La Peza Diaz
Written component 2 (10/05/2021)
03/05/2021
Written Component 1 (26/04/2021)
100 Screengrabs (19/04/2021)
As a response to the “100 Screengrabs” brief, I decided to use one of the pieces of code I wrote used for my Elaborate project as my “snippet”.
Through the following 100 iterations, I explored different variations of responses, functions, shapes, colours, and movement to deepen my understanding of the concept of interaction and what can result from it.
27/01/2021
Following with my “Elaborate” project and taking into account last week’s tutorial feedback, I decided to further develop my investigation deepening on new questions:
These questions also encouraged me to find new references:
As a result, I became interested in the concept of “authorship” and how it relates to the interaction/negotiation between different entities to reach an experience. However, I considered important to clarify some concepts before continuing exploring.
Clarifying the previous terminology, I decided to analyze different types of interaction between different entities that build on top of each other. First, there is the interaction between the programmer and the machine, to create a code:
Then there is the interaction of the programmer with the code just created, manifested on an interface. In this case, I made five different codes, allowing five different interactions (iterations):
Being the programmer, it was interesting to notice that the interaction with the corresponding interface of each code brought surprises and situations I didn’t consider at the time of creation. Which makes me think of a sort of “power balance”, in the sense that the code still has some leverage over me -the programmer-, even tough I wrote it. Is this leverage what allows for it to be a negotiation? In my opinion it is.
However, it would be misleading to think of the previously described interaction as a user-code interaction, due to the fact that the programmer has previous knowledge of the code before actually interacting with its interface, since they created it.
Therefore, the next level on my analysis consistes on the interaction of two different users (who never before had engage with any of the codes in any way) with the same codes, in a period of 20 seconds, capturing the process every 5 seconds. These were the results:
Comparing the results of these two users and their interaction with the code, I could notice two widely different approaches:
As a next step, I could’t help ask myself what would happen if instead having interactions of only two entities, there could be interactions between three or more entities. Moreover, the notorious differences between the first two users made this question more interesting.
As a result, my next experiment consisten on a new level of interaction: user-user-code. I followed the same process (interaction in a period of 20 seconds, capturing the process every 5 seconds). These were the results:
And these are some reflections I got from it:
These iterations helped me to clarify some concepts for my investigation, form some opinions (so far) and and new questions:
01/12/2020
As a result of my first iteration’s feedback, I decided to take a more synthetic approach and try to simplify the notation system, avoiding being too literal and instead focusing on core elements of the actions that it intends to convey.
In that way, the new version of the notation system focuses on the movements needed to use a door. And given that there are many different type of doors, I decided to design individual “guides” depending on the type of door in question.
The three columns on each guide correspond to the point of view represented (front, top, rear).
20/01/2021
For the “Elaborate” brief I decided to take my “Pre-laborate” project, in which in turn I took my “Present” project to a new interpretation through Processing, a coding language I had never tried (or any coding at all, for that matter).
While in my “Pre-laborate” project I was interested in translating the notation language I had came up in my “Present” project, this time for my “Elaborate” project I want to explore the concept of interaction and what does it mean to analyze communication as a negotiation between two entities.
I’m also interested in pushing as far as I can the possibilities of the newly developed skills I have gotten in Processing, so the following exploration will be through coding and more specifically, through Processing 3.
As a starting point, I took the following references:
As a next step, I produced five iterations, all of them offering a system in which the user has the opportunity to “negotiate” with the interface, given the possibilities (and restrictions) that the code offers.
In such way, it is the process of interaction itself what draws my attention more so that the actual final outcome of the interaction.
Here you can watch the five iterations captured on video:
23/11/2020
One of the most common every-day-activities we do is going through doors. So common in fact that it would appear silly to do a notation system to explain their functionality.
But, how would it be if we had to explain how to use them, say to a visitor from another planet with whom we don’t have another way of communication other than symbols and images?
Here’s an attempt to answer that question. Does it work?
17/11/2020
To further develop my “Formulate” project. I decided to follow two different approaches.
First, I decided to use the information collected a week ago and present it as a different and unexpected way to know the city. For me, it was interesting to show not only the shapes that come out of a city’s grid but also the way they are drawn out and the atmosphere they are created in. That is why in the following videos, in addition to the process of “drawing”, the backdrop sounds are crucial to identify the essence of the city presented.
On the other hand, I decided to push to the limit the method I had developed las week, but this time with special focus on three key elements: the origin (and final destination), the scale of the map and the duration of the route suggested by google:
Taking these aspects into account, I repeated last week’s process (drawing simple shapes taking London, Mexico City and New York City as background) but this time with little but significant changes:
- This time always parting from a specific location each time: The British Museum for London, The Templo Mayor Museum for Mexico City and The Metropolitan Museum of Art for New York City. All three of them being museums and being located in a fairly central area of each city.
- Using 4 strictly geometric shapes with the same edge-length between nodes (triangle, square, pentagon, hexagon).
- Drawing those 4 shapes with routes by foot, by bike and by car taken from google.
- Repeating those four drawings increasing the scale each time (20m, 50m, 100m, 200m, 500m and 1000m).
After this, I got the following data bank:
Then, taking that same other, I decided to take the duration time in minutes of each one of the routes and putting it into Excel:
And finally, I filled each of the cells with a colour, according to different parameters, in order to create colour patterns and, as a result, graphic pieces generated with Excel in combination for google maps.
In this way, the combined subvertion of Google Maps and Excel in addition of functioning as a new drawing tool, can help to distinguish the differences in time mobility within each city and compared to each other in a new and unexplored way.