Chaining Open Source Software: The Case Against Software Patents

by Jason V. Morgan

Software has become an integral part of our society. The economic success of our country depends on the success of the software industry. ``Open source'' software, software which users are allowed to modify and redistribute, is a very important part of the software industry. Unfortunately, the increased use of software patents threatens the future of this type of software.

The importance of open source software is evident in the number of people who make use of it. Most users do not realize that they make use of open source software because much of this software lies on servers. Many Internet Service Providers have Linux, FreeBSD, or another open source operating system on their systems to provide reliable dial-up service to customers. Most email goes through at least one sendmail server or some other open source email server. BIND is the most widely used software for DNS services---the services that translate server names such as ``www.gnu.org'' to a numerical IP address. According to a recent survey by E-Soft of almost 1.5 million web servers, over fifty-percent of web servers run Apache, an open source web server (``Web'').

Everyone should be concerned about any possible hindrances to open source software. Without this type of software many services would not be widely available today. It is also probable that a decentralized worldwide network such as the Internet would not exist if open source software was not such a force. Software patents have hindered the proliferation of open source software in the past and they could easily damage the future of open source software and the rest of the software industry.

Supporters of software patents claim that the involvement of the patent system is needed to provide incentive to innovate new software technology. They believe that the developers of new software technology have a right to a monopoly on the technology as it falls under the category of ``intellectual property.''

Many companies that support software patents have large investments in existing patent portfolios. This includes companies such as IBM, Unisys and Microsoft. They collect royalties from their patents which supporters of software patents feel they are entitled to.

Supporters of software patents believe that recent advancements in the strength of software patent protection give ``a powerful new legal tool to software developers'' (``High Court''). Their belief is that the software industry is just suffering ``growing pains'' and should endure while the legal system clarifies law.

According to supporters, software patents encourage competition by giving anyone who creates a new software technology power over that technology. In Inventing Software, Kenneth Nichols points out that patent law protects a wider range of ``intellectual-property'' than copyrights and trade secrets, the traditional methods of software protection. ``The patent system has the advantages of being already in place and using a model that is adequate to cover a sizable portion of the software currently on the market'' (Nichols 105). Software patent advocates such as Paul Heckel see strong ``intellectual property rights'' protection as a way of giving struggling companies the opportunity to become a major force.

Software patent supporters believe that the ``carrot-stick,'' the incentive, created by allowing these patents leads to further innovation and advancement in the software industry. Even members of the government have come to the consensus that ``licensing, cross-licensing, or otherwise transferring intellectual property can facilitate the integration of technology...and is therefore procompetitive'' (Section of Antitrust 19).

However, opponents of software patents claim that these patents are a hindrance, not only to free software, but also to the whole software industry. They claim that software patents give undue control over patented technology to patent holders and that software patents can become a huge monetary obstacle. Opponents also claim that many software patents tend to be ``frivolous'' and are not truly unique or non-obvious. In a submission to the U.S. Patent Office the League for Programming Freedom claimed that the software industry does not have a shortage of innovation; that ``[software] development has not been able to keep up with research, and there are thousands of ideas just waiting to be exploited'' (Irlam).

Opponents claim that the duration of patents, seventeen years, is too long for the software industry. They believe that the time-period is too cumbersome for an industry that changes every five years. According to them, the main use of software patents is to block out competition. They claim that the government's policy to allow cross-licensing benefits companies that have large patent portfolios at the expense of their smaller competitors.

Supporters of the ``free software'' movement, who believe that source code should be ``free'' as in ``free speech,'' consider software patents to be completely counter to the movement. Free software supporters believe that software patents provide too much control to the patent owners. These particular supporters believe that ``intellectual property'' should be shared and that software patents prevent ideas from being shared and thus inhibit the growth of software technology. To the supporters of the free software movement, software patents are a form of censorship.

All parties with an opinion on software patents purport to have the interest of the end-users of software in mind. ``Patents...create intellectual property rights that can be [bought], sold, rented and licensed like other property rights'' (Heckel 128).

