I chose this question one because of my personal experience. My company made a website for a client who was our partner for many years. It was more than a partnership, near to a friendship. We were near to the end of the project (two days before the handover) when one of our partner’s employees made an error, our partner thought that we made it and because his life in those times was very stressful he got mad. He decided to sue us to pay back all his money and refused to pay our remaining fee. It’s a four year old story and we’re still fighting on the court. I not just can imagine, but I know exactly how difficult is to define the limits of liability.
Theoretically it is possible to make error free programs. Francez Nissim(1993) thinks that using discrete maths and formal logic it is possible to make error free algorithms. But programs are the implementation of the algorithms. Programs are made by engineers and not mathematicans. Nowadays applications are running on the top of many layers, eg. operating system, code frameworks, they are using device drivers to handle hardware devices. For software development we use editors, compilers, IDEs. All mentioned layers and tools are programs themselves, too and they are made by a lot of programmers. Sometimes hundreds of programmers are working on one of those programs. We know, the man is not perfect. Practically even if our software is perfect, it has to run on thoose layers and it has to be made by the mentioned tools. Since any of them can contain errors what affects our software, we cannot guarantee that our software will work perfectly.
On the other side, software is a key factor in our life now. We can find them even in some washing machines or refrigerators. Charlie White (2006) wrote about an existing smart refrigerator in 2006, years ago! Softwares participate in flight control and airplane driving. They do almost all calculations instead of engineers who build skyscrapers or malls. It’s obvious for me, that developers need to be responsible for their work. The ethical liability is obvious. The hard part is the legal liability. Glyn Moody (2009) writes about several possible solutions. EU proposes a regulation, what says that software should work perfectly in normal conditions. They say it’s the customers’ right – which sounds right. He cites Bruce Schneider, who wrote: “Computers are the only mass-market consumer item that pushes this burden onto the consumer, requiring him to have a high level of technical sophistication just to survive.” What makes this question even more difficult is Open Source software. Who can find the guilty amongst hundreds of contributors, who many times just use nicknames to sign the code?
Reference list:
Charlie White (2006) Samsung Smart Zipel Refrigerator [Online] Available from: http://gizmodo.com/156257/samsung-smart-zipel-refrigerator (Accessed: 15 October 2009)
Glyn Moody (2009) Should Software Developers Be Liable for their Code? [Online] Available from: http://www.linuxjournal.com/content/should-software-developers-be-liable-their-code (Accessed: 15. October 2009)
Francez Nissim (1993) Program Verification (International Computer Science Series) Boston: Addison-Wesley.
You are right, we can’t make error free programs. It is not an excuse for lazy coding, but even software testing is based on the premise that we can show the presence, not absense of errors.
We can use mathematical notations like ‘Z’ to search the execution space of an algorithm and rule out errors, but as you rightly pointed out, software programs don’t execute in isolation.
There are different factors and parameters, like OS, Compiler, binary code, main memory etc that affect what it does.
Linux is flawless when we compare it to windows, but I remember having brought it to a halt on a University network when I forgot to de-allocate memory after an accidental while loop was allocating it again and again. Learning – Yes, Linux itself is still flawless but other factors e.g. poorly written code and screw it up.
Food for thought!
Cheers.
Systems are built by humans so by there very nature are flawed until they have been used, proven, tested and evolved such that the process produces the same predictable results every time.
Things get worse when systems run on other systems made by humans such as software running on hardware, as the problems get compounded.
Emotion though is always the breaking point when using and testing systems that don’t perform as we expect. Instead we need to remain clear headed and objective, but then we wouldn’t be human…..
Good and Interest information thx