DEV Community

Cover image for Reconciling Guy Debord: Coding in Grammatical First Person
Sam Osborn
Sam Osborn

Posted on

Reconciling Guy Debord: Coding in Grammatical First Person

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)
  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
  defp _and_I_sometimes_am([head|tail], maybe_my_maximum) when head <= maybe_my_maximum  do
    _and_I_sometimes_am(tail, maybe_my_maximum)
iex(1)> I.am_a_list_with_a_max([1,2,34,54,65,21,45,23,67,43,12])

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?

  2. 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".

  3. 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.

Top comments (4)

dmfay profile image
Dian Fay

While I don't disagree that computerization in general and social media in particular have accelerated or potentiated the development of the "spectacle", I don't know that writing code in the first person about it amounts to more than -- forgive the bluntness -- a moderately interesting art project.

And as art, I think it's only partially successful. Certainly, it troubles distinctions between writer and written or between reader and read. It involves and imbricates the writer and reader (I might question whether software developers are, strictly speaking, proletarian, but either way it is undoubtedly better for us to be less alienated from our labor). But are these distinctions always untroubled? Declarative languages and systems seem to be there already: SELECT this, that FROM there WHERE thus-and-such GROUP BY this. SQL can be read as an instruction set with the implicit imperative "you"; but that "you" is subjective, and when I'm designing or reading a query with any complexity to speak of, I find myself thinking as the database, mapping out the boundaries of my relations, envisioning my sets and tuples overlapping and intersecting. It's a similar story with declarative configuration using tools like SaltStack or Ansible. And thinking like this and working like this has not kept me from writing SQL to less-than-perfectly-defensible ends.

The biggest sticking point for me, however, is: why accept the Cartesian "I" on Descartes' terms? "I think, therefore I am" is not without presuppositions. What is doing the thinking, what is doing the existing? Are they necessarily one thing, the same, or even related? But dispensing with the unary "I" in this case puts us back at square one, representing software in more Deleuzean terms as assemblages of machines without identity as such -- not particularly distinguishable from how it's represented now.

samosborn profile image
Sam Osborn

This is wonderful, and you deserve a much longer and more thoughtful response than I'm about to give.

I'd like to bring in my very favorite folks up the Dark Mountain, Dougald Hine and Paul Kingsnorth, who conclude their 2009 manifesto with 8 principles. The second of which reads:

We reject the faith which holds that the converging crises of our times can be reduced to a set of ‘problems’ in need of technological or political ‘solutions’.

I don't see a real problem/solution schematic to Debord's critique of an economy of tautological representation, in which we are all absolutely implicated. The irony here is that any computer-based solution is almost entirely a perpetuation of the problem of tautological representation.

Instead, I can suggest a painfully underwhelming, utterly impractical, moderately interesting art project. No, the real way to engage with Debord is not to just write first person code as we design AI solutions to marketplace woes. Just the same, the real way to write ok code is absolutely not in first person.
However, I think it is our job as software developers living in our time to pick up this job pseudo-artisticly, tongue-in-check, and try to think about it differently. We certainly need to think about it, and it's consequences, differently.

Do you agree with Debord?
Do you feel implicated in the design and advancement of the very structure he is critiquing? I do
What do you think we should do about it? Art projects encouraged.

I'm not ignoring the great Descartes-Deleuze structure you've built at the end of your response. I think this is truly wonderful, and deserves more time than I have right now to unpack. I don't often consider myself a Cartesian, but I see a great deal of practical value coming from an articulation of "I"-ness as a way to locate thinking and agency in a field that has materialized, anonymized, economized thinking and subverts human agency with automation, auto-fill, and auto-correct. The suggestion hopefully helps getting us thinking about embodiment, agency, and ownership in general. More to come - I need to come when I'm home with Deleuze.

Bluntness is forgiven and appreciated. Thanks for the wonderful ideas here. I had never thought about the subjective "you" in SQL and the room that leaves for thinking like/as a database. That's what I'm all about.

dmfay profile image
Dian Fay

First I have to confess that I have not actually read The Society of the Spectacle. I have read plenty of people following or building on Debord, enough to derive (I think) a fairly clear outline of his thesis, but not the man himself. I see parallels to Baudrillard (whom I have also only read secondhand; I'm not really on my best footing here): the economy of spectacle is a semiotic regime, and whether on Instagram or in the replacement of the United States' industrial base with high-finance shell games, its development tracks the unmooring of semiosis from real antecedents.

The nature of this system is that we are all complicit; we have no choice but to be complicit, some of us more than others, and certainly software developers generally more than most. What do we do about it? As you say, writing more software won't help. Art seems no worse an answer than any other short of organizing, still a pretty fraught proposition in the industry. There's no gainsaying Vonnegut's remark about the power of art against the Vietnam War being that of a custard pie dropped from a stepladder, but it's not so much the fault of art.

The Dark Mountain manifesto reminds me of Peter Grey's Apocalyptic Witchcraft, although with an artistic instead of an esoteric bent. And perhaps a little more in love with ars gratia artis than is necessarily healthy; but then, I always feel that anyone waxing rhapsodic about the revolutionary potential of art is trying to sell me something, doubly so when framed as apoliteic. And if we're going to talk about challenging the myth of progress and decentering humanity's place in the cosmos, should we be starting with Emerson and Conrad, or with Lovecraft?

dmerand profile image
Donald Merand

I think @dmfay did a great job summarizing the philosophical critique of this argument, in a much more eloquent way than I would have. Nicely done!

I'm here to contribute a thought - the idea of self-identification or being-ness of code reminds me of BDD testing syntax, eg it does_this_thing when this_other_thing_happens. "Being" your code might not necessarily happen effectively in the writing, but in the testing.