- with a clear structure the simulation can be more heterogeneous
- aggregate materials and references
- no need to be SUPER discoursive
- could be evocative
- think are.na channels on instagram
- intro as a readme file
- Could be interesting to read What the Dormouse Said
```
## SETUP
Notes:
- simulation as writing machine
- outline simulation key points:
- Suspension of judgment
- Discrete temporality
- Partiality
- Orientation
- aknowledge software as cultural object
- and propose software documentation as a surface
- to renegotiate the making of software
- to create entry points
- to question who gets to participate
- plan
---
This introduction is not a written as a text, but runs a simulation.
This introduction is not a written as a text, but runs a simulation.
Coding Contingencies (CC) is a procedural take on how different characters got to code.
Coding Contingencies (CC) is a procedural take on how different characters got to code.
How did they choose a particular programming language, a coding paradigm, a development environment, an infrastructure where to run the code, and so on? These are not just technical choices, but rather coding contingencies.
How did they choose a particular programming language, a coding paradigm, a development environment, an infrastructure where to run the code, and so on? These are not just technical choices, but rather coding contingencies.
@ -14,7 +51,7 @@ Using the simulation as a writing machine we can articulate these CC with some b
1. Suspension of judgment
1. Suspension of judgment
Within the scope of the simulation it's not necessary to label good or bad choices.
Within the scope of the simulation it's not necessary to label good or bad choices.
(That would have been the case for a machine learning writing device, for example)
_(That would have been the case for a machine learning writing device, for example)_
One character could decide one morning to write their own operative system from scratch using Red Stone circuits in Minecraft, and it would be fine.
One character could decide one morning to write their own operative system from scratch using Red Stone circuits in Minecraft, and it would be fine.
Due to the nature of the process, even the most absurd starting point it's a valid and powerful narrative device.
Due to the nature of the process, even the most absurd starting point it's a valid and powerful narrative device.
In this way it becomes easier to explore marginal cases, improbabilities, and non-conform situations.
In this way it becomes easier to explore marginal cases, improbabilities, and non-conform situations.
@ -31,95 +68,20 @@ Using the simulation as a writing machine we can articulate these CC with some b
Partecipants entangle gradually, and do not come as a monolithic block.
Partecipants entangle gradually, and do not come as a monolithic block.
They can be imagined as lines: merging together and branching away, tying and loosening knots. (Ingold)
They can be imagined as lines: merging together and branching away, tying and loosening knots. (Ingold)
This leads to multi-facets characters, where not all the elements needs to interact with each other all the time.
This leads to multi-facets characters, where not all the elements needs to interact with each other all the time.
Their interfaces can be loose, they don't need to be one hundred percent compatible to come together. (Haraway)
Their interfaces can be loose, they don't need to be one hundred percent compatible to come together.
4. Orientation
4. Orientation
Zooming in and out from the particular, we get a glimpse of a more gradient and diffuse process.
Zooming in and out from the particular, we get a glimpse of a more gradual and diffuse process.
A subtle sense of direction emerge from the initial randomness.
A subtle sense of direction emerge from the initial randomness.
(By design) the simulation sees software as a mean to orientate these trajectories.
(By design) the simulation sees software as a mean to orientate these trajectories.
How does certain programming languages facilitate certain ways of thinking, and totally block some others?
How does certain programming languages facilitate certain ways of thinking, and totally block some others?
This procedure helps us to think about software as cultural object. Something "deeply woven into contemporary life –economically, culturally, creatively, politically– in manners both obvious and nearly invisible." (Software Studies, 2009), and not just as technical tool existing in a vacuum.
This procedure helps us to think about software as cultural object. Something "deeply woven into contemporary life –economically, culturally, creatively, politically– in manners both obvious and nearly invisible." (Software Studies, 2009), and not just as technical tool existing in a vacuum.
## notes for the intro
## REQUIREMENTS
- Discrete Temporality
Notes:
- a way to present how the hype for a particular coding language grows
- ie: list of trending video on yt, threads on twitter, conferences
- how languages get popular and then forgotten
- how these istogram video of language popularity are done ? find sources
- temporality could also be a way to explore events of the past
- not every simulation must be set in the present
- (or rewinding back simulating causes instead of effects)
- ie: Ulman account on childish developers culture (Close to the machine, Life in code)
- ie: Richard Gabriel timeline for example (Pattern of software)
- Temporality could also be non uniform!
- ie: using the timespan of new commits in a version control system, gradually fading away when a project stops being maintained
- Could be interesting to read What the Dormouse Said
- Suspension of Judgement
- exploration of margins, fy shuffle and normal distribution
- uncommon or absurd setup (why are they absurd?) (what is the norm?)
- meta exploration: or exploring thing we dont understand (software as unknown?) (like esolangs)
- a way to investigate and build on disproportion of means:
- ie: all the js of react + all the css of tailwind + all the backend infrastracture of netlify to run a TODO list
- ie: the extreme quest for frugality in permacomputing projects such as 100R or DuskOS
- is not redemption arc for bad guys
- Partiality
- (that could also be read as multiplicity)
- focus on the same actor in different contexts:
- ie redstone circuits
- used to develop a virtual minecraft into minecraft itself
- but also cited by hito steyerl when talking about the overflowing of internet into real life, as well as the sinking of real life into internet
- but also expanded by modders to build different red stone dialects, forking the original one
- another example is:
- reclaimed technology
- tech deployed for military purposes recontextualized for medical uses (find exact references look at software studies lexicon or bridle ! ways of being)
- Orientation
- level of details
- zoom out to outline trends
- less about single characters
- more about their surroundings
- online communities! investors! sponsor! etc.
- and then zoom in for wrapping up
- ideally: to a distance within reach ? is this naive?
- structure
- other than these four features of the simulation there should be a structure
- with a clear structure the simulation can be more heterogeneous
- aggregate materials and references
- no need to be discoursive
- could be evocative
- think are.na
- [SETUP]
- intro as a readme file
- brief & accessible
- intro as simulation
- aknowledge software as cultural object
- and propose software documentation as a surface
- to renegotiate the making of software
- to create entry points
- to question who gets to participate
- outline key points of simulation as writing machine
- Suspension of judgment
- Discrete temporality
- Partiality
- Orientation
- [REQUIREMENTS]
- need things to simulate
- need things to simulate
@ -132,86 +94,21 @@ This procedure helps us to think about software as cultural object. Something "d
- programming languages
- programming languages
- use cases
- use cases
- how to define things?
- Latour ~ Haraway ~ Barad
- ANT ~ kin
- OOO
- more than the parts
- less of what it does
- every piece of source code is is only ever partial (Marino, 2020)
- the whole is less than the sum of its parts (Harman, )
- OOO quadruple object
- Software as unknown
- Generate data
- Generate data
- use references as elements
- Ulman, Gabriel, 100R
- [ITERATE]
- Explore a combination
- Visit each element and elaborate on it
- Highlight aspects of simulation
- Repeat
- Repeat with other combination
- Need to understand how to format this!
- Meaning: One after the other or all in parallel?
- TBD
- different ways to approach the relation betwen software and context
- list of references
- possible references to build the dataset
- Weathering Software Winter (100R)
- Weathering Software Winter (100R)
- Close to the Machine, Life in Code (Ulman)
- Close to the Machine, Life in Code (Ulman) (focus on episode)
- Pattern of Software, (Gabriel)
- Pattern of Software, (Gabriel) (focus on episode)
- Red Stone Fenomenology?
- Red Stone Focus?
- P5js issues?
- P5js accessibility issues?
- Paged.js?
- Paged.js?
- Screenless Office?
- Screenless Office?
- Tidal Cycles?
- Tidal Cycles?
- Python and diataxis?
- SI16?
- SI16?
- Need to understand what does make sense and what doesnot
---
- when things are vivid enough go on
- [INSERT DOCUMENTATION AS ELEMENT]
- introduce documentation as new element in each simulation
- look what it does, how it ripples through the system
- which other element relates with documentation?
- who has to write, who get to write, who is addressed, how is sustained, etc
- articulate critical points
- [WRAP UP]
- software as a mean to orientate narratives
- narratives as a mean to orientate software
- documentation as a surface to explore
- how to situate our use of code in the world
- which context ? situated software
- why it matters for me!!!!!
```
------+.
|`. | `.
| `+--+---+
| | | |
+---+--+. |
`. | `.|
`+------+
```
Software Contingencies
the simulation
first we need things to simulate:
first we need things to simulate:
@ -231,12 +128,6 @@ to avoid that
let's define actors not for what they are but for what they do
let's define actors not for what they are but for what they do
(that is fun bc then i wrote grandma, that means functional grandma, that means not someone that has grandchildren but someone that does grandparent functions ??? ok this is not fun anymore and i am sorry)
(that is fun bc then i wrote grandma, that means functional grandma, that means not someone that has grandchildren but someone that does grandparent functions ??? ok this is not fun anymore and i am sorry)
> notes
- expand simplest simulation: few elements, 1:1:1 relation
- more context for the ooo statement, or keep it for later
- the grandma joke is not super fun
- actors
- actors
- web designer
- web designer
@ -266,16 +157,16 @@ let's define actors not for what they are but for what they do
then we need to combine thigs from the three categories
then we need to combine thigs from the three categories
00 web designer, rust, activism
0. web designer, rust, activism
01 teacher, python, work
1. teacher, python, work
02 grandma, rust, fun
2. grandma, rust, fun
03 interaction designer, vvvv, art
3. interaction designer, vvvv, art
04 musician, pure data, work
4. musician, pure data, work
05 musician, haskel, research
5. musician, haskel, research
06 student, python, art
6. student, python, art
07 student, javascript, work
7. student, javascript, work
08 student, javascript, fun
8. student, javascript, fun
09 graphic designer, haskel, research
9. graphic designer, haskel, research
...
...
@ -290,6 +181,84 @@ the random generated series is random, and its first element is random as every
but taking a step back, zooming out, one wonders: which element is the first? where is the declaration of intents?
but taking a step back, zooming out, one wonders: which element is the first? where is the declaration of intents?
could the command that generate the random series be the first, significative, element of the series itself?
could the command that generate the random series be the first, significative, element of the series itself?
## ITERATE
Notes:
- Explore a combination
- Visit each element and elaborate on it
- Highlight aspects of simulation
- Repeat
- Repeat with other combination
- Need to understand how to format this!
- Meaning: One after the other or all in parallel?
- TBD
- Different ways to approach the relation betwen software and context
- Discrete Temporality
1. Temporality could also be a way to explore events of the past
not every simulation must be set in the present
ie: Ulman account on childish developers culture (Close to the machine, Life in code)
ie: Richard Gabriel timeline for example (Pattern of software)
2. Temporality could also be non uniform!
ie: updating using commits in a version control system, gradually fading away when a project stops being maintained
- Suspension of Judgement
1. exploration of margins
uncommon or absurd setup
why are they absurd?
what is the norm?
2. proxy exploration
exploring thing we dont understand
software as unknown?
ie: esolangs
3. a way to investigate and build on disproportion of means:
ie: contemporary infrastracture to code a TODOs app
ie: quest for frugality in permacomputing projects
- Partiality
that could also be read as multiplicity
1. Focus on the same actor in different contexts:
ie redstone circuits
used to develop a virtual minecraft into minecraft itself
but also cited by hito steyerl refering to the overflowing of internet into real life,
as well as the sinking of real life into internet (steyerl)
but also expanded by modders to build different red stone dialects, forking the original one
ie reclaimed technology
tech deployed for military purposes recontextualized for medical uses
(find exact references maybe in ways of being) (bridle)
- Orientation
- level of details
1. zoom out to outline trends
ie coding language hype
how languages get popular and then forgotten
trending on yt, threads on twitter, conferences, investors! sponsor! etc.
less about single characters
more about their surroundings
online communities!
- When things are vivid enough go on
---
now that the setup is done, the simulation can start.
now that the setup is done, the simulation can start.
to build something meaningful out of these random combinations we can balance between what is defined and what is not.
to build something meaningful out of these random combinations we can balance between what is defined and what is not.
@ -298,6 +267,7 @@ leveraging on the unknown of the simulation gives room for narrations.
so for example we have #04
so for example we have #04
```
```
a musician what is their background?
a musician what is their background?
which kind of music do they play?
which kind of music do they play?
where are they based?
where are they based?
@ -310,6 +280,7 @@ for work which kind of occupation?
is it for interactive installations?
is it for interactive installations?
to teach sound design?
to teach sound design?
for live gigs?
for live gigs?
```
```
see how there are a lot of open questions in the first and third fields, while the programming language is slightly more defined and fixed. this is a good starting point. obviously a programming language is vast and complex and with dozen of features one could be interested in, but for the sake of our system it is useful to leave these things unsaid.
see how there are a lot of open questions in the first and third fields, while the programming language is slightly more defined and fixed. this is a good starting point. obviously a programming language is vast and complex and with dozen of features one could be interested in, but for the sake of our system it is useful to leave these things unsaid.
@ -323,3 +294,34 @@ which particular aspect of pure data resonates with their view of the world?
is it the open source nature and the licensing of the source code?
is it the open source nature and the licensing of the source code?
the welcoming community thriving around the programming language?
the welcoming community thriving around the programming language?
or the visual paradigm that facilitates the thinking about and connecting abstractions together?
or the visual paradigm that facilitates the thinking about and connecting abstractions together?
## INSERT DOCUMENTATION AS ELEMENT
Notes:
- introduce documentation as new element in each simulation
- look what it does, how it ripples through the system
- which other element relates with documentation?
- who has to write, who get to write, who is addressed, how is sustained, etc
