DEV Community: Sam Osborn

Mindfully Objectifying the Human Condition

Sam Osborn — Wed, 30 Oct 2019 20:10:01 +0000

Typically, we write code that will at some point represent a human as a symbol.

It might not be an exaggeration to say that the most symbolized idea in art is the human. However, in art that symbolic human is usually a conceptual person, not a living one. Whatever good or harm can be done by artistically symbolizing a human, is exclusively ideological.

In software that has a human user (most of it), the symbolized human is not only an ideological imposition, it is a biopolitical reality. Software regulates, mediates, and entangles our interactions with reality. Symbolic abstractions of humans in general have material, far reaching, and biopolitical impacts on specific human beings. This is especially true with code that is implemented in the healthcare and finance sectors, but is generally true across the board.

Consider this code:

@historic_participants = @profile.archived_participants.select{|p| p.applied?}

It's familiar as something one would find in a Ruby on Rails controller. We're making an instance variable @historic_participants that is a list of historic participants we want to iterate, probably in our view.

Let's itemize the humans we are abstracting into code:
We've got a @profile. That's a human with frustrations, desires, emotions, and aspirations. They are a biopolitical agent, who we don't necessarily know and probably won't ever meet. In this case, they've logged into our website, and we're keeping track of who they are using some client-side data. @profile is a concept in code, but will be instantiated as a person eventually. A person who is trusting us with their email address, a password (which they are probably recycling), and other important information about who they are. Information that could make them vulnerable to biopolitical exploitation. We have a humanist obligation to imagine @profile not just as an instance variable inferred from a cookie, but also as a specific human to be treated ethically or not.

We've also got p. The .archived_participants() method is returning an array of people, and we're going to select from that array, just the ones that have applied?. Logistical details don't matter here. What's important and true is that to do a pretty mundane job, I've ended up holding in my software-hands a pile of humans, and I'm now going to touch each them, anonymously and real fast. As a code writer, this is happening all symbolically, and I'll never even see it explicitly. Won't even know the names of p as they exist. Yet, {|p| puts p.information} reveals enough information about each of these anonymous folks to engage in low-level identity theft. There are, always, biopolitical implications in the human-abstracting code we write.

We are fundamentally objectifying humans as data-objects to make them casually handle-able. When human beings become anonymized objects of biopolitical manipulation, it's basically always a road to human rights abuse. We are only beginning to fully understand the ways in which this process degraded our agency and manipulated us into shopping, believing, and voting in curated ways. Person-as-p reductionism looks like targeting p with personalized ads to make them not want to vote in the 2020 election. It looks like custom insurance pricing because p has pre-existing medical conditions. It looks like AI-assisted sentencing of p in a criminal court because there are more cases than judges can process. It looks, and is biopolitical.

Facing the Problem

Techno-spiritualism offers an unexpected opportunity to engage with this problem. Throughout history we have defended humanist ethics by sacralizing the human condition. There are diverse theological vehicles for this. Humanist ethics could be equally understand through Christ's passion or a pagan neo-Platonic human ideal of unimpeachable potential. It's not possible to mention all the roads one can walk toward theologically sacralizing the human form into an ethically defensible condition. What I will mention is that UCS characters make almost all of them available in code! However you choose to theo-aesthetically legitimize you neighbors, it probably exists as a code-executable UCS character that can be parsed as a variable in your language of choice.

@historic_participants = @profile.archived_participants.select{|ᛗ| ᛗ.applied?}

In my example, I've chosen the Elder Futhark rune 'Mannaz' to iterate all of the people in archived_participants. It means human or person. Person as p has been replaced with Person as ᛗ. The symbol takes the same space in a line of code, but is a sack that carries a deep tangle of aesthetic, mystic, theological, political, and cultic power. It reminds the reader and writer that the people I abstract lightly, live deeply outside of the code.

ᛗ Man byþ on myrgþe his magan leof:
sceal þeah anra gehƿylc oðrum sƿican,
forðum drihten ƿyle dome sine
þæt earme flæsc eorþan betæcan.

The joyous man is dear to his kinsmen;
yet every man is doomed to fail his fellow,
since the Lord by his decree
will commit the vile carrion to the earth.

Anglo-saxon Rune Poem, 8th or 9th C

The Cult of Productivity

