States of Exception and how we conceptualize humans in code
Tags: discuss, career, philosophy
Published: 2019-04-25 13:02:30

---
title: States of Exception and how we conceptualize humans in code
published: true
description: Agamben's critique of biopolitics as a thought experiment for code writers
tags: discuss, career, philosophy
cover_image: https://thepracticaldev.s3.amazonaws.com/i/eu8mogq6kudph356iiaf.jpg 
---

Giorgio Agamben’s [Homo sacer: Sovereign Power and Bare Life](https://www.sup.org/books/title/?id=2003) is powerfully topical in an era captured by refugee migrations and would-be indictments of an acting president. As a body of political philosophy and modern ethics it is commanding and orienting. However, I believe it also has very important stakes for software systems and the people who build them. We as code writers inherit the philosophies we write into our code from the larger attitudes around us, and the modern biopolitics that Agamben exposes and criticizes with *Homo sacer* are very actively manifest in the software we build and use daily.

Agamben enables his critique of states of exceptions in politics by examining the idea of a *homo sacer*, a person who exists in a paradoxical state of being both inside and outside the law. The term is best understood through examples: the victims of Nazi concentration and death camps, suspected terrorists housed in the Guantanamo Bay prison, and migrant refugees (who are outside the laws that protect citizens, but still handled by the law/law enforcement). Despite these extreme examples, the chief determination of *homines sacri* is that their political nature is one where, due to a paradoxical state of legal inclusion and exclusion, a sovereign can justify control over their natural, private lives, not just their public lives as citizens.
 
The term begins its life in classical Roman law where killing a *homo sacer* does not make a person guilty of murder, and the *homo sacer* can not be sacrificed. Which is to say: the status of *homo sacer* is a legal one, the law is acting upon them, however they are not protected from homicide. Agamben is primarily interested in exploring the paradox of a person who is simultaneously outside the law and under the influence of the law. He explores two similar but hierarchically disperate paradox states: The Sovereign, and the *homo sacer*. The Sovereign is made what they are by way of a legal condition, but as executor of the law, remain above and outside it. Meanwhile, the Roman *homo sacer* is a legally qualified person, but omitted from the law that protects a person from homicide. The *homo sacer*, Agamben writes, is a character of “bare life”: the law handles them as human-as-animal, qualifies them within itself, but does not afford them the rights of a citizen. It is, in other words, the state of legal exception, and used to justify a type of control that is not just political, but biopolitical: “the inclusion of man’s natural life in the mechanisms and calculations of power”. Importantly, as biopolitics eclipses politics, the *homo sacer* becomes increasingly unable to separate the state of natural life from the state of public, ruled life. In biopolitical frameworks, the sovereign commands direct control over the “bare life” of a citizen, and are best exampled in the concentration camps of the 20th century, where the political reality of the victims was indistinguishable from the biological reality they endured. 

While politically topical, this does not immediately present itself as information for an audience of software developers. However, Agamben’s purpose is to criticize, with pointed horror, the transition from a politics to a biopolitics. The problem is when the political abstraction of a living person, a citizen, becomes re-imagined as a biopolitical object: a bare life, qualified by an operational system, but not privy to its benefits and protections. 

Software has always had to think about human beings. We all write code that has a human user, and usually a user interface, and often we need to represent humans in our code: either in databases, or as objects that receive work from functions. 
At its best, I think software is a sort of tool with a cockpit, and anyone, any number of times, can come and sit in that cockpit and do a job. The developer needs to abstract a human at least enough to build that cockpit, but more often than not, the job being done involves abstractions of human beings: clients, prospects, customers, profiles, log-ins, etc. These non-user people are handled and qualified by our systems. They are paradoxically integrated into our framework and, like a *homo sacer*, both inside and outside our applications.

As we know, software at its worst can destabilize democracies and inflame political and sectarian violence. It can be addicting, manipulative, and dehumanizing. The mode of this destructive capacity is not unlike the mode of *homo sacer* biopolitics. The software created *homo sacer* reduces the human condition to a network of trackable database records: treated as natural lives which can be watched, manipulated, piped into grooming workflows. In other-words, they are controlled by the law (in this case the code), but as animals with incidental life: not abstracted citizens with granted rights. They are humans reduced to “bare life” within a controlling schema, and from the biopolitical perspective of a piece of software, like Facebook, the realities of natural life, become indistinguishable from the abstracted realities of the coded framework.

I imagine the ultimate extension of Agamben’s work is an exercise for developers who build systems that involve humans (which I should think includes most us). The game, as I play it, is to take a software platform and break all the humans involved into three categories:
+ The Sovereign: given power by the software, arbitrates specifics within the constraints set by the programs. Ex: a user with full admin power
+ The Citizens: people in your system that substantiate the system: just as a law is useless without a citizenry to "be" the law. Ex: objects in the database, or users with limited power. 
+ The *Homo sacer*: representations of human beings who are acknowledged by the system, and are reduced to their biopolitical "bare life". They are valuable only because they validate the power of the Sovereign and the protected status of the citizens.

I work for an education non-profit that enrolls students into summer programs. We have a lot of different softwares, but one of most monolithic is a database with lots of different action interfaces and control panels for the people who work here. We use the database to manage enrollment, and it’s something I touch almost daily. Playing the game with it looks something like this:
+ Sovereigns: our full time employees with admin access. Our Registrars.
+ Citizens: the students we enroll
+ *Homo sacer*: non-primary contacts in the CRM database. People related to students who get dragged into our database as emergency contacts, but aren’t benefiting from our services at all.

Facebook might look something like this:
+ Sovereigns: Zuckerberg, shareholders, dev teams
+ Citizens: Advertisers, data consumers
+ *Homo sacer*: you and me and all of our friends and family

Hubspot might look like this:
+ Sovereigns: Hubspot contractors, tech support teams, and devs
+ Citizens: Companies who contract with Hubspot, use their plugins widgets
+ *Homo sacer*: Typical users who do not disable cookie tracking


The implication here is that as we include coded abstractions of humans into our software, we need to acknowledge the possibility for Agamben-esque states-of-exception. We should take for granted that we are including *homo sacer* in our software: humans which are qualified by the code we write, that are actualized as objects with a natural life, but omitted from the ethical framework that we extend to those that primarily substantiate our system. I argue that it is our duty to look closely at the unfortunate *homo sacer*, and do what we can to treat them with dignity and humanity, especially while consumer protection legislation in America fails to demand as such. The mode of ethics here for software developers is certainly different from the purely political landscape that Agamben explores. It is hard to imagine software that does not in some way create *homo sacer*, and maybe that is a serious problem. Certainly, the biopolitical consequences of services like Facebook are far reaching, and that demands real attention. Yet, most of the software in the world is not Facebook, and the consequences of creating digital *homo sacer* are far less than creating politico-legal *homo sacer*. The lesson, for now, is that we can learn from the essence of Agamben’s ideas, and let them inspire a more critical approach to thinking about our job of abstracting humans into code.


*Cover image:* After the Massacre of Glencoe, Peter Graham / 1889