Phenomenon of the Software Liability Research Paper

Exclusively available on IvyPanda Available only on IvyPanda

Introduction

Software malfunctions have been causing serious mistakes, tragic accidents and deaths for sometime now. Billions of dollars have been lost in damages as a result of flaws in software and the rate at which these flaws are taking place is alarming. Consumers have the right to get a product that works with fair commercial conditions and this means that there should be consumer protection principles that cover the software industry to make software developers liable for the mistakes that occur as a result of malfunctioning software (Himma, 2008). To start with, the universal code of ethics for software programmer calls for the software programmers to ensure that they provide quality services to the users of these software. They should uphold the stature of the industry by ensuring that they operate ethically. However, cases of software malfunctions have increased due to the breach of the ethical code of conduct. People are constantly incurring losses and the question that begs is whether software manufactures like Microsoft should be made to pay for all the damages arising form the flaws of their software.

We will write a custom essay on your topic a custom Research Paper on Phenomenon of the Software Liability
808 writers online

Main text

The European Union is in the process of extending the rules of consumer protection to cover the software industry in order to ensure that customers are guaranteed maximum protection. The EU believes that software programmers need to be made more accountable (Morrison, 2009). The software industry has in the recent past been associated with shoddy products that pose regular problems. The customers are expected to solve these problems which mean that a lot of burden is being pushed to the consumer and there is a general feeling that software developers need to take liability for their own inefficiencies. This means that software liability and consumer protection rules that cover the software industry need to be enacted so as to safeguard consumers from malfunctioning software and bugs.

Those advocating for the software liability may be genuine but the enactment might pose several key problems. To start with, it is extremely hard to make the open source programmers liable for their products. The enforcement of this liability would be complicated by the nature of the development of open source software (Roetzheim, 2001). To start with, there is no contract that regulates free software which means that free software cannot fall under any liability law because there is no buyer seller relationship between the developer and the user. This means that the user cannot sue the developer for the damages incurred as a result of software malfunction in the absence of a contract. It is true that the software industry has been having a problem of computer security and the most formidable way of dealing with this menace is creation of legislations that would impose financial liability for all those developers that sell software that has bugs. However, I still do not support the concept of software liability because of its negative impact on the developers of open source software, because most of them are volunteers and imposing financial liability for the free software they develop and release might stunt the growth of the open source software industry.

Software liability laws can be very dangerous. The software developers need some immunity from the over-reactive clientele. A vendor selling free software may be held financially liable for software they did not create and this may disrupt various development models. Software liability can be further complicated by emergence of lawsuits especially when security of the computer system is breached. These complications may arise because in case of a breach, directing blame and assignment of liability is not easy. Let’s take an example of a system that is running on Oracle on top of enterprise Linux manufactured by Red Hat. In case of a breach of the oracle database by a bug, it may be hard to direct blame because it is not easy to determine whether the buck stops with the former, the later or both. The complication may be even worse if the operating system was provided by another developer like Novell. Another issue that may complicate software liability concept is the disclaimers attached by the programmers and these disclaimers entail the warranty of the software. For the software liability laws to be effective, these disclaimers need to be nullified because some of the se disclaimers in the free software are usually ubiquitous (Comerford, 1998).

Computer security is a very volatile arena because attackers are always on the move trying to discover newer techniques meaning that the equation of software is different from the laws of nature and physics which do not change. Currently, there are no software liabilities laws in place and software developers seem to be enjoying a kind of immunity due to the current state of affairs (Oates, 2005). The advocates of these laws need to tread carefully because there are vital questions that need to be addressed for the laws to succeed. The problem is that those advocating for these laws do not have the requisite technological knowledge. Before the software developers are made liable for the damages and the costly mistakes that users have incurred due to software malfunction, criminals who breach computer security must be targeted first. Companies that leak information to criminals should also be targeted by any law regulating the computer industry. Software liability must be approached from an angle that ensures that the best practices are upheld and solid defensive methods are created because this will protect the implementation and maintenance of computer networks and the security of software databases. If we approach software liability from such an angle, complications will be avoided. Software liability will force companies to convert cost liabilities into insurance plans and to avoid these costs, small software companies may be forced to adopt sound practices that will ensure that they produce quality products to save on insurance costs.

Conclusion

In conclusion, software code is a very complex issue. Though we can write all types of useful software because of its intangibility and cheapness, it is important that the users of this software are protected and safeguarded from software malfunctions that have become very rampant. However, enacting software liability laws might disrupt the software landscape because the result will be reduced participation, scuttled innovation and higher costs of software. The most important thing is to consider whether software liability is a goal or an expectation and make the users aware of the need for compartmentalization and good practices in their computer networks because this is the only approach that can improve the current situation without risking the development of the software industry. Software liability laws, may not succeed in solving security and bugs problems

References

Comerford, R. (1998). Brooding on the Year 2000. NY: Sage.

1 hour!
The minimum time our certified writers need to deliver a 100% original paper

Himma, K. (2008). Handbook of Computer and Information Ethics. New York: Willey.

Morrison, T. (2009).Computer Ethics: Cautionary Tales and Ethical Dilemmas in computing .Massachusetts: The MIT Press.

Oates, B. (2005). Researching Information Systems and Computing .NY: Sage.

Roetzheim, W. (2001).Developing Software to Government Standards.NJ: Prentice-Hall: NJ.

Print
Need an custom research paper on Phenomenon of the Software Liability written from scratch by a professional specifically for you?
808 writers online
Cite This paper
Select a referencing style:

Reference

IvyPanda. (2021, December 29). Phenomenon of the Software Liability. https://ivypanda.com/essays/phenomenon-of-the-software-liability/

Work Cited

"Phenomenon of the Software Liability." IvyPanda, 29 Dec. 2021, ivypanda.com/essays/phenomenon-of-the-software-liability/.

References

IvyPanda. (2021) 'Phenomenon of the Software Liability'. 29 December.

References

IvyPanda. 2021. "Phenomenon of the Software Liability." December 29, 2021. https://ivypanda.com/essays/phenomenon-of-the-software-liability/.

1. IvyPanda. "Phenomenon of the Software Liability." December 29, 2021. https://ivypanda.com/essays/phenomenon-of-the-software-liability/.


Bibliography


IvyPanda. "Phenomenon of the Software Liability." December 29, 2021. https://ivypanda.com/essays/phenomenon-of-the-software-liability/.

Powered by CiteTotal, easy citation maker
If you are the copyright owner of this paper and no longer wish to have your work published on IvyPanda. Request the removal
More related papers
Cite
Print
1 / 1