For most programmers and software engineering professionals, a love of technology, logic, and problem-solving serve as primary motivators. As a result, we can’t resist taking on complex projects that would drive others mad. What results is a kind of myopia that is unique to people in the software industry; a single-minded pursuit of solutions that means we don’t always take the time to think about the long-term ethical ramifications of the code we produce.
That’s a bigger issue than you might imagine. In today’s world, software is involved in almost every part of our lives. It manages the complex supply chains that put food on our supermarket shelves. It helps first responders figure out how to reach us when there’s an emergency. It even makes decisions that can affect our very freedom to walk the streets.
As programmers, we don’t give those things much thought as we do our work and understandably so. They’re issues that seem far above our pay grade. But the reality is that every line of code we create has consequences, and they can be severe. For evidence, look no further than the apparent control software flaws that doomed two of Boeing’s 737 Max jets–claiming 346 lives.
It’s easy to argue that a situation like that one resulted from a cascade of failures that were the fault of the whole organization–and that’s certainly true.
It’s also easy for the average independent programmer to dismiss the scenario as something that doesn’t apply to them, since they don’t work for companies producing software with life-or-death stakes, and that could be true as well.
But when you consider that some of the software in question may have originated at an outsourced programming firm that didn’t have the necessary expertise for the work, it starts becoming clear that we, as an industry, can’t afford to keep passing the buck. There’s no way to know when we’ll be faced with making a decision about the ethics involved in something we’re working on.
For that reason, it’s important for all programmers, developers, and software engineers to take steps to define some ethical boundaries in advance. We, as an industry, have to seek out the right knowledge and decide where we draw the line between earning our pay and sleeping well at night. Here are some tips on where to begin that journey and how to make sure to be an ethical programming professional.
Understand What Ethics Is (and What It Isn’t)
As programmers, we all started somewhere. For some of us, it was tinkering with bits of code and dabbling in online coursework to learn how things worked. For others, it was in a university, struggling with assignments and working toward a computer science degree. No matter the path, the one commonality we (almost) all share is that nobody took the time to teach us about ethics.
If you ask almost any programmer if they’ve run into ethical issues in their work, they’re likely to say no. If you’re more specific though—like asking if an employer has ever asked them to forego unit testing in the interest of time or if they’ve felt pressure to misrepresent the status of some part of a project to a client—and the answer you’ll get is likely to change.
The reason for it is that it’s just plain hard to identify what a programming-specific ethical issue is even when it’s staring you in the face. Still, there’s no programmer working today who hasn’t faced one or two such issues. Things like casual violations of intellectual property rights when it’s clear some code has been lifted from another project or a client’s insistence on intrusive activity logging without any outward disclosure that it’s taking place come to mind. Most of the time, they’re practices that are so commonplace that they just don’t stand out—unless you know what you’re looking for.
To help, every programming professional should take some time to study the concept of ethics and gain some knowledge in that area. It’s easy to do. A good place to start is to simply reflect a little bit on your own concept of right and wrong. Think about some of the work you’ve done in the past, and ask yourself: “if I were on the other side of the screen, would I be OK with this?”
You can even do some independent study to brush up on your knowledge of applied ethics. There’s certainly no shortage of online resources on the topic. MIT even offers free online courses in ethics, as do several other reputable universities.
If you have time, pick up a copy of author Sara Baase’s book A Gift of Fire: Social, Legal, and Ethical Issues for Computing Technology. It’s a deep dive into the myriad ways that ethical questions intersect with modern technology, and it contains a wealth of real-world examples to illustrate all of the concepts. Just make sure to buy a legitimate copy of the book. Although it may be available for free elsewhere online, going that route would be highly unethical in itself.
Don’t Cover Up the Lapses of Others
Since programming tends to be an iterative process, it’s not uncommon to work on projects that involve building on or extending existing code. When doing so, we all have our head-scratching moments when we encounter things that range from the confusing to the completely outrageous. Sometimes, we’ll find sloppy code. Other times, we’ll see things that are just, well, wrong.
That’s what happened to Medium user dCFO, who inherited a piece of Medicare billing software and discovered that it had been programmed to defraud the government. In that particular case, the solution was to report the fraud to the proper authorities. In every such case, leaving well enough alone is always the wrong way to go.
To uphold high ethical standards as a programmer means calling out substandard or inappropriate code wherever you find it. Whenever possible, you should report anything unusual to your immediate supervisor if you have one. If they won’t listen, keep reporting up the chain of command until you find someone willing to take action. If you’re working as a freelancer, you should communicate your concerns with your client directly.
If you’re in a situation where those above you seem content to sweep an ethical issue under the rug, or worse—are complicit in the problem—you might have to look for another way to call attention to the situation. It’s not always necessary to put your own name on the report (as in the case above, where the programmer tipped off the authorities anonymously), but it’s critical to call attention to anything shady that you can’t fix on your own. To do otherwise means you’re passing the buck, and the next programmer that encounters the issue is going to assume you were in on it too. If you make a documented effort to fix the problem, you’ll be in the right no matter how the situation eventually turns out.
Don’t Be Afraid To Say No
Programmers, and especially the independent variety, make their living moving from project to project. That brings with it a certain urgency to take on whatever work comes along no matter what it is. Needless to say, that can lead to a variety of ethical conflicts. After all, freelance programmers often don’t know all of the specifics of what they’re going to be working on until they’re knee-deep in code.
Once that happens, there’s tremendous pressure to keep saying yes to the client in the interest of getting paid for all of the effort already made. But what happens when the client asks for a feature or a change that’s unethical when you’ve already invested countless hours of work? If you went into the project with your ethical boundaries firmly established, the answer is that you have to put your foot down and say no.
In fact, you have to also make it clear why you’re saying no. As much as those conversations might be unpleasant to have, they’re necessary to let the client know that you understand that what they’re asking for is unethical. When you have to do this, it’s important to start the conversation without being confrontational. Don’t lead with the assumption that the client knows they’re in the wrong. Pose the issue to them as a question, leading with phrases like “Did you know that …” or “I think this is a problem, but can you explain to me why you don’t see it that way?”
Most of the time, the client will back down when called out in this manner. Sometimes, they’ll even respond with genuine surprise—after all, nonprogrammers often fail to see the ethical implications of what they’re asking you to do; they just want results. If they don’t, though, the next step is to walk away. As much as it may hurt financially, it’s the right thing to do.
Engage in Ethics Discussions With Other Professionals
If there’s one thing that programmers tend to do with regularity, it’s talk about their projects. That’s why there are so many blogs and communities dedicated to programming in all its forms. As it turns out, those are also excellent forums for discussing the ethical implications of the things we work on.
For a start, make it a habit to ask other professionals what they think when they’re confronted with a challenging ethical dilemma. You might be surprised at how many others have faced similar problems, and they may be able to offer valuable advice on what to do. Even if your situation is unique, it’s still worthwhile to bounce the problem off others who can understand what you’re talking about.
You should also share your ethical failings with others when they happen. Longtime programmer Bill Sourour did just that when he published a blog post entitled “The Code I’m Still Ashamed Of.” In it, he related the story of a project he worked on early in his career that involved building a misleading online quiz for a pharmaceutical company. It turned out that the medication it promoted had some side effects that drove some patients using it to kill themselves.
As painful as the episode was, it was a learning experience that sparked a conversation around programming ethics that encouraged others to share ethical issues they’d encountered. Almost like a great torrent had been unleashed, simultaneous discussions on StackExchange, Stack Overflow, Reddit’s r/programming forum, and elsewhere sprang up with countless programmers sharing their experiences. Those places remain a great sounding board for programmers who encounter ethical dilemmas, even today. The more people that take the time to tell their stories, the better off we, as an industry, will be.
Pledge To Do Your Best
Although there aren’t many professional organizations for programmers to join that provide an ethical framework to follow, there are some published pledges that can serve as basic words to live by for the average programmer. A more in-depth resource that makes a fantastic guidebook is Robert Martin’s book The Clean Coder: A Code of Conduct for Professional Programmers. It’s filled with plenty of actionable advice that can help any programmer to embrace ethical practices and to elevate their craft. They’re both excellent places to start.
Remember, though, Rome wasn’t built in a day. It’s unreasonable to expect that you’re going to make the right ethical call in every situation you encounter. It takes plenty of time to get used to standing by your ethical boundaries and applying them to everything you do. Nor can you expect the programmers you work with to suddenly embrace ethical programming standards. No matter how those around you act, it’s critical to stand firm. Eventually, your attitude will rub off on those around you.
The main thing is to always approach every project with a discerning eye and stay on the lookout for anything that seems less-than-aboveboard in each project’s requirements or the existing code involved. Then, make it a point to always do your best to do the right thing and maintain your integrity.
If you’ve made the right preparations and have taken steps to spell out your own ethical boundaries in advance, you won’t have to wonder what to do when something questionable crosses your desk. You’ll be able to spot problematic situations early and be able to focus on your response. And when that happens, your response will be more sure-footed and likely to yield a positive ethical result.
It won’t always be easy. It won’t always be good for your bottom line. But maintaining high ethical standards is a responsibility all programmers share, and as our work becomes more deeply ingrained in the world around us, the stakes grow ever higher. Remember, the results of all of our work are all around us. Lives and livelihoods depend on it. And there’s no way to know when an ethical judgment call you make today will have real-world consequences in the future.
So, the most critical takeaway is to spend the time now to develop your ethical boundaries and learn how to handle complicated ethical situations when they come up. It’s more than worth the effort. Remember, at the end of the day, we’re all in this together. If we all do our part, our industry will rise to the challenge of driving thoughtful, ethical, and unassailable code to power the future. It’s all up to us.