Have you paid much attention lately to what happens when you install software on your PC? By and large, software installers these days are admirably simple. Click a button here, click a button there, tell it where you'd like the programs to go, and then relax.
But what about that one screen that pops up, usually somewhere in between the flashy logo graphics and the part where the installer actually starts copying files? You know the one I'm talking about — it's packed full of text in weird legalese: "License," something-or-other. "Warranties," et cetera.
If you're like me, when presented with that screen you probably just hit the button marked "Agree," and then move on to the business at hand — installing the software you just bought. Computing is complicated enough as it is; this one detail seems safe enough to overlook.
You might want to think twice, however. For instance, if you've been following the news, you may have heard about how programmers at Microsoft unknowingly let a bug slip by in their Access database software. This one oversight has opened up the potential of costly errors for customers using Access.
As it turns out, in certain situations data entered into an Access database can unintentionally get attached to the wrong record. For instance, a list of all the moving violations I was charged with last year might get mistakenly merged into your file in an auto-insurance company's database. Or your medical record could be swapped with my grandmother's. Worse, this bug affects all versions of Access dating back to its original creation, as well as a great many third-party applications written in Microsoft's Visual Basic, which borrows database management code from Access.
No minor oversight, the Access bug had gone unnoticed at Microsoft for years. By now, thousands of users could risk corrupting critical databases. It seems like yet another difficult situation in what has been a very trying year for Microsoft.
You may be wondering what all this has to do with the software installers mentioned earlier. After all, overlooking something such as the Access bug is the kind of lapse that could cost the industry millions. Pushing an "Agree" button before you've read all the accompanying text isn't likely to do any harm.
For most of us, "licensing" is an unfamiliar concept, and buying software may be the only area in which it touches our lives. The distinction is important, however, because it separates a software purchase from most other consumer transactions in an important way.
Unlike buying a can opener or a new pair of shoes, when you plunk down dollars for a software product, you're not actually purchasing the software. What you're paying for is a license to run the software, under certain terms and conditions. In effect, software companies are saying that, for a price, you may use the code they developed — provided you agree to play by their rules. The licensing agreement you see when installing the software is the legal contract that lays out those rules.
Some of the reasons for this distinction are easy to understand. A licensing agreement lets the software publisher make it clear the number of users who should have access to a given copy of a program, and even what the program should be used for. If you bought a copy of Tetris with the intent of using it as the control software for a hydroelectric dam, for example, the publisher shouldn't be held liable when your results are less than satisfactory.
Where the concept of licensing gets more sinister is in the choice of "rules" the publisher might include in its license. In keeping with the legal tradition of "freedom of contract," software companies generally have carte blanche to draft
licenses any way they like; if you don't agree to their terms, you can always opt not to use their product. After all, there's a "Disagree" button right there in the installer.
For many, however, ditching a major software application, two steps into the install process, isn't a real option. The product is already paid for; the project for which it's needed is already under way. We'll skim the license, press the "Agree" button, and go on about our business — only to one day find, to our dismay, that our license stipulates that Microsoft will assume no liability for the damages we incurred as a result of garbled data in our Access database. The fault was in their code, but the mess is now ours to clean up.
We shouldn't look to any "lemon laws" or consumer protection statutes to help us, either. Those govern sales transactions. In paying for software, we never actually bought a product; we paid merely to enter into a contract — a decidedly one-sided one — with no room for negotiation. By licensing computer programs rather than selling copies outright, software companies are in the unique position of being able to deliver the consumer a product containing known flaws — or even one incapable of performing its stated function at all.
That "Agree" button doesn't seem so harmless now, does it?
Fortunately, the situation isn't quite so bleak. The courts have traditionally viewed with suspicion contracts shrink-wrapped into software boxes and hidden away in installers. Some have ruled that consumers must be aware of the terms of such contracts before they open the box, and have negated those parts of a license that limit the seller's liability.
Still, more often than not, the terms of a license will hold. And in a marketplace where software makers aren't accountable for bugs in their products, what incentive do they have to produce quality software in the first place? When abused, an end-user license can negate competition and stifle innovation as surely as any monopoly.
Further, lawmakers have recently proposed a significant amendment to the Uniform Commercial Code — a set of statutes governing business practice, the majority if not all of which have been ratified into law by all 50 states — known as Article 2B. If passed, Article 2B could significantly broaden a software maker's ability to specify contractual terms in their licenses.
Imagine a world where not only could a software manufacturer not be held liable for damages, but where it was required that all lawsuits against the manufacturer be filed in a far-off state, or even another country. Or alternately, where you would be required to enter arbitration proceedings against the manufacturer, having waived your right to sue by the very act of installing the software. Imagine being required to pay for all tech-support calls, even ones involving known bugs in a software product. These are just some possibilities of what might happen, should software companies be allowed unrestricted free reign to draft licenses however they choose.
As consumers, it's our responsibility to be aware of the issue of software licensing. We need to stop turning a blind eye to the rights we may be waiving when installing software, and start closely examining the contracts presented by software publishers.
Oversight is one thing, but willful ignorance is another. The trouble it takes us to read and understand the terms of software licenses may turn out to be nothing when compared to the trouble we might find ourselves in if we don't.
