Software Liability, Assessment Example

Abstract

The paper discusses the issue of software liability. The paper confirms the need for programmers to carry the burden of responsibility for the quality of products, which they create. The paper addresses some of the most serious controversies around the issue of software liability.

Software Liability

That software solutions can cause serious security and operational problems to their users is not a secret. Users who buy licensed software do not question its quality, nor do they ever apply to legal and litigation mechanisms to protect their rights if the software fails. It should be noted that manufacturing faults in the software industry are not uncommon, but users find it difficult to identify and address the party responsible for the software failure. Should distributors be held responsible for problems with software? Should programmers carry the burden of responsibility for their products? The current system of law refers to several different types of liability, but none seems to apply to software developers. The problem is that the software industry operates in standard-free environments; in other words, no universal standards of software development exist. Obviously, software developers (programmers) should be held responsible for the manufacturing faults that cause significant material and non-material losses, but imposing such responsibility on programmers is impossible, unless the software industry develops, implements, and complies with a unified system of standards of care and quality assurance.

Today, a written disclaimer accompanies most software, saying that the programmer (or the creator) is not liable for any losses caused by the product failure. As a result, companies and individual users are the only ones responsible for the losses that may occur in case the software fails. The scope and significance of these losses require a detailed examination of the issue: what if a software failure results in human deaths? Or what if a company loses billions of dollars because of security holes, which software developers were not able to close? Software developers operate in complex and pressuring environments, but they cannot totally release themselves from professional responsibility: as with any other profession, software developers must be responsible for the products they create and for the damage that may result of software failure.

Software manufacturers today release themselves from the burden of responsibility for the quality of products, which they produce. Software failures are a usual element of daily routine, but hardly anyone ever thought of applying to software developers for compensation. Medical professionals, car manufacturers, and even children’s writers are held liable for the quality of products or services they create. If a children’s writer “was to suggest a school experiment that involved drinking sulphuric acid, because she’d confused it with acetic, then she’d be in big trouble” (Thompson, 2005). Users must possess legal guarantees, which will give them the right to apply to software developers for compensation if a software failure occurs. However, in order to hold programmers responsible for software failures, two essential issues should be resolved.

First, the current system of law refers to several different types of legal liability. In general terms, “liability is any obligation, responsibility or duty that might arise from a cause in a statute, contract or tort” (Tomkins, 2000). Ordinary negligence applies when professionals, including programmers, do not exercise the necessary degree of care which a reasonable person in his (her) position would use (Tomkins, 2000). Thus, courts and plaintiffs should prove that there was something the programmer should have done to prevent damage and losses. This type of liability can successfully apply to programmers, but plaintiffs cannot always know what programmers should have done to avoid the imminent problem. Malpractice implies a failure to follow a higher standard of care for a particular profession, but the software industry does not employ any standards of care; and whether programmers can be considered as professionals is still a matter of hot legal debate (Tomkins, 2000). Finally, strict liability applies whenever the damage is obviously caused by software defects, but the problem is in that the majority of software issues and holes are hidden from the users’ eyes, and it is very problematic to establish and prove the existence of the direct link between software failure and the damage caused by it (Tomkins, 2000). As a result, modern system of law makes it virtually impossible for users to impose responsibility on programmers, and a new type of liability should be developed, to help users to resolve their software concerns.

The second problem is in that the software industry operates in a standard-free environment. In other words, there are virtually no standards, which programmers should follow in their practice. The only tool of quality assurance, which programmers use in their professional performance, is testing – but even testing cannot guarantee that the software does not fail its users. With the variety of software solutions and its applications, even the most responsible programmers cannot test their products for every possible use (Tomkins, 2000). Thus, users are the only ones who face the risks and carry the losses caused by software failures. This, however, does not mean that programmers should not be responsible for the quality of products they create.

Modern environments heavily rely on software. Cars, homes, airlines, medical facilities, financial institutions use software in their daily operations. The consequences of software failure range from lost time to lost reputation and even human lives. That is why programmers should realize that they carry direct responsibility for the quality of products they create. However, holding them responsible for software failures is impossible unless there is a system of standards and expectations of care, with which all programmers will have to comply. Software liability poses a number of challenges to legal professionals and programmers: those who oppose to software liability claim that software codes are too complex to be 100% safe and software vendors may face unnecessary charges and litigation difficulties (Anonymous, 2007). Finally, the effectiveness of software largely depends on how well companies and individuals can use it to meet their needs. Neither software developers nor their CEOs are legally protected from unreasonable legal claims. Nevertheless, there is an urgent need to develop an effective system of software standards which will apply to all programmers and will make it easier to increase the level of programmers’ responsibility for software failures and losses that follow.

Conclusion

As businesses and individual consumers are growing more dependent on the software, the issue of software liability is becoming more urgent. The current system of law refers to several types of liability, but none applies to software issues. Because software failures result in significant material, non-material, and even human losses, programmers should be responsible for the quality of their products. Yet, holding programmers responsible for the production failures is possible only if the software industry develops and complies with a single set of standards of quality assurance and reasonable care.

References

Anonymous. (2007). Software liability laws: A dangerous solution. LWN.net. Retrieved March 22, 2010 from http://lwn.net/Articles/247933/

Thompson, B. (2005). Whose fault is it anyway? BBC News. Retrieved March 22, 2010 from http://news.bbc.co.uk/2/hi/technology/4294388.stm

Tompkins, T. (2000). Hardware and software liability. Rensselaer Computer Science. Retrieved March 22, 2010 from http://www.cs.rpi.edu/academics/courses/fall00/ethics/papers/tompkt.html