Here is a non-revolutionary idea. One that many have had before, and one that many will have after this article. One that might never become true, because of the forces at play and the strength of some contrarian opinions. Here the author proposes the establishment of the equivalent of the “Hippocratic Oath” for the software industry.
Software as a craft grew out of the needs for computation of capitalism and cold war. Commercial and military computing drove the development of faster and better computers, through a process that ended up putting computers in our wrists, streets, pockets, pacemakers, and in every planet, moon and asteroid in this corner of the galaxy.
Capitalism needed faster computation. Computers, born as a by-product of the Second World War, were perfect for that matter. Computers required software, and this software begat more developers. Some of those developers created faster algorithms, some made simpler programming languages. Some made history, some just made a decent nine to five during forty years.
For a long time, software development did not pay any attention whatsoever about ethics. As practitioners, we cared more about compilers, syntax, libraries, frameworks, IDEs, but we did not ask ourselves whether our software was being used for good causes or not.
A million dollars is not cool. You know what is cool? A billion dollars.
Hubris drives the industry. Not ethics. The current state of affairs is a direct consequence of the lack of questioning in the industry. We have created a broken world.
Our world is made with software. We are the makers of this new world. We must be held accountable, not only for its wonders, but also, and most importantly, for its flaws.
As a profession, we have enjoyed for a long time the privilege of knowledge. We have used the power brought by that knowledge, and we have created one of the youngest professions available to new students these days. We are the new Francmasons, and as such, we must start applying the rules of ethics accordingly.
It is time for the software engineering profession to be driven by ethics. And up to a certain point, regulated.
It is time for accountability, for the end of the all-powerful End User License Agreement that removes all liability from the creators of software.
At first sight, however, and given the large applicability of software, it might seem that not all branches of software engineering should be covered by regulation. One could argue that an agency making websites or games might not need to be covered by regulation; companies making software for pacemakers and financial trading, most certainly.
However, the author of these lines does not believe in the auto regulation of markets, and as such, all branches of software should be regulated by state intervention. Such intervention is required in most, if not all parts of modern economies, and software experts are already part of the ranks of governments and judiciary powers.
Fortunately, the pitiful state of the software industry these days gives a hint to what behaviours could be considered ethical these days:
- Selling consumer data for advertising purposes is unethical.
- Creating consumer products without respect for privacy and security is unethical.
- Releasing software without accessibility features is unethical.
- Racial profiling of any kind is unethical.
- Collaborating with dictatorships is unethical.
- Using language detrimental for any human group is unethical.
- Promoting or simply allowing the spread of fascism or fascist ideas is unethical.
If your software does any of the things above, you are acting unethically through your software, and you and your team are responsible and must held accountable for it. Each of the developers involved in the creation of such a software (apart from the creators of the libraries and operating systems linked to them,) and in particular those who make a profit out of the sale or promotion of such a software, must be held accountable for breach of ethics.
Let us be clear: all of the team members must be held responsible. Responsibility cannot and must not be diluted. Hubris can be lethal:
Additionally the overconfidence of the engineers and lack of proper due diligence to resolve reported software bugs are highlighted as an extreme case where the engineers’ overconfidence in their initial work and failure to believe the end users’ claims caused drastic repercussions.
We need software-savvy lawyers defending online harassement victims. Software-savvy politicians approving new legislation for our software-driven world. Society needs software companies to be held accountable for bugs in critical systems. To be responsible for privacy breaches in consumer systems. To proactively prevent security issues in public infrastructure and national security.
In general, to be responsible for any kind of gross or lesser negligence related to the software put in production.
A First Step
And all of these measures could start with a very simple first step, taken at the end of computer science, programming, or engineering studies: an ethical oath, mandatory to all those working in software systems. The very mechanism that Hippocrates found the key to ensure a decent standard of ethics in the medical industry, must be put in action in our own industry, and fast.
Maybe this will be the nudge that will make many managers in software companies, nowadays only attracted to the industry because of good salaries or eye-catching IPOs, to care about quality, accessibility, inclusion, privacy, and security.
Let me be very clear about this: market forces will not solve the issues caused by the lack of ethical standards in our industry. Maybe, in a few years time, we are going to witness a new kind of graduation ceremonies, one in which software developers pledge for ethical behaviour.
An Oath For Software Developers
I propose the following one, adapted from the current Hippocratic Oath used in the United States:
I swear to fulfill, to the best of my ability and judgment, this covenant:
I will respect the hard-won scientific gains of those software developers and engineers in whose steps I walk, and gladly share such knowledge as is mine with those who are to follow.
I will apply, for the benefit of society, all measures that are required, avoiding those twin traps of overengineering and releasing untested code.
I will remember that there is art to programming as well as science, and that warmth, sympathy, and understanding may outweigh the knowledge of the developer or the skills of the sysadmin.
I will not be ashamed to say “I know not,” nor will I fail to call in my colleagues when the skills of another are needed for the proper resolution of a problem.
I will respect the privacy of my users, for their lives are not disclosed to me that the world may know. Most especially must I tread with care in matters of life and death. If it is given me to solve a problem, all thanks. But it may also be within my power to generate another one; this awesome responsibility must be faced with great humbleness and awareness of my own frailty. Above all, I must not play at God.
I will remember that I do not merely create a system or implement an algorithm, but I create systems for the highest benefit of society, who will have to use it and who will store their most confidential information within. My responsibility includes these related problems, if I am to solve adequately the problem at hand.
I will prevent early code optimization whenever I can, for readable code is preferable to fast code.
I will remember that I remain a member of society, with special obligations to all my fellow human beings, those experts in the field as well as those not initiated or knowledgeable in the matters of code and software.
If I do not violate this oath, may I enjoy science and art, respected while I live and remembered with affection thereafter. May I always act so as to preserve the finest traditions of my calling and may I long experience the joy of solving the most intricate problems I am faced with.
It is said at the beginning of this article that this is not the first time somebody comes up with such an idea; Graham rightly pointed the author to the ACM Code of Ethics which serves basically the same purpose, albeit with a longer text.
May any of these ideas find an echo. It is the humble opinion of the author of these lines, that without such mechanism (necessary but not sufficient) we will not be able to start talking about ethics in software engineering properly.
As David Heinemeier Hansson said recently:
Maybe it’s time we need an algorithmic oath for programmers: I will program no harm by privacy theft, attention hoarding, radicalization optimization. I will not put engagement metrics above the humans they are extracted from.