This is supposed to increase the dissemination of ideas through the marketplace and thus benefit users of software who should get better products. However, as Richard Stallman, founder of the Free Software Foundation, points out ``navigating the maze of patents will be harder than writing software'' (Stallman) if software patents continue to proliferate. This would only reduce the amount of software that would be available.

Reducing the amount of available software may seem to be a good idea to some. But experience in the software industry shows that products that lack competition tend to stagnate. Microsoft did little to MS-DOS until competing products such as PC-DOS and DR-DOS became available. The capabilities of Internet browsers were fueled largely due to competition between Microsoft and Netscape.

Of course, quality should be emphasized over quantity when it comes to the output of any industry---including the software industry. Paul Heckel suggested that ``if software patents were more widely respected we would probably have fewer variations on a theme, and more themes to vary on'' (136). He cited the 250 different spreadsheet programs available in 1992 as an example of the overuse of a product idea. However, in Intellectual Property Issues in Software it was noted that

software innovator Bricklin, creator of the original spreadsheet program, VisiCalc, believes that [software patents] could be ``very bad for the industry''...had patents been available when he and his collaborator developed VisiCalc, Bricklin speculated, their company, Software Arts, would have sought the protection. The consequences of such a decision, he further speculated, would have been to prevent other innovators from exploring different expressions of the spreadsheet idea and to handicap the competition. (National Research Council 64)
Open source software adds even more competition to the software industry and thus increases the need for innovation. ``Open source programs have demonstrated a level of reliability and robustness under rapidly changing conditions'' (``Business Case''). At the very least, this raises the level of quality needed for successful proprietary software.

According to the Open Source Initiative, the organization which controls the ``Open Source'' trademark, open source software ``may not restrict any party from selling or giving away the software'' (``Open Source''). However, the GNU General Public License (GPL) preamble notes that software patents create the ``danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary'' (GNU GPL). What is worse is that third parties can also obtain patents and thus have control over software that they did not even write.

This has shown to be true with in the case of the Lempel-Ziv-Welch (LZW) compression algorithm whose author obtained a patent for the technique in 1985. However, the algorithm became part of several standards, partially due to ignorance that the algorithm, which had been published in the June 1984 issue of IEEE Computer, was patented. One of those standards was the CompuServe GIF file format. This file format allows lossless image compression; meaning that it makes image files smaller without losing any data. Today the GIF image format is the most popular lossless image compression format despite attempts to displace it with other standards. Even though Unisys, the current patent holder, had no part in creating this file format, it now asserts intellectual-property rights and demands royalty payments for programs that create GIFs.

Unisys's policy is to allow non-commercial software free license to the LZW algorithm. However, open source software is not necessarily non-commercial software. This means that any one that asserts the right to sell an open source product that creates GIFs has to pay a royalty to Unisys. A distributor may not even be able to distribute the product if Unisys were to deny the distributor the right to use the LZW technology.

Supporters of software patents would contend that Unisys has these rights as the owner of the LZW algorithm. However, Unisys is able to assert the right to royalties for software that was not written by any Unisys employees. Traditionally ``it [was] the means for carrying out an idea that [was] patentable---not the idea itself'' (Mylott 48). But any software that implements the LZW algorithm probably does it in a different way; thus software patents such as this cover an idea too.

The original reasoning behind the patentability of software was that a computer running some software was in fact a different machine. Software changes the information stored in a computer's memory; changes what the computer knows how to do. ``Viewing software as a physical, electrical process operating in a physical matrix of digital circuitry opens the way for it to be considered patentable subject matter'' (Lautsh 59). The logic behind this view is very convoluted and indicates how much the patent system has had to stretch to even allow software patents. Even a novice computer programmer, and many non-programmers, would know that simply implementing software on a different type of computer can dramatically change the actual instructions that tell the computer how to work. However, software patents are usually broad enough to cover the implementation on any platform.

