The Software Engineering Code of Ethics is the standard used to teach and practice software engineering. The Software Engineering Code of Ethics is composed of eight principles that describe the behaviors and actions of software engineers. Only four of those eight principles will be covered in this paper. The principles described in the code of ethics should influence software engineers to consider the effects of their product on the local and global scale. Since software engineers are the ones who plan, develop, test, and maintain software systems, they have a vital opportunity to create ethically positive or ethically negative software or influence others to do so. Software engineers who commit themselves to making software engineering a respected and ethically positive profession are bounded by this code of ethics and shall adhere to the Software Engineering Code of Ethics while developing software systems. Overall, the Software Engineering Code of Ethics is used to educate not only software engineers but also the public on the ethical duties of software engineers 1.
Positive ethics are the moral principles that most ethically sound humans are bounded by. Anyone who values software ethics is an ethically positive person. An example of something that is ethically positive in the software engineering discipline would be white hat hackers. A white hat hacker is a software specialist that usually tries to break into software systems to expose weaknesses in that certain system. A white hat hacker works with other companies to secure companies’ software system. White hat hackers are essential in protecting software systems against ethically negative software developers 2. Negative ethics contradict the moral principles that were previously stated. Anyone who does not value software ethics is an ethically negative person. An example of something that is ethically negative in the software engineering discipline would be black hat hackers. A black hat hacker is also a software specialist like a white hat hacker, but they choose to use their knowledge to exploit software systems in certain companies. Their main goals are to steal, manipulate, and delete data from certain companies and also targeted people 3. An example of an event caused by ethically negative software engineers would be the 2011 Sony Playstation network outage. The Playstation network outage was an intrusion into the network caused by black hat hackers. More than seventy-seven million accounts and the information on those accounts were compromised. The attack forced Sony to turn off the network so that more accounts could not be compromised. The network was offline for twenty-three days 4. The previous examples were used to give the reader background information for the following principles discussed.
The principles from the Software Engineering Code of Ethics that will be discussed in this paper are public, client and employer, product, and judgment. Each principle has a list of statements that make up that certain principle. Several of the important statements will be listed for each principle. The public principle states that software engineers should act in the best interest of the public. Software engineers should only allow safe software to be distributed to the public. Releasing unsafe software to the public would cause negative repercussions. Software engineers should also communicate with authorities about software dangers. Authorities, in this case, are the upper software staff of a certain company. Software engineers should also balance the interests of the client and employer to accommodate each of their goals and not allow superiority. The client and employer principle states that software engineers should act in the best interest of both the client and employer. Software engineers should be honest about their skill sets and limitations. Software engineers that inflate their skill level will run into trouble when they cannot complete a certain project. Software engineers should also document projects well. Not documenting projects will cause delays when other programmers cannot tell what the software is or how it performs. Software engineers should communicate well with the client 1. The risk of not communicating well with the client can be seen in the Challenger incident. The Challenger incident was a tragedy where seven people were killed when the spaceship exploded in midair. The Challenger incident could have been avoided if NASA had listened to the company they contracted out to build the rocket boosters, Morton Thiokol. Morton Thiokol had warned NASA previously that the rocket boosters were not ready to be launched, but NASA went ahead with its plans. The rocket boosters were ultimately the cause of the Challenger incident 5. This paper is not implying that not communicating well with the client over software will lead to deaths but that miscommunication in the software engineering field can lead to negative results. Software engineers should also not promote the conflicting interest of the client. The software engineers’ interests should be based on the client’s proposed interest. The product principle states that the products created by the software engineers should meet the highest standard. The software engineers should strive for the highest quality possible. Software engineers should not go beyond their means, but they should strive to create the best within the realm of their expertise. Software engineers should ensure adequate testing and debugging of software. Releasing buggy software to the public could end up being a security flaw in the software system which could cause a security risk. Software engineers should ensure proper and achievable goals. Lastly, the judgment principle states that software engineers should maintain integrity in their judgment. Software engineers should make decisions based on human values. Making moral decisions will lead to a more ethically positive conclusion. Software engineers should also disclose any conflicts of interests to avoid ethically negative decisions to be made in the future 1. Each of the principles discussed compose the Software Engineering Code of Ethics.
In conclusion, the Software Engineering Code of Ethics is a way to educate people on the ethical obligations of software engineers. The code of ethics is composed of eight principles in which only four are discussed in this paper. These principles should be used to guide software engineers in a more ethically positive manner 1. As software becomes more complex and advanced, the Software Engineering Code of Ethics and other software code of ethics documents might have to be changed to include ethics regarding AI and advanced robotics. More emphases will need to be put on ethics in the future because of the advanced roles that software will play in human life.