Are Software Patents Useful?

It is certainly encouraging to see reform of the U.S. patent system gain the attention of Congress (thanks, Rep. Lamar Smith!). Both the normalization with respect to international practices as well as starting to move damages more in line with actual harm. Clearly, the reform is trying to strike a compromise even among R&D-based companies: biotech and software being the poles. The debate for IT companies should be more fundamental: are software patents useful?

We should be judging "utility" objectively.

Patents are neither evil manifestations of corporate interests, nor an inalienable right of the subsisting lone inventor. They are contracts among us with the mutual self-interest of accelerating and sustaining innovation. Abstractly there could be lots of optimal points here, so we'll overlay a bias towards protecting individuals and especially individual freedom. In this sense, I'm not only highly aligned with Stallman, but have been heavily influenced by his thinking.

So, back to the basic question: are software patents useful, viz do they maximize innovation and the freedom to innovate?

My answer is "(mostly) No". And certainly not under our current view of how and for what they are awarded. And just to be clear, don't construe this as even a hint of criticism of patent offices around the world. These hugely overworked folks are doing what we collectively are asking them to do. It's an extraordinarily demanding job.

I say (mostly) no, because copyright appears to be (mostly) better for maximizing innovation while giving individual copyright holders the ability to modulate compensation and derived works. Larry Lessig (another primary influence in my thinking) and the folks at the Creative Commons have done a spectacular job of creating rather precise set points along this continuum.

What does copyright have to do with patents? With a mild fear of being pedantic, we have five basic tools at our disposal for controlling the distribution of our ideas and their expressions:

1. Public Domain. We can publish our ideas, and expressions of our ideas without restriction. A principal power here is that such publication can blunt or defeat any other person's attempt to obtain a patent, or to enforce copyright.

2. Patent. We can publish our (new and non-obvious) ideas in exchange for a time-limited exclusive right. That right being to \*exclude others\* from creating any expression of our idea. This is often misunderstood as a right of the inventor exercise the patent. It's not. It is the right to prevent others from doing so. One catch being that the invention may be dependent upon someone else's patented idea who could transitively exercise their right to exclude. Note that the "new and non-obvious" test is subjective and one that we ask our patent examiners to perform, backed up by (frequently technically lay) judges and juries.

3. Copyright. We can publish an expression of our ideas (code) with a vernier of exclusive rights, ranging from "you can't make any copies whatsoever" to "copy any and all freely, just propagate my copyright". There are two cool parts about copyright notices and source code: (1)they are both textual representations that can coexist in the same file, and (2) the copyright notice is a cudgel for a license agreement that can also go along for the ride: "follow the license terms or you can't make any copies whatsoever".

4. Trademark. We can freely publish our code but create a name and/or logo for the code (or, more typically, the binary build) that is sourced from us. In other words, others can use our code but they can't use our name for the code.

5. Trade Secret. Keep our ideas and our code a secret, and punish those who violate the terms of our secret agreement (e.g., an NDA). Of course, you always run the risk that someone else independently develops the idea and does 1,2,3 and/or 4 with it!

Copyright puts the licensing control clearly and explicitly in the hands of the developer. It can also capture a license for any related patents the developer might have obtained. Some of the most effective of these are "patent peace" grants, such as what we have done with CDDL: you get a grant to our patents as long as you follow the copyright license, including that you won't prosecute for any patents that you might have. If you do prosecute, then our patent grant is revoked.

So, in a way, the utility of a software patent here is that it can put even more teeth into the potential enforcement of a public license. That's fine when used this way. But any developer is always open to attack from a patent holder who has no interest in her code (e.g., a troll) other than to extract rents from having read upon the ideas in the patent.

I'm yet to see the case where these attacks are directly or indirectly useful. It's seldom that the patent holder is himself practicing it, so the patent peace provision is empty. These all seem to be taxes upon our industry. (At least we (Sun) have some resources to combat this. We paid almost $100M to Kodak to immunize the entire Java community from infringement claims on mechanisms that Kodak themselves don't use --- they acquired the patents from a third party. This was pure insanity, but we felt like we had to pay this in order to indemnify the whole Java community.)

Patents are a far more blunt instrument than copyright, and tend to teach far less than code. I just don't know of any developer who reads patents to understand some new software pattern or idea. Remember, the limited monopoly we grant a patent holder is in exchange for teaching others how to do it so that when the patent expires everyone is better off (the length of time of the grant is another issue. How long is two decades in software generations?)

Obviously, you make the case that these are the side-effects of an otherwise healthy dynamic balance around innovation. That individuals, start-ups and large companies do indeed need the protection in order to invest in basic software R&D that might yield, say, the reduce the solution to a previously exponential-time problem to a logarithmic one.

Certainly, we (at Sun) feel like we have put some serious coin into developing things like ZFS and dtrace, which we have published under a FOSS (Free and Open-Source Software) license (CDDL for now), and for which we have applied for patents. We will \*never\* (yes, I said \*never\*) sue anyone who uses our ZFS codebase and follows the terms of the license: they publish their improvements, propagate the license, and not sue anyone else who uses the ZFS codebase. And look at the innovation not only with ZFS in OpenSolaris, but its adoption by Mac OS X and BSD.

But under what conditions would we enforce our patents? How would we feel if someone did a cleanroom version of ZFS and kept the resulting code proprietary?

We wouldn't feel good, to be sure. But I'd put the burden back on us (certainly as a large company) that if such a thing were to happen it was because we were failing to \*continue to\* innovate around our original code. Being sanguine about patent protection as an exclusive right would result in less innovation, not more.

Our licensing of our Java implementations under GPLv2 are a case-in-point. The early returns are that we are seeing renewed interest and vitality in the platform and a real acceleration of innovation --- both from us as well as others.

There is a better state for fostering innovation in software. It's one built around the network itself, and one whose principles are grounded in the freedoms entitled by developers in the form of copyright. It's proving to be amazingly stimulating of innovation, and we ought to collectively drive our industry to state of complete FOSS. Either that, or take refuge in trade secrets and trademarks.

In case you haven't noticed, driving to a state of complete FOSS is exactly what we are doing at Sun. With some narrow exceptions, all of our software efforts are or will be under a FOSS license, and we will actively build and participate in communities around these code bases, and work as transparently as we possibly can. Why? Because it maximizes innovation. We have even taken the step of making some of our hardware design free and open. It's still early, but we think this style of open development will also yield a vibrant culture around OpenSparc.

Will we stop pursuing software patents on our software? Can't do that yet. That's simply because our competitors will still go for them, and unless our system changes, we'd have fewer "trading stamps" and end up paying even higher rates to indemnify the users of our software.

Is there anything short of eliminating software patents that could get us off that treadmill and drive us to a maximum innovation state? Well, maybe, given some additional restrictions on their granting. I have a few ideas having to do with teasing apart interfaces from implementations, but that's the subject of a future blog.


Post a Comment:
Comments are closed for this entry.



« December 2016