System documentation needs to be similarly thorough. In the maintenance and modification of existing computer systems, it is the system documentation that directs software technicians as to the structure and form of the software, which may not be (and in most cases are not) the same individuals that built the software. Thus, software developers must provide adequately detailed systems documentation, so as to allow the efficient and effective tracing of program errors, both during development and in post-development; there is a social responsibility to create easily maintained software (so as to reduce the frequency and inconvenience of maintenance work), and thorough systems documentation is implicit in meeting this responsibility.
As has been mentioned, software development is a collaborative art, and commercial software products are usually the result of some years of intensive work by large teams including managers, supervisors, researchers, analysts, designers, writers, programmers, testers, lawyers and marketers. Each member of the team is individually responsible, to varying degrees, for the detection and prevention of possible social, ethical, and legal issues arising from computer software.
Analysts, in identifying the initial requirements of computer systems, must be alert to the ultimate intended purpose of the systems they describe. The designers of the final product must constantly question whether the features they are incorporating are ethically sound.
Ergonomics is “the study of the relationship between people and their working environment”.12 Also on a software development team are ergonomics consultants, with the responsibility of deciding on and developing the interface through which a user interacts with the computer system. In developing software, it is important to take into account certain ergonomic design principles, so as to make the new system as intuitive, easy to use, and physically safe as possible. Repetitive strain injuries can be sustained from the improper use of software (by not taking regular rest breaks, and also through poor postural practices, eg. poor wrist support when working with mouse and keyboard input), and it is the job of ergonomics consultants to minimise the risk of computing-related injuries.
The two factors that contribute to the likelihood of repetitive stress wrist injuries are the number of movements required to perform an action, and the effort needed to perform each action. A program that makes use of consistent screen-design principles allows the user to predict the location of features, minimising superfluous searching and increasing ease-of-use. By implementing keyboard shortcuts for common functions, the effort involved in performing repetitive actions may be reduced (continued use of the keyboard requires less effort than changing between keyboard and mouse input), and so cater for the second factor contributing to repetitive strain wrist injuries.
RSI can also refer to complications like eye strain, caused by long sessions of uninterrupted computing. Ergonomics consultants can recommend the implementation of uncontrolled cinematic scenes in video games, for example, to help force breaks in play and reduce wrist strain, but also interrupt otherwise lengthy periods of intensive concentration on the computer monitor and so resting the user's eyes.
The decision by software developers to consult with ergonomic specialists helps in the design of software that will be easy and safe for public use. If an ergonomically dangerous program was released onto the market, the physical health of the individuals who used that program would be endangered, so software developers must be socially responsible for the welfare of their users in this respect.
But perhaps those with the greatest responsibilities are the software programmers and testers. It is inevitable that with demands and deadlines being imposed, errors will creep into software code. The critical nature of some computer systems means that these errors can be life threatening and economically catastrophic. Although it is a software tester's entrusted job to detect and report programming errors before a product's release, there comes a point when it would be unreasonable to ask a tester to keep searching a program for bugs; the same program can only be inspected for so long before it is almost certainly safe to assume that it is bug-free. Ideally, programmers would be exceptional human beings, incapable of programming errors in the first place. Unfortunately, it is human nature to make mistakes and learn from them, and so it is the tester's responsibility to ensure commercial products are as safe and reliable as possible.
A recent example of a computer system failure causing wide-spread inconvenience and economic loss occurred when Atlanta's Hartsfield-Jackson International Airport was unnecessarily evacuated on April 19th, 2006.
The baggage-screening security systems of the airport are designed to super-impose suspicious articles on X-ray images of passengers' bags at random intervals, in an effort to keep security staff on alert. The screening system is supposed to notify staff that the event is only a test scenario a short time after the doctored image appears on screen. On this particular occasion, a test scenario took place, but the test notification was not displayed. Subsequently, a full evacuation was carried out while some hours were taken searching for a suspicious bag that didn't exist. Widespread flight delays across North America ensued, and considerable economic loss resulted.13
In critical software of the kind used for airport security, it is certainly very unexpected to encounter a software malfunction like this one. Testing of the software's features by the developer would be expected to pick up an error of this sort, but obviously in this case the tester/s did not encounter the problem. It is not necessarily fair to condemn the software's developer because of the presence of the error, and yet their decision to release the software as reliable and safe for use in airport security applications led to the mass inconvenience of thousands of patrons, delays on a national scale, and financial losses to the aviation industry for the approximate two hours the airport was evacuated.14
But while software developers are responsible for providing safe, reliable, functional and lawful software, there is no escaping that some onus must remain with the users of software. Even the most reliable software will behave unexpectedly to someone unfamiliar with its operation, even the most lawful of software can be modified by the end user (against the instructions of licence agreements) and used for unlawful purposes, even the most functional software can only provide solutions for the problems it was designed to solve.
Software developers can be as amiable in their design of software as can be conceived, but in a technologically reliant world, where the internet provides almost countless arenas for the expression of user opinion and the transfer of user customizations, and fundamental social infrastructures are based on ever-aging computer technology, the users are always ultimately responsible for their own demands of software, and their own uses of software. Software developers can affect many areas of the community, in many different ways through the decisions they make, but in the end they can only ever be responsible for their own actions, and not the actions of others.
