Electronic Design

Beware Of Pretty Punctuation Marks Bearing Gifts

Buyer beware is good advice, especially where cell phones and software are concerned. It started so innocently: my cellular phone vendor, whose logo looks like a cute asterisk, called and offered me a free phone. I would just have to renew my service, as its anniversary date was coming up.

Not wanting to look a gift horse in the mouth, I asked what happens when the contract expires next month. Good move. But I really should have run in the other direction.

I had a family plan with multiple phones. A free phone was especially tempting because my daughter is heading off to college this fall in another part of the state.

The bad news was that my current cell phone service didn't cover the area where her college is located. So I looked for another PCS vendor, and I found one that covered the entire state and the country as well. So far so good—except that I signed up for the new service before canceling the old one. Uh oh.

Unfortunately, the friendly salesman from my current service was wrong. My service contract wasn't ending. That meant hefty cancellation fees, or worse yet, canceling my new contract would cost even more. Yes, both services used Nokia phones. But even though many Nokias look alike, they can be very, very different underneath.

PCS licenses are bad enough, but that's nothing compared to software licensing. Between the fine print, the Uniform Computer Information Transactions Act (UCITA), and aggressive sales and marketing people, it's a wonder that anyone really knows what they signed up for, whether it's a developer's toolkit or the latest desktop software.

Nonperpetual licensing and subscription services have become a way of life, and often the best-suited solution for some software products. Antivirus software is one type of application that lends itself to subscription services. Unfortunately, many vendors feel that this approach should be used with most kinds of software, from desktop applications to development tools.

The problem is that software, unlike many other technical products, doesn't wear out. For example, I still use a four-year-old word processor and it does the job just fine. Of course, older software may be incompatible with newer software or hardware platforms and eventually require replacement. But as long as there's hardware and an operating system to run it, the software will work fine.

That is unless the program or someone remotely disables it. How can you tell if this could happen? A good place to start is at the license itself. Taking the word of a well-intentioned salesperson isn't a good idea. Still, the license, with all of its legal babble, might not tell the whole story.

If the software is open source, then it's possible to check for code that may disable a program. Of course, open source has other benefits too. Anyone with access to the source code can make future enhancements or bug fixes. Plus, restrictions or incompatibilities can be ex-plained or addressed with sufficient programming knowledge, time, and the source code.

Being open with the source code is as important as being open about licensing and contracts. More than enough good reasons exist for keeping source code private. But there are none for keeping licensing and contract terms hidden in the fine print, like in my PCS contract.

Luckily, the episode with my former cellular provider ended amicably after an escalating exchange of letters. The company didn't impose any termination charges, so I will consider it in the future after reading the fine print. Let's hope that your next software contract works out as well.

Hide comments


  • Allowed HTML tags: <em> <strong> <blockquote> <br> <p>

Plain text

  • No HTML tags allowed.
  • Web page addresses and e-mail addresses turn into links automatically.
  • Lines and paragraphs break automatically.