Sam Osborn — Wed, 09 Oct 2019 20:57:37 +0000

To draw out.
To lead on.
To lengthen.

Productivity, from it's Latin, is the drawing out, the leading out, the lengthening of a thing from it's originary place. We are steeped in adoration for it. Unable, often, to to maximize the other variables of our economy, the wizards of our capitalism have focused on productivity. It's an enchanted buzz-word fetishized by talking heads on youtube and an iconography of clipart hands and meaningless arrows. So we've set about making the landscape around us more fertile: ambient lo-fi Spotify playlists plow the fields we let fallow overnight to restorative rituals of yoga and online-shopping-as-self-care. Little careless consumerist steps to eek out every drop of productivity from our nitrogen-fixed lives. But this is not a bettering-of, a finishing-of, a making-of; productere is elongation. Our work becomes a litch-like parody of itself: neither living, nor able to die. We are absolutely antagonistic to discrete accomplishment as we search for ways to work more productively. We draw it out, ever longer, never better, into a place that work does not belong.

All works of quality are final in their completion. All days of harvest are followed by evenings of rest. All of the good works we do must end...

tamen producentur

Cultus is always distinguishable from industry, even when the worshipper's motives are most sordid and his notions most material; for in religious operations the changes worked or expected can never be traced consecutively.
-George Santayana, Reason in Religion

On the Moral Obligation to Decomputerize: programmers, liturgists, and Luddism

Sam Osborn — Wed, 02 Oct 2019 14:30:16 +0000

The role of a programmer, irrespective of technology, is that of a liturgist.

For reasons both humanist and ecological, we all need to reconsider Luddism. As Ben Tarnoff says in his recent Guardian piece: "To decarbonize, we need to decomputerize." He is absolutely right, and as I have said before, if we don't nurture that change internally, it will be forced onto us externally as social, economic, and technical institutionalism crumble under the weight of climate collapse.

It is time to take up the task of decoupling Information Technologies roles from digital terrain. What does it look like when you point a programmer at a problem but don't let them use a computer? What happens when digitization is just one tool in a larger collection of information technologies being imagined, trained, and maintained by an IT department?
What are we without our computers?

The role of a programmer, irrespective of technology, is that of a liturgist.

Programmer's are the keepers of ritual. We design the abstract into the material and people it diversely with compassionately trained users. We imagine, design, and dictate repeatable patterns of behavior that capture arbitrary qualities as material objects to do the business of naturalist thinking. We speak a profound and academic language, rich in symbolism and multiple meanings; it is inaccessible to our congregations. We are the mediators of the arcane into the mundane, and populate daily life with enchantment and animation. In as much as our code has the ability to make meaning, it is identical to the ways in which liturgy and ritual make meaning.

The work of expression, the creation of a fabulous environment to derive experience from, is not, however, the first or most pressing operation employing the religious mind. Its first business is rather the work of propitiation; before we stop to contemplate the deity we hasten to appease it, to welcome it, or to get out of its way. Cult precedes fable and helps frame it, because the feeling of need or fear is a practical feeling, and the ideas it may awaken are only incidental to the reactions it prompts. Worship is therefore earlier and nearer the roots of religion than dogma is.
-The Life of Reason Vol VII Book 3: Reason in Religion, by George Santayana

Thunderbolt 3: A parable of consensus failure in the Post-Truth Era

Sam Osborn — Tue, 10 Sep 2019 20:36:08 +0000

1.
Standardization is a special ingredient that makes human intelligence possible. Standards are the structure onto which consensus clings. They are the scaffolding that hold language as meaningful, turn the wildest mathematics into domestic shorthand, and transmute humble science into monolithic Theory. Computer science is no exception: it is more standards than substance.

2.
Standardization understands that there is diversity in the universe. However, to communicate information, we need to build tunnels of consensus between unique nodes. Standard and consensus are sympoietic: they make-with each other. Standards are born from consensus, but they also shape present and future consensuses.

3.
Consensus is a byproduct of shared exposure to the same universe. It is enabled by a common ground beneath our feet, mediated by sense organs, and shared into reinforcement through communication.
Standardization is a byproduct of society and civilization. It stands as an object of organization created by a group of people. It implies not only community, but compact and enforcement. Those who exist outside of a set of standards risk exile from the institution that created them.

