Transatlantic Cable: 'US against them' in software legal battle

The headlines for the past few weeks have been full of the Microsoft anti-trust case, but there's another legal battle going on that could be equally important.

In fact, it could have an even bigger impact as it could remove the rights of users to sue over bugs in software. It might even kill off the open source movement.

The problem is a proposed new law, the Uniform Computer Information Transactions Act (UCITA), which was written by a group of Washington bigwigs to clarify how contract laws affect the sale of software.

The idea behind it is simple: much of the contract law that controls the sale of goods in the US was written to deal with the sale of physical objects, not pieces of software. The new law is designed to add new rules controlling who is responsible for what when you buy an application or an operating system.

Much like the EU, it has to be adopted by the individual states before it becomes law, and opponents of the bill are taking the opportunity to lobby hard against it.
The group behind the law (the National Conference of Commissioners on Uniform State Laws) claim it will simplify the rules, but opponents, such as the umbrella group 4Cite (http://www.4cite.org ), believe it all works in favour of the big software companies.

For instance, the proposed law puts responsibility for bugs and other problems onto the company that produced the software. Seems like a good idea, but there is a clause that allows vendors to modify these terms by using a 'shrink-wrapped licence' - one of those agreements you have to sign before opening the box. Opponents claim that it will finally allow software companies to produce 'take-it-or-leave-it' licences.

Such licences will remove the right of the user to get a refund if the software doesn't do what they want but they don't realise this until after they've bought it. If it doesn't do what the user wants, that's tough - no refunds. In fact, a cleverly written licence could, its claimed, remove software makers from any liability whatsoever.

It will also, opponents say, allow software producers to include code that could be used to remotely remove or otherwise disable the software. So, if you were to use a program in a way that broke the terms of the licence agreement (such as installing it on more than one machine), the publisher could connect to the program remotely and disable it. And there is nothing that you could do about it.

The impact of the UCITA on the open source movement could also be extreme. The UCITA, by default, makes the company or person who writes the program responsible for the bugs in it, which seems fair enough. But open source software is shipped "as-is" - you use it at your own risk. The UCITA turns this on its head, meaning that if you were to download and install an open source program and it trashed your hard disk, you could sue the author of the program. The author couldn't claim that he had no responsibility.

Richard Stallman of the Free Software Foundation said: "Sophisticated software companies that make proprietary software will use 'shrink-wrap licences' to avoid liability entirely. But amateurs, and self-employed contractors who develop software for others, will suffer because they don't know about this problem. Free software developers won't have any reliable way to avoid the problem."

At present, the UCITA has only been proposed in two states (Virginia and Maryland), but others, including California, are due to consider it over the next few months. The American Lawyers Association expects it to be introduced to all 50 state legislatures within the next 18 to 24 months. Time enough for lobbying groups in the US to get their act together. And also time to spread the word around the world, where this legislation threatens to hit just as hard.