Solutions to the Software Patent Problem

Speech given at the Locatelli Center, Santa Clara University,
in November 2012 (video,
metadata)

Andrew Chen: Thank you, Eric.

My name is Andrew Chen. I teach patent law at the University of
North Carolina, and I had a previous life as a Computer Science
professor.

I have the easiest job today, which is introducing two men who need
no introduction. Richard Stallman, we know, is the founder of the
free software movement, co-founder of the League for Programming
Freedom, lead software architect for the GNU Project and author of
Emacs, which he's described as a text editor and also a way of life.
Something that I can agree with, having written my doctoral
dissertation using his program.

Dr Stallman has decided not to participate in the live streaming
facility for today. He explains that use of the streaming online
would require use of the Microsoft Silverlight plugin, which would
pressure people to use proprietary software. Dr Stallman considers it
wrong to pressure people to do that. He would like you to know that
he plans to make a recording of his presentation available at a later
time in either the Ogg Theora or WebM formats.

Dr Stallman.

[applause]

Richard Stallman: Can the tech people please confirm that
the streaming is off?

OK, I think that's confirmation.

So, why are software patents bad? Or, “computational idea
patents” as I think we should really call them, because each one
is a monopoly on a computational idea. Most people, when you say
“software patents,” they think it's a question of
patenting a specific program. I'm sure all of you know that that's
not what those patents do, but most people don't know that, so, to try
to avoid misleading people, I call them “computational idea
patents.”

So, anyway, the reason these are bad is that they deny people the
freedom to use their computers as they wish and do their computing as
they wish, freedom that everyone must have. These patents put all
software developers in danger, and their users as well. A danger that
there is no reason we should stand for. So: we should protect
software from patents. Software needs patent protection: protection
from patents.

But most people don't know enough about what patents do to
appreciate why patents that can restrict software are so harmful.
Most people think that patents are like copyrights, which is not true
at all. The sum total of what they have in common is one sentence in
the Constitution, and that similarity is so little and abstract it has
nothing to do with the practical effects.

So, the last thing we should ever do is use the term
“intellectual property” that confuses not just these two
laws, but a bunch of other unrelated, disparate laws, that don't even
share one sentence in the Constitution with those two. So that term
spreads confusion whenever it's used and about eight years ago I
decided I should never use it and I have never used it since then.
It's surprisingly easy to avoid, because in general there's no reason
whatsoever to use it except that it's chic. And once you learn to
resist that, it's as easy as pie, just talk about one law, and then
you call that law by its name, and you're making a coherent, clear
statement.

So, I have to explain to people what patents do, and show them that
it's not at all like what copyrights do. An analogy is a good way to
do this. What can you say about programs? Well, they're large works,
full of details that all have to work together to get the desired
result. Well, what else is there like that? A novel, or a symphony.
So, imagine if the governments of Europe in the 1700s had had the
cockeyed idea of promoting the progress of symphonic music with a
system of “musical idea patents.” So, any musical idea
statable in words could have been patented. A melodic motif could
have been patented, or a series of chords, or a rhythmic pattern, or a
pattern of repetitions in a movement, or the use of certain
instruments while the rest of the orchestra is silent and a bunch of
other musical ideas that I can't think of, but maybe a composer
would.

So, now imagine it's 1800 and you're Beethoven and you want to
write a symphony. You're going to find that it's harder to write a
symphony that you don't get sued for than to write a good symphony.
Now, you'd probably have complained, and the patent holders would have
said “Oh, Beethoven, you're just jealous because we had these
ideas before you. Why don't you go think of some ideas of your
own?”
Of course, Beethoven is considered a great composer
because he had lots of new ideas, and not only that, he knew how to
use them effectively. And that is: combined with lots of familiar
ideas, so that his pieces were merely shocking for a while, but people
could get used to them. They were not so alien and incomprehensible
that they got rejected. They shocked people for a while, people got
used to them, and now we don't see what's shocking any more, because
we're used to those ideas. Well, that's the proof that he used those
ideas well.

So, the idea that anyone could, or should have to, reinvent music
from zero, is absurd. Not even a Beethoven could do that, and it
would be silly to ask someone to try. It's the same with computing.
Just as a symphony implements many musical ideas together, but the
hard part is not picking a bunch of ideas. The hard part is
implementing them together with notes. It's the same with software.
A large program will implement thousands of ideas together. But the
hard part is not picking some ideas. It's easy to pick some ideas.
What's hard is to implement them all together and make it work
well.

