There's a quiet war now being fought, the outcome of which might potentially affect every computer user in the United States.
Outside the software industry, academic circles, or the few online information sources that have followed the course of the conflict, few are yet aware of the issues at stake. But it's a battle the cannon-fire of which is soon to be heard in your state legislature, and you're going to want the right side to win.
On one side of the fight are major publishers and software developers like Microsoft and AOL, and trade organizations like the Business Software Alliance.
And on the other side — alongside small or open source software developers, state Attorneys General, librarians and the entertainment industry, among others — are consumers.
In other words, you and me.
The fuss is over the Uniform Computer Information Transaction Act, or UCITA. It's a model law, originally intended to amend the Uniform Commercial Code. And it's a doozy.
Of course, if understanding the law were simple, then it might not be so troubling. But clocking in as it does at some 84 pages, the bill is so complicated that many of the very state legislators now asked to vote on it don't really understand what it means.
They just listen to the lobbyists who support the law — people who don't exactly have your best interests in mind.
UCITA was originally drafted as Article 2B of the Uniform Commercial Code, a body of law meant to keep the rules governing contracts consistent from state to state. Most of this Code applies to transactions of goods between businesses; consumers rarely need concern themselves with it.
When you buy a pair of shoes, you're paying money to own the product, plain and simple. But under UCITA, what you'd be paying for when you purchase software wouldn't be the program itself, merely a license to use it. That's a subtle difference, but a significant one.
No doubt you've seen those "License" screens when you go to install a new piece of software. Generally, they're a few pages of fine print, involving terms and conditions, and a bunch of legalese.
You're told to read them, and then click "I Agree," before you're allowed to complete the installation. You probably don't read them, but you should. Because the way the software industry would have it, those screens of text are legally binding contracts.
And if they are contracts, it follows that software license agreements should be governed by the Uniform Commercial Code. That was exactly the purpose of Article 2B, which later became UCITA: to make special provisions for transactions of computer information and software. As contracts begin to apply more and more to sales between businesses and consumers, the software industry called for new rules to handle these specific cases.
That's the problem. Because in any contract, there are at least two parties concerned. In the case of a software license agreement, the contract involves both a consumer and a software vendor. And who is the #1 supporter of UCITA? It's not the federal government. It's the software industry. Are your alarm bells buzzing yet?
They should be. Because UCITA, if it's ratified by your state legislature, will enact into law dramatic changes in the interpretation of software licenses, and grant sweeping new powers to software manufacturers over how their products are sold, developed, and used.
Among the clauses included in UCITA is a provision allowing software vendors to expire your license and access to their software remotely — via the Internet, for instance. It also allows them to include code in their products that actually stops them from working, in the event the license has been negated.
In effect, it allows the manufacturer to "repossess" your software, should it decide you've reneged on its terms. Or worse — should it decide it's time for you to upgrade.
The bill allows software manufacturers to decide when, where, and how their customers can transfer the software to someone else. Currently, if you finish a computer game, you can sell your copy to a friend, provided you un-install it from your machine.
Under the new law, the publisher would be free to claim even that as a violation of the game's license agreement. The only legal option would be for your friend to buy a brand-new copy, since you never "owned" a copy to sell in the first place — just a license to use it.
UCITA would also allow software publishers to explicitly ban "Reverse Engineering." This would prevent developers from observing how software behaves in order to figure out how it works (presumably to create a clone product).
Even though Reverse Engineered code is 100 percent original, UCITA would allow publishers to treat it as though it were a pirated copy of existing software. You should be especially concerned about this if you use Linux, or another free OS like FreeBSD.
These practically rely on Reverse Engineering to support the myriad available hardware and proprietary protocols — for instance, Microsoft Networking — without being encumbered by the original software's commercial license terms.
Because UCITA codifies into law the distinction between buying a product and licensing software, under its provisions you could lose all the consumer protections that apply to normal product sales. So-called "Lemon laws?" Forget it. They only apply to sales of products, not licenses.
Software vendors would be able to disclaim any warranty — even so far as to refuse to warrant whether the product even works. If you think you've bought buggy software before now, imagine what could happen when software vendors are assured you can have no legal recourse whatsoever.
Actually, under UCITA software developers can only disclaim these warranties provided they use a shrink-wrap license to do so. That's great for the large corporations, like Microsoft and AOL, that use them — but what about smaller hobbyist or open source software developers, who haven't the legal resources even to draft such licenses?
They could be sued for any and all damages their products are claimed to have caused. Richard Stallman of the Free Software Foundation feels it could spell big trouble, even severely hampering further development of free software like Linux.
I first wrote about Article 2B in 1998, when it was still under deliberation by lawmakers. Since then, now called UCITA, it has been completed and is now on its way to individual state governments.
In fact, in Virginia (home of AOL) the state legislature has already passed the bill, and it awaits the signature of the governor. UCITA is coming. Virginia and Maryland are the states where it's under consideration now, but California isn't expected to be far behind.
The software industry is spending millions on lobbyists to make their interests known in state legislatures across the country. We're talking companies with pockets as deep as Microsoft's, as well as trade organizations that represent the smaller players.
What your local representatives and your governor need to hear, in even greater measure, are the voices of the other side of the equation: people like you and me.
Get informed — good sources for further information on UCITA are www.4cite.org and www.badsoftware.com, as well as features on other sites, like Slashdot.org and InfoWorld. Then get involved. The battle is coming your way — let's not let it go unfought.
