It's Time We Programmers Talked About Ethics

Please, no more political posts!

"I don't want to talk about politics" should be a t-shirt or hat given to every new programmer their first day on the job. It is one of the most common refrains you hear in programming Internet forums and it's been the policy of many a successful Internet technical site.

It's both right and wrong. I think the sentiment is exactly right. The problem is that the words are bit too undefined and the concept misused. We say we don't want to talk about politics when in fact we just don't want to think about difficult topics.

I get it. You're online trying to figure out how to implement a bubble sort in QBASIC for that pet Donkey Kong project you've always wanted to code, and here's some dude bringing up the Venezuelan Beaver Cheese Crisis. They're upset about it, they've already decided about what needs to be done, and the only thing that's going to happen is that a lot of really smart and talented coders are going to waste time arguing about (perhaps) critically-important stuff that nobody is going to agree about and nobody will change their mind. Worst-case everybody hates one another at the end. Best-case it's a form of intellectual masturbation. Instead of working doing useful coding stuff, everybody spends their morning passionately instructing some other person desperate not to work on why they're wrong on the Internet. No thanks.

Don't get me wrong, it may be a world-changing important, emotional, and immediate debate that has to happen, it just doesn't have to happen here, not with that Donkey Kong thing you've got going on. Shut the hell up about politics and just talk code, please!

I get it.

So we talented, focused, and hard-working coders have been doing this for years, decades even, and what we've found is all of those little technical bubble-sort-like questions were answered, products were built, and suddenly we're living in a world now where there are all of these software products are doing things nobody really wants. Not all of them, of course, but a lot. Sure, we coders knew what we were building as we were building them, but that's politics, right?

Coders were working in projects building components that didn't work right and ended up killing people, but how were they supposed to bring it up to their boss's boss? That's politics, right? The IPO they're in is a snake oil show, and most of the coders know it, but that's politics, right? They're thinking about selling rights to our code to an oppressive regime that plans to use it to control people, but that's politics, right? We've stuck so much telemetry on your phone you might as well be a lab rat, but that's politics, right? Just give me the code.

We all kept politics out as much as we could. We got online and boiled everything down to bits and bytes, ignoring in our forums where code is ending up and how people have been hurt. All this time we were really building weapons, truth be told, weapons more powerful than the A-bomb, but we were doing it in tiny little distributed pieces so each of us could pretend that the use of the weapon and the piece we made are completely unrelated.

We kept it productive. We only cared about GC in Java and the fact that some guy in Bavaria used that code to build a giant robot that shot up those surfers? We couldn't have known that, could we? If you haven't spotted it, this is a circular argument. We refuse to talk about the larger effect of things then claim that we couldn't have known how the things we've built could have been put to a larger use. We could have never known that anything we do at all could ever be bad because we refuse to talk about anything controversial at all under the rubric that all controversial things must be a waste of time. They're politics.

Ask me how to build an AI-powered death ray that only kills clowns and that's a technical question. Post a story about how death squads are using AI-powered death rays to kill clowns and that's politics.  We win every time. We live in a consequences-free world. Everything is just bits and bytes without any of it ever amounting to something controversial. Ever. Isn't it nice here?

That's where we got it wrong.

Politics is the public process of people seeking to right wrongs in the world. If we're solving problems, we don't need to talk about politics. That is, we don't need to talk about anything that is in the current news: political figures, political decisions, political parties, political movements. If it's trending on Facebook or Twitter? Good money says it's a emotive knee-jerk clickfest and we have work to do.

Maybe a better way of putting it is "We don't want to talk about current people and events doing controversial things" Count me in for that rule. We fix defined problems right here, in the IDE in front of us. Most of politics is people not agreeing there is a problem, what the problem is, or how to solve it. All of that doesn't fit with our jobs.

It's squishy.

How do we fix it? Perhaps a good rule would be that if it happened five, ten, or fifteen years ago and people can talk about it without going crazy? If it's tech-related we can probably talk about it. Let's try, see how it works.

There has to be a place to talk about the profession of programming, what makes an ethical programmer and what doesn't. That place is right alongside where we talk the details of programming. My fellow dudesters, we gotta talk ethics. In various ways, many of us are participating in the building of things that hurt people. We are long past the point of purposefully ignoring this. Without talking about particular people, products, news stories, or current events, we must talk about how we think professional programmers should conduct themselves in an environment where code isn't just Donkey Kong anymore.

