In a recent Medium article, Christiaan Verwijs raised the question of whether the power delegated to software developers should be grounded by an ethical code of conduct. In the piece titled "A Code of Ethics for (Agile) Software Developers?", Verwijs explains that software developers have a huge impact on the world and a "responsibility to protect privacy, to create secure applications and to build products in a way that thrives on complexity." Verwijs goes on to say that:
‘software developer’ should be a profession, comparable to lawyers or physicians. One defining characteristic of a profession is that it has a Code of Ethics. Much like the Hippocratic Oath taken by physicians or the Archimedean Oath taken by (some) engineers.
The 2015 Volkswagen scandal demonstrated an extreme case of ethical compromise, resulting in an engineer being sentenced this August, for his role in manipulating emissions tests through a "clever and sneaky algorithm, installed in the emissions-control module, (which) detects when the cars were undergoing emissions testing."
Speaking with IEEE's Spectrum magazine at the time of the VW scandal, Dr. Yotam Lurie, a business ethics professor at Gurion University of the Negev in Israel, commented on the affair, stating:
It’s shocking that the software engineers of Volkswagen overlooked and neglected their fiduciary responsibility as professionals. Professionals have a semi-regulatory responsibility within the organization to ensure safety, in this case environmental safety, even when this is less efficient or economical.
In an interview earlier this year, Dave West, product owner at Scrum.org, commented on situations which may lead to ethical ambiguity:
It's also difficult to navigate what's right and wrong if you're pressured to meet deadlines, or your livelihood is on the line; a code of ethics can provide context and a framework for professionals to fall back on... I would love to see a standardized, industry code of ethics. We do have our own that falls under our mission of improving the profession of crafting software.
Robert C. Martin (Uncle Bob), spoke to InfoQ's Ben Linders in September, about his own proposal for a Programmer's Oath, which covers 9 declarations relating to craftsmanship, transparency and feedback-loops, opening with the moral tenet of “I will not produce harmful code.” Martin explains that:
There are two kinds of harm that a software developer can do to their users. The first is the most obvious. The software could fail. It seems perfectly reasonable that we should promise to do our very best to deliver software that does not fail.
Martin then goes on to describe the professional responsibility of building software which is structured to provide agility for change:
The second form of harm that programmers routinely do to their users is to harm the _structure_ of software. Users expect software to be easy to change. It is _soft_ ware after all. Users need their software systems to keep pace with the rapid change in society and technology. It seems perfectly reasonable that we should promise to do our very best to keep software soft.
In his 2015 paper titled "Professional Ethics of Software Engineers: An Ethical Framework," Lurie proposed a series of ethical questions which may be posed at each phase of the SDLC. Lurie explains the need for ethical considerations in software development:
...(there is) a relationship of power, which in this case is between the software developer (the professional) and the end-user (the customer), necessarily requires ethical checks and balances to regulate it and assure that it is not abused...
Lurie explains further that there are behaviours often considered as solely technical activities, which should be given ethical consideration:
More specifically, what appear to be primarily technical features of a software package.. such as quality, usability, reliability, accuracy, serviceability, and safety—in fact determine what the product can do and how it serves the end-user... these primarily technical features of a software product actually have important ethical ramifications.
In a recent blog about “core values and practices” in building software, technical principle at ThoughtWorks, Evan Bottcher shares insights into “fundamental software engineering values” reflected in the “craft of building software.”
Bottcher writes that:
Values are statements of belief — that if these attributes are present, we’ll be able to build software that will not only delight users and customers, but will also allow for rapid change with confidence, both in the short and long term.
Bottcher builds on XP’s values and principles and presents four core values of fast feedback, simplicity, repeatability and clean code. These in turn support 8 core engineering practices:
- Simple Design
- Collective Code Ownership
- Pair Programming
- Refactoring
- Test Driven Design
- Continuous Integration
- Automation of Repetitive Tasks
- Vertical Slices
Bother states that these values and principles should apply to all deliverables, including MVPs:
..there are trade-offs that can be made when a piece of software is genuinely throw-away. However, these are core values and practices that always apply — even for a short-term delivery, with an uncertain ongoing viability. Dropping these practices will make you slower, even in the short term..
Martin also stresses the importance of not compromising on the practices of the Programmer’s Oath:
Every programmer has had the experience of being significantly impeded by badly structured and tangled code. That code was "easy" to write, but left the system in a state that slows everyone else down. The slower everyone else goes, the more pressure they feel to take shortcuts that leave the system in ever worsening states. Repeat after me: "The only way to go fast, is to go well."
Verwijs’ proposed code of ethics for software developers, provides suggestions for ethical conduct relating to user-centricity, developer and team relationships, honesty relating to failure and complexity, transparency, quality and fast feedback loops being used to guard user security and privacy. Verwijs’ ethical code is presented as an exercise. He explains the difficulty in adoption of a single code:
One problem with these ethical codes is that they only work when they are embraced by the majority of developers and when they become a part of educational training. We certainly haven’t reached that point (yet).
In the case of VW, the sentenced engineer was ordered to serve a 40 month jail term and pay a $200,000 penalty. Although the engineer did not mastermind the scandal, the prosecution’s memo stated that:
(he) knew that what he was doing was wrong but minimized his own moral responsibility for the fraud by reassuring himself that he was merely an engineer whose job it was to present practical solutions to problems, regardless of their propriety.
Shane Hastie continues the conversation around professionalism and ethics in the latest InfoQ Culture Podcast, where he talks with Licenced Professional Software Engineers, Sean Dunn and Chris Edwards.