Software development is polysingular. The various frameworks and models developed for computer programming are essentially translations of the world’s complexity into electricity and back.
Computer languages enable us to realize the same process using multiple possible ways. The basic building blocks of programming are variables (basic building blocks), classes (types of things) and objects (things themselves). Various functions define the affordances that each object can have. The variables, classes, objects, and functions come into dynamic relation to the user through executable code and affect the surrounding complexity.
One important element of computer code is its immanence. Once the machine is running, it’s ruthless in its intention to fulfil the code. This is the main difference that sets machines apart from humans: they don’t change their minds. Even if the machine has a learning process embedded, it’s still mainly driven by the algorithms of learning that were preprogrammed. There is no space for irrational. Therefore, while programming is polysingular to a certain extent, it’s not polysingular in its ability to reinvent itself. The number of options given is finite and the way they can morph one into another is limited.
Nevertheless, programming is the language we can use to create interactive paradigms that are polysingular in their essence. Conditional statements (such as “if… then… else…”) define the branches of pathways available. Loops (while… do…) and cycles (for…) ensure that there’s a rhythm and consistency to what the functions can do.
Every time we are in front of a computer or using an interface let’s remember that at the core of it we are interacting with a multitude of objects, classes, variables, and functions, most of which are loops. These loops come together and produce temporary areas of non-equilibrium stability, which enable streaming videos, transmission of texts, responsive links and buttons. The software that’s polysingular also carries within itself a certain dysfunctional pathos, it disrupts the way we normally do things. There are not so many examples of polysingularity in programming, but the websites like Coub.Com (short video loop format), ThisIsLike.Com (rhizome-like network of knowledge), Google Maps (love the possibility to create polysingular routes to the same destination), GitHub (multi-branch version control system) are at the forefront of introducing polysingularity to the software we use. However, as most of the programs are so rational we need to introduce more irrationality into them. Human is the last agency for meta-polysingularity: the process that enables polysingular entities to reinvent themselves in polysingular fashion. Therefore we absolutely need humans to behave irrationally with their own software tools and the software tools, while designed rationally, need to provoke their users for irrational behavior. It’s only through this combination of machine and human that we’ll be able to achieve a true polysingular process of constantly shifting between islands of non-equilibrium stability, while maintaining each of them for a moment of time when it’s relevant to the situation we find ourselves in.