Neer 1
Keith Neer
28 APRIL 2013
CSC 540/Dr. Lyle and Dr. Pilgrim
The Development of Software
During the development of software, numerous obstacles are faced in order to produce high quality software. These obstacles include, but are not limited to, common constraints, ethical issues, and expectations of the product. It is necessary for these obstacles to be overcome in order for software to be effective and presentable. To compensate for lacking areas, developers often conduct unethical and immoral behaviors to produce the software in a timely manner. In some cases, these acts are not typically associated with ethics; therefore, they do not realize that what they are doing is unethical. As a result, the entire process and production of software development has become unethical as a whole.
Although there are numerous obstacles faced in the production of software development, the following five are the most common of these constraints. First, a clear line of communication must be present. There is frequently a lack of understanding of what the customer or client wanted or expected. This can result in a poor customer satisfaction and a low chance that they will purchase in the future. Second, a clear schedule of priorities must be properly established and addressed to all involved in the production process. This includes scheduling appropriate time hacks and due dates for the amount of work that needs to be completed. Third, there are constant changes to the requirements of the software and expectations from the client. After the client receives the software, their expectations and needs change, thus resulting in this feedback being implemented into the software. Fourth, during the process of reviewing the software, there is commonly an inability to fix bugs that are found. Also related to the revision process, includes poor testing of the actual software. This can affect the effectiveness of the software and lower the satisfaction of the user. Fifth, the struggle of communication and collaboration between team members is a common obstacle when working together towards a goal. It is important to maintain communication and share respect with all team members in order to successfully produce effective software.
These very obstacles are some of the same constraints that were present in the 1940s. The history of software development began in the 1940s and was designed with quality and pride. Similar to today’s obstacles, the developers’ then worried about the maintainability of software to include stability, speed, readability, cost, security, and the number of bugs the program contained. In the 1960s, the software developers hit a crisis that changed the future of software development. Many of the software development projects were running over predicted time hacks and were also running over budget. Some software even resulted in the lives of people. For example, Therac-25 was a radiation therapy machine whose job was to destroy tumors by using high energy beams. The software was behind schedule, so the developers were not able to find and fix all of the bugs in the software. When the software was supposed to emit low-intensity beams, it emitted high-intensity beams resulting in the death of six patients. This was one of the first major unethical acts in the development of software.
During the software crisis, many companies blamed the fact that they were not able to hire enough programmers who were qualified for the job. Many more problems came to existence because as a result of this. The OS/360, which involved over 1,000 programmers, cost the company millions of dollars due to the fact that they failed to develop a coherent architecture. Many companies had difficulties keeping up to date with security threats which caused property damage by allowing hackers to steal identities. Acts such as these are ones that destroyed the reputation of the software company. Some of these problems can be solved by hiring highly qualified programmers, while others can be solved by eliminating the constraints involved in software development.
There are many ways to develop software and there are numerous processes that can be used, but for these purposes, the Software Development Life Cycle will be discussed. The Software Development Life Cycle (SDLC) is a framework that describes the activities performed at each stage during the software development process. There are five stages involved in this cycle and each stage is expanded below.
The first stage of software development is where the developer gathers information to understand what the client is expecting from the software. There are times where the client does not describe fully what they are expecting or wanting. This is sometimes because the client is not exactly sure of what they want the software to do, or they do not fully understand what the capabilities are of the developer. In some cases, the developer does not understand what the client really wants. This problem can be mitigated by the developer explaining to the client what they are capable of doing and they can ask questions when they are not sure what the client is asking. The client can also be more descriptive of what they want and is expecting.
The second stage of software development is where the developer implements the information into software. The developers sometimes do not have enough time to complete the software due to the complexity and amount of work they have to complete.The changes to what the client is wanting the software to do can also delay this process. This frustrating, yet necessary process needs to be done for successful results. The developer needs to create a stable and open line of communication with the client and explain to them what is going on. The client might be understanding and give them additional time. They could even allow them to finish the software as is, but make the changes to the software in future versions.
In the third stage of software development, the developer may run into the problem of properly testing the software. Often developers are faced with a time crunch to finish the software and poorly test the software and also fail to fix the known bugs. There should be no excuse to not completing the testing stage because poor testing could lead to serious injuries to people, such as the Therac-25 case.
The fourth stage involves the communication amongst team members and future development and maintenance. Documentation of the software can save time and money. Poor documentation may create problems with team members because they do not know how to use the portion of code that you created. It can also make it very difficult to fix bugs because you do not understand what you wrote months or even years ago. This can be mitigated through a standardized method of documenting code so all team members will know what you were thinking while writing the code.
The fifth stage is not the end of the software development, although it is the last stage. This stage is the deployment and maintenance stage. This is an ongoing process to ensure the software runs stable and free of bugs. This step is where improvements are made to the software. Clients do not want to use software where its bugs cannot be fixed and the software is not kept up to date with the rapid changing needs of society. After the Software Development Life Cycle has been completed, the result is that the software will be more accurate and have a higher quality.
Although the SDLC is an effective way to ensure that an ethical product is developed, there are still possibilities for unethical issues to arise. According to Ron Garrett and Jennifer Lewis, the five most common ethical issues that software development companies face are the following: using open source code without proper accreditation to original creator, using illegal software to perform necessary tasks, reverse engineering competitors' code, not addressing known bugs, and taking talent away from their competitors.
Open Source Software (OSS) companies are like every other proprietary companies that develop software for a profit. The reason why a company may provide their software as open source is for better code reliability. According to Linus' Law, “Given enough eyeballs, all bugs are shallow”. Basically, more people with fresh eyes and with different view will be able to find and solve problems quicker and cheaper than a large corporation that provides closed source software. OSS is also customizable to what the user needs, thus allowing for modifications of the code for their needs. OSS is generally cheaper than closed source software. The most significant difference is that OSS companies provide the source code to customers who purchase the proper license. Some OSS companies only allow the licensee to possess a copy of the open source program for archival reasons. Some OSS licenses give the licensee the ability to study, modify and even redistribute the source code free of charge; however, in order to know what is permitted, the license should always be read.
Why do some developers want to abuse OSS and their developers by “stealing” their software, modifying a few lines and claiming it as their own? This could be due to the fact that it is the easiest route available for completing software on time, especially when they are on a time crunch. Some believe the saying, “why re-invent the wheel when someone else has already invented it?” Some developers do not understand that taking another person's code and modifying it does not make it a new program. The program is a fork of the original. Renaming variables, changing the order of function parameters and reorganizing the code does not make it a new or different program. It is still the same program. If an individual does this, there are several programs and tools available that can test for this. Chances are, they will get caught and because it is unethical, there are sometimes consequences. If one is unsure, compensate the original developer, otherwise do not do it.
“Pirated” or “bootleg” materials are a common for software development companies. According to webopedia pirated software is an unauthorized copy of software that was licensed for a single computer or user. Under most End License User Agreements (EULA), an individual who purchases the software is a licensed user instead of the owner. Therefore, one may not be able to do whatever they want with the software once they purchased it. Bootleg material according to webopedia is the illegal distribution or selling software, music, movies and etc. without permission from the copyright or trademark owner. According to a research study conducted by Business Software Alliance, 35% of all software that is installed on personal computers worldwide are illegitimate copies, which equates to about $34 billion in losses. Interestingly, the United States has one of the lowest piracy rates at the rate of 21%.
Reasons why a software development company would use “pirated” or “bootleg” software is too minimize the cost of the production of the software. Companies save thousands of dollars just to avoid paying the licensing fees. There is no doubt, this is illegal. The punishment can be severe and are subject to civil litigation, arrest or criminal prosecution, with the addition of fines up to $250,000 and up to five years in prison. In many cases, the companies are held liable for the action of their employees, even if they know nothing about what is going on. Again, it is illegal, don't do it.
There are two main methods for reverse engineering of software. The first method is just merely using the source code that is already available from the software. The source code will make the program easy to reverse engineer, but difficulties can arise from poor documentation of the program. But the second method is when the source code is not available; this is where the real work happens for reverse engineering. Successful reverse engineering can be accomplished in many ways using various programs. Once the software is successfully reversed engineer, the developers will be able to view the source code. From there they will have everything they need to know in order to replicate the software.
After retrieving the source code from the software, it would be similar to stealing from OSS, except for that the fact that in most cases they would have had to use a “cracking” software in order to obtain the source code. This is illegal because they did not create the process for the software. They should not take credit from another person’s work without their permission. Even with their permission, they should credit the original person in their software. Otherwise, it should be illegal and the developer should be punished to the fullest extent necessary.
Another ethical issue that developers ignore is addressing known bugs in the software. This is a common issue that occurs regularly. The client and the customers pay for quality software, not software that is filled with bugs. This is often caused when the developer is short on time left available to test their program. Without this time, they are unable to find the bugs and fix them properly. Another reason for this occurrence is that the developers might lack the necessary skills and experience needed to test their programs for bugs and fix them. When developers do not find and fix their bugs, this can lead to a negative reputation and a decline in business. Some of these bugs can result in injury or the loss of lives as mentioned previously with the Therac-25 radiation therapy machine.
Another example of a major bug that was discovered was by a group of researchers from the Ann Arbor Research Center for Medical Device Security. The bug possessed the ability for hackers to hack into Heart devices. This ability allowed the hacker to control the device and operate it in a dangerous manner. These operation included tasks such as shutting down the device and even sending jolts of electricity throughout the body, which can be fatal. This might not have happened if the software was properly tested and the bugs were fixed and removed appropriately.
Some of these bugs may be difficult to find, but when clients are paying top dollar for quality software, they should receive quality software. Should software developers and their companies be at blame for side-effects of the bugs present their software? For instance, in 1994, a Chinook crashed on Mull of Kintyre killing 29 people. The blame was being pushed onto the pilot as if it was his fault. Later to be discovered that it was a bug in the software that controlled the engine. Due to instances such as this, software developers should be held more accountable for their products and have consequences enforced as necessary. By placingmore strict laws on software development, developers would work harder to find and fix the bugs in software before releasing and selling their product to clients and consumers.
The last ethical issue that I will introduce involves developers taking away talent from their competitors. Everyone wants to create better software than their competitors, but is it ethical to wait until they release their software to release yours? This is done so the competitors are able to figure out what the customers like and want, but also to discover the flaws within their software. This is especially relevant is there is a special feature that they discovered and created before any other company or developer. The original developer should be able to have the credit for their idea before other companies begin to use it and add it to their own software. In terms of ethics, this act could be considered stealing. Not only are they stolen ideas, but it is similar to stealing source codes from the original developer. Nobody likes their original ideas and work stolen from them, especially if they are not granted credit for the original work that is being used or referenced.
Software developing companies do not actually expect their software to last for a very long time. In fact, most companies replace their software every nine years, on average. The longest life of software has been 20 years and the shortest life has been 2 years. Most software development companies plan to replace their software every five to ten years. These companies set these as milestones instead of as a forecast. The top reason why companies replace their software is because of the hardware changes or changes in system architecture, as well as a high maintenance cost. Microsoft has been coming out with a new operating system about every three years. The success of the operating system will determine how long Microsoft will produce it. For instance, Windows XP was released in 2001 and continued selling until 2010. On the other hand, Windows Vista was released in 2007 and it continued selling until 2011. What happens to this software when the company is done selling and maintaining it?