For fear of sounding like a George Orwell fangirl by (mis)quoting him twice in two weeks, all language is political.*
What do I mean by this? Not that all language falls somewhere on a political spectrum, but that power relationships play out on a linguistic level. Language does not (or tends not to) exist in a vacuum: its purpose is communication in some guise or another. Using language implies a speaker/writer and an audience: either one or several readers, or one or several listeners. A conversation is language between equals; a monologue is something of a power relationship fait accompli.
More than this, when I say that all language is political I mean that all language is inflected by the user. In an structure where words had a single inherent meaning, apolitical usage might be possible, theoretically: if a word meant only what it purported to mean, and did not draw on the history of its usage and associations, objectivity might be possible (and how much more limited would language use be). But this is not the structure of human language: our words seek to make connections outside and beyond themselves; they are contextually meaningful as well as inherently.
After Babel, there can be no such thing as objective language, because all use is a kind of interpretation or translation. Objective language could only exist where there is a one-to-one mapping of signifier and signified, to use Ferdinand de Saussure’s terms. Given that the word for something is not the thing itself, an intermediary layer of interpretation exists, which taints the language with the bias of the interpreter. All language use is coloured by both the speaker and the receiver – by their beliefs, received wisdom and attitude; in short, by their cultural baggage. All language is a representation of (the speaker’s) reality, not the reality itself.
Apolitical coding structures and anti-languages
If all language is political, all programming must be political therefore, given I have previously defined software programming as language.
But it does not require my argument that code is language to follow Juliane Tveten’s argument that code is political: the Anglocentricity of our major coding languages is proof enough that code is inflected by the position and status of the coder. A coder must be fluent enough to write her functions in (American) English, because the major programming languages are written in English – even those written outside the States. For now, even those programming languages which do not take English as their base need to be able to interact with English languages if the coder requires a truly robust software application.
Digging a little deeper below the surface reveals rather more than just the Anglocentricity of code: the subjectivity of the designer colours more than the linguistic geopolitics of coding language. The structure of software appeals to traditional binary ways of thinking: it is predicated on a logic of 1s and 0s which are defined in opposition to one another. Opposition is the traditional way of thinking logically: our reality is structured and made sense of through binary pairings, not least that of self and other, but also male and female, heterosexual and homosexual, black and white, right and wrong. Our day-to-day embodied lives are experienced somewhere on the spectrum in between. This is a queering of logic for which there is little room in software code: in binary thinking there is no in-between.
Tveten explores how it might be possible to make a programming language feminist, or trans, or anti-feminist, and how it might be possible to change the system from within by repatterning or renaming structures and functions of code. The more radical projects reject the logical basis of the binary logic of software: reimagining programming languages requires an overhaul. Zach Blas’s queer programming anti-language seeks to interrupt the flow of circulation between heteronormative culture, coding, and visual interface.
transCoder uses imagined structures and functions to defy the binary logic of software (ones and zeroes) as a larger critique of identity binaries (male versus female, heterosexual versus homosexual). For instance, running the matrimonial function “iDo” causes a computer to self-destruct, while “metametazoan” deletes all language “that is representative of gender binaries” and “sets everything in the program equal to itself.”
Clearly, it is a programming language that achieves little of itself: causing a computer to self-destruct somewhat limits the opportunity for transCoder to integrate with other languages in an application. transCoder is as linguistically exclusive as the Anglocentric languages, in that it does not allow linguistic cross-pollination or interfacing.
It is hardly the point of Blas’s project to integrate, however – it is solely a conceptual language. His anti-language cannot coexist with traditional programming language, and in refusing to do so Blas subverts the notion of the utility of code and objectivity of programmers. In considering the possibility of trans code, the structuring of “normal” code is revealed to be anything but objective and apolitical. Rather, the logical basis on which software code is founded is seen to be as contingent on social realities as those codes which propose alternative logical bases, or indeed other languages. Technical language is no more protected from having a political bias or from reinforcing a social status quo than any other form of language. As Tveten writes,
Just because certain forms are technical, it doesn’t mean they don’t have social or political influence. Computation can’t have this pure, objectified, position-from-nowhere objectivity. Objectivity is marked in influence specifically by who you are and where you are and what you’re bringing to it.
Apolitical code does not exist: as a product of human thinking, it is a language coloured by the status and subjectivity of its writer. The myth of objective knowledge cannot be shored up by technical, so-called apolitical or emotionless software languages. Code’s reliance on binaries shores up the traditional oppositions of our own thinking, but it reveals those binaries to be socially contingent.
On “sexist” algorithms and avoiding groupthink
Viewing the language of code as playing out the power struggle of subjectivity is nowhere more obvious that in the output of the code itself: in the decisions that are made as a result of the algorithms designed by the coder. An algorithm is a set of sequential instructions or operations that act as a decision-making point in code: a form of automated reasoning.
As Caroline Criado-Perez writes (pp. 165-6), we
…use algorithms every day: they are in our computers, in our washing machines, and, of course, on the Internet. They are silently shaping our lives. But while they themselves may seem like harmless processes that help us day to day, they are by no means free from societal baggage, because each algorithm is designed by a human (or a team of humans), meaning that subjective values, interests and biases will inevitably affect the algorithm’s design and output.
In other words, the way we program software to execute functions and to make decisions is not only inflected by the (implicitly exclusive) language we use to write the code, the design itself is affected by the positionality of the designer. It is the decision-making process of the designer which structures the decision-making process of the algorithm, which means it is the lived experience of the designer which informs the associations between concepts and the natural progression of statements executed.
Last year Google’s web search algorithms were called sexist, with a research team from Carnegie Mellon University reporting that the company displayed more prestigious job listings to users believed to be men. There are any number of ways that systemic biases could have crept into the algorithm, from historical data about the gender pay gap, or the pipeline to positions of leadership to the designer’s own uninterrogated beliefs.
While to a certain extent the bias of the designer can be mitigated in several ways (using a diverse team of collaborative designers is linked to reducing groupthink and fostering better decision-making, for example, and designing with the end user group in mind perhaps introduces more of the imagined end users’ subjective biases than the designer’s), fundamentally flaws in algorithms such as these demonstrate. technical language is just as susceptible to subjective influence as any other prose. In fact, it is supposed objectivity which makes software design so insidious: its subjectivity must be recognised in order to be challenged.
Passionate coding, dispassionate prose
I would go so far as to contend with Haraway et al that objectivity in knowledge, in language, does not exist. All knowledge must be situated and partial, because knowledge is embodied in the knower – “knowledge” is a theoretical concept until it is known – and is therefore limited by the knower’s partial perspective. Objectivity is not a realistic end goal: it is not that some have an objective view of the world and others are limited, but that all knowers, writers, designers, have a necessarily finite point of view.
This means that the language that we use to code, to write decision-making algorithms to process web searches, and the like, embodies the politics of the writer and imposes the designer’s worldview on the end user. The struggle between the designer’s worldview and the end user’s is a power struggle – one that the designer is likely to win, given that the interpretation or execution of software is rather more rigid that the author declared dead by Roland Barthes.
Moreover, however, it means that we must invest in collaborating with diverse thinkers who can root out systemic biases. If code can’t be objective, its subjectivity must be layered with multiple points of view. Since all coders are human and subjective (for now), all language is political; even software code.
Turns out that in software programming, as in all things, there is no such thing as dispassionate prose.