The Software Engineering Code of Ethics is the standard used to teach and practice software engineering

The Software Engineering Code of Ethics is the standard used to teach and practice software engineering. The Software Engineering Code of Ethics is made up of eight principles that describes the behaviors 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 products. The public is the focus of the code of ethics and describes that everything should revolve around the public’s interest. Since software engineers are the one who plan, develop, test, and maintain the 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 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 considerations that need to be taken by software engineers.
Positive ethics is 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 that companies software system. White hat hackers are essential in protecting software systems against ethically negative software developers. Negative ethics contradict the moral principles that were previously stated. Anyone who doesn’t 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 choos to use their knowledge to exploit software systems in certain companies. Their main goals are to steal, manipulate, and delete data from certain companies. 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 Playstation network so that more accounts couldn’t be compromised. The network was offline for twenty-three days. The previous examples were used to give the reader background information for the following principles to be discussed.
The principles from the Software Engineering Code of Ethics that will be discussed in this paper are public, client and employer, product, and judgement. Each principle has a list of statements that make up that certain principle. Only 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. They should only allow safe software to be distributed to the public. Releasing unsafe software to the public would cause negative repercussions. Software engineers should 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, employer, and employer 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 on their skill sets and limitations. Software engineers that inflate their skill level will run into trouble when they can’t complete that certain project. Software engineers should document projects well. Not documenting projects will cause delays when other programmers can’t tell what the software how it performs. Software engineers should communicate well with the client. 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 though if NASA has 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 would ultimately the cause of the Challenger incident. 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 not promote conflicting interest of the client. The software engineers’ interests should be based off 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 shouldn’t 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 the 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. The judgement principle states that software engineers should main integrity in their judgement. Software engineers should make decisions based off 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. Each of the principles discussed compose the Software Engineering Code of Ethics.
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. As software become 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.