4.
The difference between standards and consensus is that standards are policed. Some group needs to make decisions about how consensus shapes a standard. More importantly, a group needs to see that standard is enforced. Policing can be organic: there are standards in our daily life that are unwritten, we all co-police these standards, built on millennia of bio-social consensus around what makes group-life possible. But we mostly care about the standards that are policed through bureaucracy.

5.
There is a special type of revolutionary dissonance when the standards and the consensus deviate. The policing party has no ethical, moral, or epistemic gravity to legitimize enforcement. It can lead to the adoption of a new standard.

6.
Because standards and consensus are sympoietic, a schism in standardization can forgive schisms in consensus. This is something to avoid at all cost: a schism in consensus is epistemic dissonance, and looks like confusion over truth. This post-truth world that we live in is a symptom of divided consensuses and of multiple mutually exclusive standards.

7.
Remembrance is a tool to shape standard adoption in a way that does not shatter working consensus. By building remembrance into a new standard, an adoption is possible that does not alienate those on the periphery of consensus. By keeping a body-of-consensus as large as possible around a new set of standards, the designers can maximize the quality of that standard as a communication pipeline, the policers have widespread democratic backing, and the core epistemic structures supporting the standards are truer and stronger.

8.
Failure to remember results in standardization that is increasingly narrow. A narrowly adopted standard is self-defeating and doesn't do the important job of rallying diversity around agreement to get work done.

Apple's premature abandonment of USB-A for "Thunderbolt 3" is a wholesale assault on remembrance, even if it is the true future standard. The result is a schism of consensus that disrupts daily life. Seen in isolation, it is an act of minor inconvenience, and a transgression remedied by consumer choice in a free market. Seen in context, it is yet another assault on group consensus. A jettisoning of rememberance to make way for a factional sub-standard that excludes more than it includes. We see here the material embodiment of the Post-Truth Era, and all of it's anti-democratic consequences.

Wayland the Smith: a myth for the Software Developer

Sam Osborn — Tue, 06 Aug 2019 15:08:30 +0000

Hwæt synt nu Þæs foremeran Þæs wisan goldsmiðes ban Welondes? ForÞi ic cwæð Þæs wisan forÞy Þa cræftegan ne mæg næfre his cræft losigan, ne hine mon ne mæg Þon eð on him geniman ðe mon mæg Þa sunnan awendan of heire slede. Hwær synt nu Þæs Welondes ban, aððe hwa wat nu hweat hi wæron?

Where now are the bones of the famous and wise goldsmith, Weland? I call him wise, for the man of skill can never lose his cunning, and can no more be deprived of it than the sun may be moved from his station. Where are now Weland's bones, or who knoweth now where they are?

Alfred the Great, king of the Anglo-Saxons, injected this moment of contemplation into his 9th century translation of Boethius. It is a noteworthy straying by Alfred from the content of the original latin and proposes a way of understanding the Consolation of Philosophy that is intimate to the daily life of an Anglo-Saxon. As he wanders from Boethius, he arrives at a place that is unique to the ancient world, a place where craft and skill are interfused with wisdom and cunning. Where philosophy and ritual articulate themselves in the solemn flashing glow of the forge. Where the smith is a rune-etcher, a word-knower, a delineator, and a form-changer. Within old metalworking communities the smiths were practitioners of religion: priestly and magical. We see this in their myths: an old and nameless Bronze Age smith god, twisted and deformed by arsenic poisoning left his shadow on the familiar gods of the classical and post-classical world: Hephaestus/Vulcan, Gabannus/Goibniu, Ugarit, Ptah, and Völundr/Weland/Wayland. All are tragic figures: sub-ordinate to and exiled from the gods, lame or crippled, but profoundly skilled: channelers of certain sort of cunning. An archetype is here: the subordinate smith to the gods, a personification of controlled skilled.

Weland the Smith is a slippery character; a talented man, skilled in a craft, so also cunning, wise, and self-possessed. He appears generically in Germanic Eddas and Beowulf as the maker of great and semi-magical items: swords, armors, rings. To say a thing was made by Wayland was to say that nothing could be finer. His was the fullest extent of applied craft, and he is a personification of craftsmanship.
Wayland is enslaved by the evil king Niðhad, who cuts his hamstrings to enfeeble him and confine him to the forge. However, Wayland is indignant and resolved to be free. He kills Niðhad's son and makes a goblet from his skull. He poisons Niðhad's daughter with beer from that same goblet. Then collecting feathers from birds, fabricates a pair of wings and escapes to haunt the edges of eddic stories as the maker of artifacts of narrative renown.