So “computational idea patents” obstruct the hard and
big job by promoting resources that we get plenty of anyways. So it's
a misconceived system. Designed to give us help we don't want at the
cost of tremendous problems.

So what we need is to get rid of the problem. What is the problem?
The problem is: software developers and their users are threatened by
patents. They are in danger. How can you prevent that? Well, one
way is: don't issue patents that could affect software. That solution
works if you apply it from the beginning. If a country never issues
such patents, then its patent system doesn't attack software. OK,
it's a good solution. But it's not applicable if a country has
already issued hundreds of thousands of software patents.

Now, I've proposed that constitutions should explicitly say that
patent privileges can be reduced just as they can be increased. That
they are not in any sense somebody's property; they are privileges
given out by the government which can be changed at will. After all,
if you allow the government by legislation to increase them, it's
absurd to make this a one-way ratchet. But that's not in the US
Constitution.

So, what can we do? Well, we can ask courts to rule that all those
patents that restrict software were invalid from the beginning and
always have been invalid, and that gets rid of them all. However,
that's not something that people can lobby for. It's not something we
can say to officials, “do this because we want you
to.”

So, if we're going to look for a solution that we can get
implemented, what is there? Well, the only way I can see is to
legislate that software is a safe harbor. If it's software, then
you're safe. Circuits to do the same computation would be covered by
a patent, but if it's software, then you're safe. But what does that
mean? What does it mean for something to be software? Well, it runs
on a general purpose, universal machine. So first you make a
universal machine and then you put in the program to say what it
should do. Well, if the machine's only function is to be universal,
then the program is all that implements any specific, patented
idea.

So, that's the case I want to get at, and I'm trying to separate it
from a case like that in Diamond vs. Diehr where there
was a patent for a system, a method of curing rubber. The
implementation involved a computer, but it also involved special
purpose hardware, not a general purpose universal machine, and that
special purpose hardware was crucial to carrying out the patented
technique.
It wasn't actually a software technique. And, actually, I
read an article by Pamela Samuelson arguing that the CAFC twisted that
decision and basically got the quantifiers in the wrong order. That
the Supreme Court said, “the fact that there's a computer in
there somewhere doesn't automatically make it non-patentable,”
and the CAFC twisted that into “the computer makes it
patentable.”

Anyway, we might have some hope with the courts, but I'm proposing
a method that will separate the cases that we must protect from
non-computational idea patents that affect systems that might be
implemented with a computer in there somewhere. The precise words to
use? Well, the best I could come up with was: “software running
on generally used computing hardware.” We certainly want things
like smartphones to be covered; we don't want it to exclude anything
that has any kind of special-purpose hardware in there.
The portable
phone obviously has specialised hardware to talk to the phone network,
but that shouldn't automatically mean that if it's running on a
portable phone, it's vulnerable to patents. Because that is a general
purpose computer and people use it for all sorts of things. But my
words, “generally used computing hardware,” they may not
be the best possible words. This is a subject that I think calls for
study, because we've got to look at each possible wording that might
be used and see which cases would be protected from patents and which
would be exposed to come up with the right method.

Now, every time I suggest a method to solve this problem, the first
thing people try to look for is how to half solve it instead. The
idea of really solving the problem shocks people because it strikes
them as radical. They think “I can't advocate something so
radical as to really solve this whole problem. I've got to look for
some partial solution that will only protect some software
developers.”
Well, that's a mistake. It's a mistake a) because
it wouldn't do the whole job, but b) because it would be harder to get
it passed. There are lots of software developers and they are all
threatened and if we propose to protect them all, they will all have a
reason to support it. But if we propose to only protect some of them,
the rest will say “well, this doesn't do me any good, why should
I care?”

So, let's propose a real solution. And, besides, partial solutions
tend to be vulnerable to the problem that Boldrin and Levine have
written about very effectively, that it's easy for the pressures for
patents to stretch the boundaries if you give them any kind of
boundary that they can stretch. And this, by the way, is another
advantage of applying a change to suing people, rather than to what's
patentable. Because there, the criteria are just “what kind of
situation is this?”
It's harder to stretch those, and if they
tried, it would always be in a case against somebody who's going to be
fighting not to stretch it. So it's less vulnerable to being
distorted from an intended restriction of substance into an actual
requirement of form of patent applications, which tends to happen to
any kind of requirement about what patent applications have to look
like.