Programming, power, and responsibility

I had an enlightening conversation with my 14 year old this past week about power. She was talking about a day in her Spanish class last week where the teacher told gave some instruction and stepped out, but rather than follow the instruction, the students stared at each other, trapped in a perilous adolescent state of freedom and compliance. My daughter, frustrated with their lack of compliance and its effect on her learning, repeated the teacher’s instruction, and then everyone stared at her, still doing nothing, clearly signaling, “You do not have that power”. She then asked a truly insightful question: “Sometimes I have power in class, especially when I know something that other people don’t. They come to me, they want help, I help them, and they’ll do anything for it. Why didn’t I have power when the teacher left? What is power?”

What is power? I hadn’t ever really considered the question. I fumbled through an answer professorially, reflecting Socratically to give myself time to think, and finally admitting to her that I really don’t know much about what power is. We talked through the others kinds of power that we thought we had, why we had it, and what its limits were. She talked about recently acquiring power over her peers because she’s decided she no longer cares about what they think of her values or ideas (e.g., calling people out on inappropriate use of the word “gay”, fighting mental health stigma — by the way, when did my daughter become a fearless defender of social justice?). I talked about my many forms of institutional power (authority as an instructor, influence through action, my role as an expert, inherent white male privilege).

It became clear to us that power is an inherently social thing, but also that power is something granted by people in social settings. It is not something that people can acquire without some form of implicit consent from other people. In fact, even the most powerless in our society in some way are granting power to their oppressors when they do not stand up and defend their rights and freedoms. It’s a collective implicit consent.

Then the conservation went somewhere interesting. If power is something granted, rather than something created, owned, or produced by an individual, and we accept that power is like property, in that someone has some fixed amount of free will, someone which they can temporarily grant to someone else, doesn’t the individual receiving the power have at least a partial responsibility to use that power to serve those who granted it (if not a complete one)? If this is true, than those granted power are obligated to serve those who granted it.

Now, you’re probably thinking: duh. Voltaire knew this, Spiderman’s Uncle Ben knew this. These are old, old ideas in political philosophy. How could you possibly have not realized this? And wait: what could this possibly have to do with programming?

I believe code has a capacity for power and that code is granted power the moment someone incorporates a program into their life in some way. When I use Uber, I create a dependency on its code, giving up some of my freedom in exchange for efficiency, convenience, and other benefits. When I store a spreadsheet in Google Sheets, I create a dependency on the geographical stability of Google’s data center in the Dalles, Oregon, and the Bonneville Dam that powers it. In a way, every program is like a Hobbesian social contract: by executing its code, you agree to be constrained by its abstractions, assumptions, and limitations, in exchange for certain augmented abilities.

Now, if code is a social contract, than coders are the ones being granted power by users. Developers must accept that every additional user is an additional unit of responsibility to serve, as that developer is now wielding that user’s power. Just as politicians in a democracy have a responsibility to serve its people, developers have a responsibility the users of their code. And just as in a democracy, developers have a responsibility to listen to their users, to understand their collective desires, and serve those desires, in exchange for the power the users granted and the freedoms that they lost.

Most developers I know don’t see code as democracy. They instead have a dictatorial theory of code, even in mature open source projects. I am the king of this experience, and my users are the commoners. They will accept what I create and like it, and trust in my benevolence. Now, this isn’t always bad if these developers are actually benevolent. It can lead to wonderful information experiences, as Apple occasionally creates. But when power is consolidated dictatorially, and the developer dictators are not benevolent (or simply incompetent), bad things happen (like Comcast).

This metaphor of code as social contract provokes several interesting analogical questions:

• Is user feedback the analog to political polling, with all of its weaknesses?
• Is open source a form of direct democracy, with all of its tradeoffs?
• Are new software projects like new countries and new users immigrants?
• If new users are immigrants, what are citizens, and do they have greater rights?
• What is a software project’s constitution? It’s design principles?
• Why are developers not elected via direct democracy?
• If code is law, is a computer law enforcement?
• If developers are lawmakers, do developer teams also suffer from cult of personality?
• Are software standards communism?
• Are bug reports lawsuits?
• Are feature requests lobbying?
• Does money corrupt software politics?
• What is conservative and progressive software development?
• Are software development methodologies like obscure parliamentary rules?
• How do political parties form within software organizations and do they help consolidate power to reinforce the establishment?
• How do we teach developers-in-training to be effective, ethical software politicians? Is that the role of HCI, Design, and UX?

What’s interesting and potentially unique about code as law is that unlike many other forms of law, code is unambiguous. It does exactly what it is written to do. The interpretation that we must do of other forms of law through enforcement and judicial reasoning is actually done only by developers, both when they’re writing the law, and when they’re debugging it. All of the nuance gets lost and buried (or encapsulated if you will) in the assumptions that developers make about the meaning of the information and process they design into abstractions. It is then up to society to deconstruct these abstractions to understand their nuance and advocate for these assumptions to change.

The most frightening thing to me about this metaphor is how few people understand that code is law. If our world is politically illiterate, our world is algorithmically ignorant. With code underlying every major human infrastructure, every citizen of every country needs to understand that code is law as much as law is law. And, better yet, we need to begin a conversation about how (or whether?) the laws in code need additional democratic participation, beyond the weak mechanisms embedded in the marketplace.