The story of Wayland invites us to consider creativity slightly differently.
I don't think it's wise to project Wayland onto any of us as developers: he is wild, violent, and indignant. However, I think the Wayland-Niðhad narrative is dialectically vivid, and probably embodied by us all internally, and played out around us externally.
In what ways are we enslaving our own skills? In what ways have we cut the hamstrings of our own cunning?
What does a pair of forged wings look like for the future we are headed into? Where will we gather the feathers to build those wings?

As craftfolks, we are well positioned to explore the mythic interplay between nurtured skill, subordinating control, and indignant escape.

Perhaps more whimsically, we can make connections between the antique mysteries cults around forges and smiths and the modern mysteries cults of technocaptalism: to which we are the smiths of the gods.

Cover image: Front panel of the Franks Casket, carved whales bone, early 8th century. Left scene shows the Wayland the Smith working the forge. The headless body of Niðhad's son lies under the anvil. To his right he, or his brother Egil, pluck feathers from birds to make Wayland's wings.

Post-Progress Software Development

Sam Osborn — Wed, 12 Jun 2019 20:25:42 +0000

Things look dire. Not a small collection of smart people* are looking at the astonishing mismatch between IPCC climate models and current state of political action and imagining a near-term future (in our lifetimes) that includes something akin to societal collapse or systemic unravelling.

What is certainly true is that economic progress as we've known it will not be able to continue as it did through the 20th century. At the very least, a major and immediate redirection of the prime movers in our economy - from disposable and carbon-based to sustainable and renewable - needs to happen, on a scale that would redefine economic life in the developed world. What seems increasingly more likely, however, is that we will not meet required goals, and economic and technologic change will be out of our control: forced upon us as global food networks decay, major urban centers flood semi-annually, and refugee migration becomes the new normal for large parts of this planet's humans.

The short history of Software Development as a profession has been paired with a unique socio-cultural-economic reality, manifest in peri/post-20th century growth and so far dependent on a petroleum rich mega-surplus of energy, capital, and educated human resources. This reality is incompatible with either a society that is handling the realities of climate change, or a post-collapse world were society is heavily fragmented, has access to much less surplus, and is exposed to fairly regular pain and suffering.
These two scenarios seem like the only two roads ahead of us - both omit the current programmer's status quo.

So what does the near-term future look like for code-writers?

Will our occupation become irrelevant as the social fabric that supports it crumbles?
What will we do if the infrastructure of the internet is fragmented? Either through economic/cataclysmic dereliction or populist and psuedo-fascist states erecting ever more ardent firewalls and iron curtains?

When it comes to technology and knowledge, I am far from a fatalist. It is critical to note that technological progress has never been stopped or even delayed because of socio-politcal unrest or climatic hardship. In fact there is a good argument to be made that these factors drive progress in the longterm. While it seems like the economic reality is likely to change drastically, there will not be a regression in technical knowledge. Yet, certainly a regression in its permeability, accessibility, and social station. In the same way that post-Roman Western Europe continued right where Rome left off technologically and philosophically (with a noteworthy shift in aesthetic, religious, economic, political, and cultural organization), I expect the same is true of our immediate future. Humans as whole won't forget how to write code, or make tools out with circuits and batteries. However the tasks we will be asked to complete will be very different and the resources at our disposal will be greatly reduced. Like post-Roman Europe, power and accumulated capital will shift from central economic hubs to peripheral, but networked, communities.

Among other things, it seems that climate induced economic-politcal meltdown will help to break up the monoculture that is modern professional computer science. Instead of walking in lock-step, encouraged and informed by common web culture, we will be diffuse, peripheral, and diverse. Helping, I imagine, local people with local problems using networks of devices regionally not globally. Hopefully, the harsh realities of the world facing us will break the spell of technology-as-lifestyle and social-media-as-productivity, and let us use computers again as tools. I see, with optimism, a future for both code writers and code that is more earthly, humane, and immediate. One that is dialectical, rooted in craftsmanship and antiquity, not entrepreneurialism and economic opportunism. However, that reality will be matched with a world devoid of modern luxury and economic excess.

