Earlier, I talked about the End User Licence Agreement (EULA) that bind software users to legal restraints – preventing lawsuits against the Software manufacturer in the case of failures. In it I stated: “abdicating all responsibility for the software failing upon the user is a cop out.” In my mind, there are two immediate problems preventing the abolition of this cop out. The first I shall call:
The tale of a bad Meat-loaf song and an oddly scaled reflection:
I stand by my “cop-out” statement. But on the flip side of the conversation, I also want to state: “People need to take responsibility for their own actions”. By this I mean: where a user makes errors using computer software, due to their own lack of understanding, they do not deserve legal protection. This is the counter argument that prevents the issue of fair EULAs being a black and white issue. Years of pop-culture has seen me take the viewpoint that lawyers live to make money by suing those who already have it. If the great mediums of film and television are to be believed (even partially believed), a person’s stupidity is no defense for the company/organisation/individual being sued. This attribute probably explains the “Objects in mirrors are closer than they may appear” stickers that appear on car mirrors.
Without any legal protection, the software industry would be forced to produce software that provides absolute protection for the absolutely clueless. I can see the “Are you sure?” dialogues now…
Software that molly-coddles users to the extremes of looking after those who hadn’t figured mirrored images may be a little difficult to judge scale by, will likely be tedious and unproductive to use.
The second “immediate problem” I see, I couldn’t think of a tricky title for… So I have simply called it:
The blame game:
A likely area of confusion is figuring exactly who is liable in the event of an error. Normally, the aspect that fails in a software application is the one closest to the user. Say for instance: an error in CAD software means a building is not constructed strongly enough. In this example, the error will likely be in the calculations performed by the CAD software. But this may not be the case.
- An operating system function may not have returned the correct value.
- An error in rounding floating point numbers may have caused a value to be “just the wrong side” of the required value.
- The compiler used to compile the CAD program may have generated the wrong assembler / Intermediate language instructions.
- The processor may have returned the wrong answer for a division.
Exact determination of who is at fault would no longer be a case for lawyers alone. Evidence to find the guilty party may prove to be elusive. Suing the software producer would probably succeed in tying up the programming resources of the company whilst they ascertain whether they should counter-sue someone else. The only people who benefit from the long proceedings that would likely ensue, would be those who are getting paid by the hour… To me, it appears as though only the lawyers come out of this scenario any better off.
The threat of legal recrimination may well force software developers to put more effort into thorough practices that raise the quality of their wares. As you may have noticed, quality software is something I am passionate about. But I am a realist. I don’t think I will live to see the day that all software released is “bug free”. I am convinced that nothing short of starting the computer software industry again would achieve such a goal. The financial, economic and cultural shock required to “stop the industry whilst we get our act together” is not one the rest of the world would be prepared to bear.