In the case of the LZW compression algorithm it is true that software patents have encouraged innovation. When it became apparent that the LZW patent was going to make it difficult to distribute graphics software, developers at Hutchison Avenue Software Corporation contributed code that created compatible GIF data without using the LZW algorithm to the gd library, a software library for generating GIFs. However, they had to use an inferior method along with an algorithm to make the data look like it was generated using the LZW algorithm. This process makes it possible for viewers such as web browsers to read the images; but it makes the images much larger than they should be. Users now have images that take up more space than they have to, wasting disk space and network bandwidth, hardly beneficial to anyone.

In 1992, Paul Heckel argued that the software patent issue is really an intellectual-property rights issue and that software patents need to be highly respected in order to maximize the output from the software industry. Interestingly enough, one of the issues he brought up was the operating system development efforts of the Free Software Foundation:

AT&T has invested in Unix based on its ownership as manifest in patents and copyrights. AT&T cannot be pleased when Stallman gives away free copies of a clone of a product it invested millions in developing and marketing. If AT&T had not used patents and user interface copyrights to protect its intellectual property rights, Stallman would have no trouble making and distributing a Unix clone. But AT&T must pay its bills with money it receives from customers and has asserted its rights. If it is acceptable to clone Unix or any program, will anyone invest in new ideas? (Heckel 128)
We now have several ``Unix clones'' available and in wide use. Ironically, the introduction of these systems seems to have done more for the marketability of the proprietary Unix versions than strong intellectual-property rights ever did. Strong intellectual-property rights aided in the splintering of Unix into dozens of proprietary versions, reducing their marketability. But the widespread use of open source versions helped create better standards, unifying Unices both open and closed. Today, the proprietary Unix versions are still a major force, especially on high-end systems.

Paul Heckel had his own small stake in software patents in the form of some patents he owned. One of these, which he sued Apple for, was U.S. Patent 4,736,308. This patent covers ``means for selectively removing the recognized preselected characters in'' (US4486857) a string. It also covers the case in which this is done by ``[recognizing] the vowel characters a, e, i, o, and u'' (US4486857). Personally, I did not consider these claims to be non-obvious. The claims are very easy to infringe upon also. The simple Unix command line ``sed -e 's/\([^ ,.]\)[aeoiu]*/\1/g'''---which takes strings such as ``this is an example string'' and converts them into ``ths is an exmpl strng''---arguably infringes on this patent, which is still in effect.

Heckel did not argue the benefits software patents had for him. He argued that software patents benefit small businesses by giving them a powerful way to protect their ideas. However, he failed to acknowledge that software patents provide a tool for competitors to prevent the inventor from using an idea by simply patenting the idea's usage. ``Normally, the largest companies own most of the patents, and use them to force other companies, both large and small, to cross-license with them'' (Irlam). This gives an uneven amount of power to large companies that have armies of lawyers. Even Heckel showed an understanding of this imbalance of power when he formed ``Heckel's Principle of Dealing with Big Companies: There is no such thing as a free lunch; unless you're the lunch'' (122).

The situation is even worse for open source software, which is often developed by dozens, if not hundreds, of individuals. Open source software often does not have a company backing it up and thus developers are more vulnerable to litigation. The nature of open source software also makes cross-licensing a non-viable option. An atmosphere of fear is created by the potential of legal entanglement due to software patents. The open source development models are vulnerable since they usually thrive off of the ability to move code back-and-forth easily. Requiring even small royalties would greatly hinder the freedom of developers to share the code they write. Software patents have a devastating impact on the feature-set that open source software can implement. Bruce Perens, a highly-visible open source advocate, pointed out in a LinuxWorld article that ``as Linux and open source software gain new capabilities that infringe on current patents, patent-holders will gain the power to hold [open source] systems back---potentially up to 20 years behind proprietary software'' (Perens). But with some changes the patent system could actually help the open source community.