What do you think?

*
Jem Bendell's Deep Adaptation
Breakthrough Think Tank
The Dark Mountain Project
Extinction Rebellion

Cover Image: photography by the author

Reconciling Guy Debord: Coding in Grammatical First Person

Sam Osborn — Tue, 21 May 2019 18:20:48 +0000

In societies where modern conditions of production prevail, life is presented as an immense accumulation of spectacles. Everything that was directly lived has receded into a representation.

The spectacle cannot be understood as a mere visual excess produced by mass-media technologies. It is a worldview that has actually been materialized, that has become an objective reality.

The first stage of the economy's domination of social life brought about an evident degradation of being into having - human fulfillment was no longer equated with what one was, but with what one possessed. The present stage, in which social life has become completely occupied by the accumulated productions of the economy, is bringing about a general shift from having to appearing...

Guy Debord Society of the Spectacle

The Software's Implication in the Spectacle

The Society of the Spectacle, despite being written in the 60s, might be one of the most lucid critiques of social media, pop culture, the destructive vortex of superficiality, and the deflation of fact that is so frustratingly widespread, thanks in part to software. Debord spends the entirety of the Society rendering an ever more refined definition for spectacle: the realization and materialization of representation as-itself in a commodity economy. The critique is widespread and scathing but predicated on the idea that in a society where representations are the economic goal and the economic by product, the system becomes completely tautological. The means and the ends of the society are completely identical and so agency and embodied living vanish into commodity-representationism.

What is particularly destabilizing about Debord is not his thesis, which is really a very elegant critique of how social-media/mass-media problematize the lived human experience - a thesis that does not need to be pushed hard to advance in our political and cultural pseudo-dystopia. What is locally and topically destabilizing is that the traditions that Debord is criticizing are intimately entangled in the psyche and culture of the greater tech world. If Debord's antagonist is the spectacle, then software is its modern accelerant, and we, the designers, are the workers who "do not produce themselves," but rather "produce a power independent of themselves. The success of this production, and the abundance it generates, is experienced by the producers as an abundance of dispossession."

Which is to say: we labor to manifest code, but are neither embodied in it, nor defined by it. As we deploy our work to production, it becomes a facet of an "advanced economic sector that directly creates an ever increasing multitude of image-objects, that spectacle is the leading production of present-day society". It is no exaggeration that the spectacle grows on our backs.

Playing with Reconciliation

The topic of being a software developer who engages with Debord, who writes code that is sensitive to his critique, is honestly monumental. The two may be irreconcilable. But, I like writing code, and I like thinking, so here's a playful go at it.

The key, I think, is unwinding of the progression that Debord lays out in his 17th thesis: that we have progressed from being into having into appearing. Representation is no doubt a critical part of coding. We are all the time creating object oriented representations of concepts, commodities, and image-objects. My challenge is to rewind that back to simply being, and here is the short-circuit moment that oscillates between Zen buddhism and wholesale disfunction: code in first person.

Here is a silly example in Elixir. I've found that if one really wants to write first-person code, it is best done functionally:

defmodule I do
  def am_a_list_with_a_max([head|tail]) do
    _and_I_sometimes_am(tail, head)
  end
  defp _and_I_sometimes_am([], my_maximimum), do: my_maximimum
  defp _and_I_sometimes_am([head|tail], maybe_my_maximum) when head > maybe_my_maximum do
    _and_I_sometimes_am(tail,head)
  end
  defp _and_I_sometimes_am([head|tail], maybe_my_maximum) when head <= maybe_my_maximum  do
    _and_I_sometimes_am(tail, maybe_my_maximum)
  end
end

iex(1)> I.am_a_list_with_a_max([1,2,34,54,65,21,45,23,67,43,12])
67

Coding in First Person faces into Debord's criticism in a few important ways, all of which interesting enough that I think it warrants playful consideration:

