design – Alex De la Peza

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).

09/11/2020

As part of my “Formulate” project, I decided to stretch the functionality of Google Maps, one of the apps I use most frequently. However, this time I wasn’t interested in knowing the location of nowhere or get the directions to nothing. This time I set myself to try to DRAW with Google Maps.

To get started I thought of simple shapes and if it would be possible to achieve them. I chose straight-line figures, so I had clear “touching points” I could refer to. Then, using London as a base, I asked Google Maps to give me directions to each of the edges of each figure as destinations. This way I got the directions to do each route by foot, by bicycle and by car.

The results were interesting:

After doing this, I wondered what would be the results if I did the exact same thing, but in a different city. So I chose two different cities, each one of them more different than the other: Mexico City and New York City. To do so, I followed the same parameters, including the scale.

For me, it was interesting to explore how mucho would these figures change, especially considering the very different conditions between cities, such as their layout and their relation to water (London has a river going through the middle of the city, Mexico City sits on top of a lake but no longer has a connection to it, and NYC IS pretty much an island in the middle of a river).

Finally, I found it captivating to compare each one of these options between each other and find out what happened:

So far, for me has been interesting to explore all the possible outcomes there can automatically be in Google Maps asking for a route and using the exact same points as destinations, only changing the way of transportation and the cities in question.