The League for Programming Freedom
Patent Searches Are Unreliable
Even if developers could afford patent searches, these are not a reliable method of avoiding the use of patented techniques. This is because patent searches do not reveal pending patent applications (which are kept confidential by the Patent Office). Since it takes several years on the average for a software patent to be granted, this is a serious problem: a developer could begin designing a large program after a patent has been applied for, and release the program before the patent is approved. Only later will the developer learn that distribution of the program is prohibited.
For example, the implementors of the widely-used public domain data compression program COMPRESS followed an algorithm obtained from the journal IEEE Computer. (This algorithm is also used in several popular programs for microcomputers, including PKZIP.) They and the user community were surprised to learn later that patent number 4,558,302 had been issued to one of the authors of the article. Now Unisys is demanding royalties for using this algorithm. Although the program COMPRESS is still in the public domain, using it means risking a lawsuit.
The Patent Office does not have a workable scheme for classifying software patents. Patents are most frequently classified by end results, such as “converting iron to steel;” but many patents cover algorithms whose use in a program is entirely independent of the purpose of the program. For example, a program to analyze human speech might infringe the patent on a speedup in the Fast Fourier Transform; so might a program to perform symbolic algebra (in multiplying large numbers); but the category to search for such a patent would be hard to predict.
You might think it would be easy to keep a list of the patented software techniques, or even simply remember them. However, managing such a list is nearly impossible. A list compiled in 1989 by lawyers specializing in the field omitted some of the patents mentioned in this paper.
When you imagine an invention, you probably think of something that could be described in a few words, such as “a flying machine with fixed, curved wings” or “an electrical communicator with a microphone and a speaker.” But most patents cover complex detailed processes that have no simple descriptions – often they are speedups or variants of well-known processes that are themselves complex.
Most of these patents are neither obvious nor brilliant; they are obscure. A capable software designer will “invent” several such improvements in the course of a project. However, there are many avenues for improving a technique, so no single project is likely to find any given one.
For example, IBM has several patents (including patent number 4,656,583) on workmanlike, albeit complex, speedups for well-known computations performed by optimizing compilers, such as register coloring and computing the available expressions.
Patents are also granted on combinations of techniques that are already widely used. One example is IBM patent 4,742,450, which covers “shared copy-on-write segments.” This technique allows several programs to share the same piece of memory that represents information in a file; if any program writes a page in the file, that page is replaced by a copy in all of the programs, which continue to share that page with each other but no longer share with the file.
Shared segments and copy-on-write have been used since the 1960’s; this particular combination may be new as a specific feature, but is hardly an invention. Nevertheless, the Patent Office thought that it merited a patent, which must now be taken into account by the developer of any new operating system.
Obscure patents are like land mines: other developers are more likely to reinvent these techniques than to find out about the patents, and then they will be sued. The chance of running into any one of these patents is small, but they are so numerous that you cannot go far without hitting one. Every basic technique has many variations, and a small set of basic techniques can be combined in many ways. The patent office has now granted at least 2000 software patents – no less than 700 in 1989 alone, according to a list compiled by EDS. We can expect the pace to accelerate. In ten years, programmers will have no choice but to march on blindly and hope they are lucky.
Patent Licensing Has Problems, Too
Most large software companies are trying to solve the problem of patents by getting patents of their own. Then they hope to cross-license with the other large companies that own most of the patents, so they will be free to go on as before.
While this approach will allow companies like Microsoft, Apple and IBM to continue in business, it will shut new companies out of the field. A future startup, with no patents of its own, will be forced to pay whatever price the giants choose to impose. That price might be high: established companies have an interest in excluding future competitors. The recent Lotus lawsuits against Borland and the Santa Cruz Operation (although involving an extended idea of copyright rather than patents) show how this can work.
Even the giants cannot protect themselves with cross-licensing from companies whose only business is to obtain exclusive rights to patents and then threaten to sue. For example, consider the New York-based Refac Technology Development Corporation, representing the owner of the “natural order recalc” patent. Contrary to its name, Refac does not develop anything except lawsuits – it has no business reason to join a cross-licensing compact. Cadtrak, the owner of the exclusive – or patent, is also a litigation company.
Refac is demanding five percent of sales of all major spreadsheet programs. If a future program infringes on twenty such patents – and this is not unlikely, given the complexity of computer programs and the broad applicability of many patents – the combined royalties could exceed 100% of the sales price. (In practice, just a few patents can make a program unprofitable.)
Go to: The Fundamental Question
Home > Research Resources > Software Ownership & Intellectual Property Rights > Against Software Patents
HOME |
IN THE NEWS | RESEARCH RESOURCES
TEACHING
RESOURCES | STUDENT RESOURCES | LINKS
The Research Center on Computing & Society
at Southern Connecticut
State University
501 Crescent Street • New Haven, CT 06515
Director: (203) 392-6790 •
e-mail: webmaster@computerethics.org
© 2000 – 2007 – Research Center on Computing & Society