According to Seth Shulman, author of Owning the Future, the patent system has allowed increasingly abstract patents to be allowed. At the same time, the courts have upheld these broad patents. Software patents would be much easier to deal with if they were kept very specific. Perhaps software patents should include reference source code. This would make it easier to verify or disprove infringement. Open source software would especially benefit if the code had to be licensed under a sufficiently ``open'' license. Developers would lose very little, but gain a lot, if their ideas were incorporated into actual products that were licensed openly. The increased communication would also boost the software industry as a whole.

Requiring software patents to include reference source code would be similar to the old requirement that patents include a physical model. It could be argued that since patents no longer include this requirement that software should not have a similar requirement, but such a requirement would be a good way to reform a system that ``disproportionately rewards ideas rather than their applications'' (Shulman 169). There is no real precedent for requiring an open licensing of all software reference implementations. Although ``some court decrees, though no decided cases, have called for royalty-free license or even dedication to the public'' (Section of Antitrust 49) of various patents. Requiring open licensing would simply be a recognition of the uniqueness of software and the software industry.

Software patents currently can only do more harm than good to the software industry. Their only real benefit is that they can give small companies legal leverage in a competitive marketplace. But this benefit is even greater for the large companies that generate thousands of patents a year. Even worse, this benefit does not readily extend itself to independent developers who are often involved in open source development projects. Despite the myopic fear that proprietary software developers have of open source software development, this area in the software industry is a major resource. Action should be taken to protect this resource and encourage its growth. By requiring software patents be licensed ``openly,'' the software industry would benefit due to increased software quality and larger markets for software.

Works Cited

``The Business Case for Open Source.'' Apr. 1999. The Open Source Initiative. 26 Apr. 1999 http://www.opensource.org/for-suits.html.

GNU General Public License. 16 Feb. 1998. Free Software Foundation. 13 Apr. 1999 http://www.gnu.org/copyleft/gpl.html.

Heckel, Paul. ``Debunking the Software Patent Myths.'' Communications of the ACM 35.6 (1992): 121-140

``High Court Declines to Review Ruling Seen as a Software Boon.'' The New York Times 12 Jan. 1999: C6

Irlam, Gordon and Ross Williams. ``Software Patents: An Industry at Risk.'' 4 May 1994. The League for Programming Freedom. 26 Apr. 1999 http://lpf.ai.mit.edu/Patents/industry-at-risk.html.

Lautsh, John C. American Standard Handbook of Software Business Law. Reston: Reston, 1985.

Mylott, Tom. Computer Law for Computer Professionals. Englewood Cliffs: Prentice-Hall, 1984.

National Research Council. Intellectual Property Issues in Software. Washington, D.C.: National Academy, 1991.

Nichols, Kenneth. Inventing Software: The Rise of ``Computer-Related'' Patents. Westport: Quorum, 1998.

``The Open Source Definition.'' Apr. 1999. The Open Source Initiative. 26 Apr. 1999 http://www.opensource.org/osd.html.

Perens, Bruce. ``Preparing for the Intellectual-Property Offensive.'' LinuxWorld Nov. 1998. 27 Apr. 1999 http://www.linuxworld.com/linuxworld/lw-1998-11/lw-11-thesource.html.

Section of Antitrust Law American Bar Association. The 1995 Federal Antitrust Guidelines for the Licensing of Intellectual Property: Commentary and Text. Chicago: American Bar Association, 1996.

Shulman, Seth. Owning the Future. Boston: Houghton. 1999

Stallman, Richard. ``Patent Reform is not Enough.'' 20 Mar. 1999. Free Software Foundation. 26 Apr. 1999 http://www.fsf.org/philosophy/patent-reform-is-not-enough.html.

``US4486857: Display system for the suppresion and regeneration of characters in a series of fields in a stored record.'' United States Patent and Trademark Office.

``Web Server Survey.'' April 1999. E-Soft. 26 Apr. 1998 http://www.e-softinc.com/survey/199903/index.html.


Submitted: May 31 1999
Last modified: Jan 15 2002 by Jason V. Morgan
morgan@cs.utah.edu