Embodied code: This might sound bizarre, but the implication and invitation here is that the code writer is the code. The things that the code-writer does to the data, are the code. This isn't a game of representation anymore, it's a game of being and embodying. Which is to say, your ability to write good code is not based on how well you can represent objects in your system, but rather how well you can be like the objects in your system. In the above example I being like a list a numbers, and finding my maximum. This is important because it dismantles the materialization of an externalized spectacle. The ethical consequences should be immediate: would privacy policy change at Google and Facebook if that code forced its programmers to live in it in the first person?
Relocating the disenfranchised proletariat: The worker is absolutely dispossessed from the product of his labor. It is our job as software developers to think deeply about a thing, but then disembody that thought-structure from ourselves, and capture it in itself in a self-sustaining way. This sounds critical, but that exercise is really the appeal of programming, and why I love it. The reality is that the disembodiment of thinking into a spectacular autonomous image-object is exactly the notion that Debord is critiquing. It also leaves us all vulnerable to modes of disconnection and subjugation. The reduction of intellectual labor into a commodity (what's your hourly rate?), leaves us, the workers, deprived of our intellectual capital, and exchangeably anonymized. Writing in first-person doesn't prevent this completely, but in as much as grammar offers a defense against the anonymity of representation, it is the word "I".
Ambiguity of Perspective: Something really interesting happens when reading and writing first-person code: an ambiguity beings to emerge between the different speaking characters. There is "I" the code writer, which is absolutely the intention. But in a slightly poetic way, the code begins to speak out to the world in the first person. Self documenting code is all the rage.

Conclusion and Invitation

The important consequence of first-person code is that it orbits the module "I". In many ways, "I" is both the voice of the code writer and the structural core of the code. If you have thoughts on what "I" might be, I'd love to hear it. "I-ness" is certainly a profound epistemological focal point, and something so far missing for code-syntax. Maybe it needs to stand for something larger than a module, however high-order that module is? The obvious conclusion to this is some sort of first-person oriented language, though for now I am interested mostly in exploring first person in existing languages. Give it a try: oscillate between Zen buddhism and confusing disfunction with me.

Metamodernism for Software Developers

Sam Osborn — Wed, 01 May 2019 13:52:10 +0000

The present is a symptom of the twin birth of immediacy and obsolescence. Today, we are nostalgists as much as we are futurists. The new technology enables the simultaneous experience and enactment of events from a multiplicity of positions.
-Luke Turner, Metamodernist Manifesto

This isn’t an introduction to Metamodernism, and this isn’t a manifesto. It is a deep dive into the ideas seeded in both. It’s an asking of a question: “What does metamodernist software feel like?”

Metamodernsim is interested in the sincere and the romantic in opposition to the “deconstruction, irony, pastiche, relativism, nihilism, and the rejection of grand narratives” of post-modernism. It is fundamentally obsessed with oscillation between states: that is to say it is dialectal. Metamodernism says there is sincere meaning to be found, and the answer comes from the oscillation between positions.

As Luke Turner proscribes, “We must go forth and oscillate!”

Oscillations:

Between software and reality: Find substance in the world outside of the digital. Ground the work we do in the dirty world you inhabit. Use paper, and assume your users use paper. Write code that imagines people at desks, people who spill drinks.
Between microservices and monoliths: Microservices are agnostic and independent. They wait for something to touch them and react. Monoliths are mystically large and create space for the explicitly intentional and the deeply complex. Oscillate between agnosticism and mysticism.
Between convention and configuration: Vibrate between the hardness of configuration and softness of convention. There is room there to create something that is at once sharply defined and forgiving.
Between using and building: Use the software you write, to know it completely. If you can’t do that, talk frankly and lightly with the people who do use it.
Between practical and beautiful: Tuner writes: “Just as science strives for poetic elegance, artists might assume a quest for truth”
Between mobile and static: Do you want people thinking about your software everywhere? Anywhere? All the time? What happens when you let people take a break?
Between dense and minimal: Show people what they need to see to do the jobs they want to do.
Between self-serving and ethical: Jobs need to be done. Some jobs hurt people. Wiggle in the space between those facts.
Between public and private: Share, mindfully, and not on other's behalf.
Between agility and intentionality: There is a good and useable space between progress and purpose. We need to make sure things are moving forward, keeping pace with our ever changing environment, but growth for the sake of growth is the attitude of a cancer cell.

Cover Image: Odd Nerdrum, You See We Are Blind

States of Exception and how we conceptualize humans in code

Sam Osborn — Thu, 25 Apr 2019 13:02:30 +0000

Giorgio Agamben’s Homo sacer: Sovereign Power and Bare Life 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