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: