Reconciling Guy Debord: Coding in Grammatical First Person  
Tags: discuss, philosophy, disfunction, play
Published: 2019-05-21 18:20:48

---
title: Reconciling Guy Debord: Coding in Grammatical First Person  
published: true
description: 
tags: discuss, philosophy, disfunction, play
cover_image: https://3.bp.blogspot.com/-M-f_u2Z4H7s/WpTZIcRUWFI/AAAAAAAAErE/R8y-4QMvsVIIzMrMjDp9ezHU5w2-a_xlwCLcBGAs/s1600/Society%2BSpectacle.jpg
---

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:
~~~elixir
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
~~~
~~~elixir
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:

1. __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?

1. __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".

1. __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.