We can't go on like this, ignoring it. It's reached the point where tech, the tech many of us built in some way, is being used to do terribly dramatic and controversial things. We end trying to force one another to talk about it anyway. We post these stories. "What the hell?" the poster asks. "Some programmer built this?", "Should I help do X", "Building sort doesn't hurt people, so where's the line?", "How is it okay to track this information?", or "Should I take a job with people doing stuff I think is immoral? How about letting them use my code?"

There are really good questions that we need to ask as a programming profession that only we can ask. Trust me, we have reached the point where it's either we talk about it or others will talk about it and make decisions for us. Nobody wants that. This isn't going away. So let's figure out how to talk about being a professional and respectable programmer who can sleep easily at night and whom other people trust and confide in. We can do that without endless arguments if we set some ground rules and just talk generics.

Would These Ground Rules Work?

• No current controversies. Pick a time limit, anything within that time limit is off-limits. People are just too wound up about it, and we're not looking to argue, we're looking to make ourselves better. That's why we meet.
• Separate the personal from the professional from the public. We have to acknowledge different levels of what's okay or not or we won't be able to discuss anything, dynamic types or killer robots, doesn't matter. It's okay to feel strongly that something is wrong and still think it's the right thing to do to let other people do it. That doesn't make you a hypocrite, it makes you a human. There are a lot of wrong people in the world.
• Morals - my relationship with myself and my higher power. Morals are the things I hold most deeply, the things I'm willing to get upset about and tell you why right is right and wrong is wrong, dammit. Nobody else in the universe has the personal morals I do. I create them with the decisions I make.
• Ethics - how I feel all of us should act as a profession so that we know what to expect from one another and that people will hold us in high regard. Ethics is what we really need to talk about. Not what's right or wrong, but what standards we should strive to uphold so that each of us can be passionate about our morals while still acting in a way that's predictable and honorable to outsiders.
• Laws and Regulations - those things that I feel that I should have no control over. I never want to build a quadcopter that looks like a spider, I think it's immoral, I think it's unethical. It's so bad that nobody should do it ever. Anybody who builds one should be caught and punished. This is what we're going to get, and we're going to get it good and hard, if we don't come up with a good set of professional ethics. (And we're not going to be the ones creating them.) Of course, government can be good! There's a needed role for laws and regulations, but it should be as a last resort, only when an industry has shown an inability to control itself. But come on! We're programmers. We've got this.
• Always assume positive intent
• Seek agreement on the general, historical then move to the specific and recent
• Always be looking for the simplest question everybody can agree on where well-meaning and intelligent people have different answers. That's where you learn stuff

Levels of Ethical Concern in Human-Machine Interaction

I'm not going to leave you without something useful, so here's a first stab at levels of ethical concern for writing code that interacts with people. I'm not telling you what to do or not. All I did was make an ordered list of how concerned I would be from an ethics standpoint in building various pieces of code based on how it interacts with people. For each level maybe I'd get a yes or no answer. I might build it or I might refuse on ethical grounds, but stuff in level one is a much easier "yes" than stuff in level ten, which I find mostly evil. As the levels go up I'd have to think long and hard about agreeing to write the code.

• Collecting truly anonymous data somebody needs for something they're paying for.
  SEDE Stream Encrypted Data Exchange, PKI-like system for individual data recordings
• Must have producer anonymous to all other systems aside from one
• Must have consumer anonymous to all other systems aside from one
• Must exist for a financial reason obvious to both
• Can only contain one column of a relevant financial transaction
• Is aggregated in a random and nonstandard time chunks by consumer
• Can only exist for a certain time based on the type of transaction
• Reporting a sensor reading
• Doing a trivial, yet perhaps time-consuming thing for a human
• Answering a non-current-events question
• Advising a human what to do with a detailed explanation
• Telling/nudging a human on what to do (or advising without an explanation)
• Making a decision for a human that reasonable people might debate
• Passively preventing humans from doing something
• Actively causing humans pain or harm
• Carte blanche telemetry. Lab-rat tracking.
• Lying to humans

That's right, in my mind the worst kind of code a programmer can write is code that deliberately lies to humans. That's because we humans can't go around trying to figure out if every computer we meet is telling us the truth or not. More importantly, it completely flips the script from humans manipulating computers to computers manipulating people. It's gotta be completely eliminated from the planet. Nuke it from orbit.

Of course, I'm not that upset. Throw this away or break this down any way you'd like.

No matter how we want to do it, there's a ton of work around how we can be better, more ethical professionals. We need to do it, at least as much as that Donkey Kong thing you were working on. Plus, I don't think we have a choice. We either start being very active about what makes a professional, ethical programmer or not or others will decide it for us. Pick one. I'd rather us do it.