Subject: Re: patent trolls and X-licensors
From: Thomas Lord <lord@emf.net>
Date: Wed, 31 May 2006 08:41:29 -0700

Stephen J. Turnbull wrote:
> But the only reason you can get away with this is because it's so
> difficult to discover what the applicable patents are.  *If* there
> were an effective search engine, "I didn't know" would get you about
> as far as "but Officer, I'm colorblind and astigmatic, I thought that
> stop sign was the Golden Arches."
>
>   

There are some problems with the idea that a better
search engine will make software patents viable.

The first problem is that in computer programming,
seemingly more than in many other fields, there are
many different ways to describe the purpose and form
of an invention.    In fact, "purpose" and "form" are
often so abstract that it takes original, creative thinking
to make the connection between the patent and the
program being charged with infringement.  RMS
often cites two examples related to this: First, a patent
for "compiling formulas into object code" that was
applied to natural order recalculation in spreadsheets
about which RMS quips "When I first saw it, I thought
it was the wrong patent."  Second, some patents that
were used to attack Apple over Hypercard.   When
the patent *holder* first saw hypercard he didn't think
his patents applied -- later his lawyers persuaded him
otherwise.[1]   If those people have trouble seeing
the connection between the patent and the allegedly
infringing program, how well do you expect a
search engine to do?

We don't know, just from RMS' anecdotes, how common
those kinds of problem are.  I would say it is not a bad guess
that they are very common because it is part of
the art of writing patents to make the claims as broadly
applicable as possible.

Second, in software more than in certain historic
fields, the length of time between patent application
and grant is very significant.   Suppose that
a new class of techniques for applying AJAX
technology becomes widely apparent -- but each
of these new applications involves doing a little
more work first.   This can easily result in hundreds
of new patents whose existence will become known
only after a year or two -- no search engine can help
find the applications.   Well, most of the interesting
development using that new class of techniques is
going to take place in that same initial year or two.
So the result is that everyone hacks for that time
and *then* the patents are unveiled and we get to
see who lost the lottery.

Third, let's suppose we have a perfect patent
search engine.   You type in a description of the
program you are thinking of making and the search
engine gives you back an exactly correct list of all
of the patent holders who might sue you and not be
immediately and prejudicially laughed out of court.
In the common case, for any substantial program,
you should expect that list to be very long.  You
should expect that no matter how you change your
plans and tweak your query, that list will remain
very long.  So what are you supposed to do?

I say that that's the "common case" because that's
the entire theory behind the practices of cross
licensing and patent trolling.

In fact, it is a "bug" in the system of patent law
that it creates incentives to promote that common
case -- the case where no matter what you do many
patent holders can potentially sue you.   The
incentives arise because of a combination of three
factors:  (1) the abstract nature of
programming -- the problems in defining "purpose"
and "form";  (2) the unusually cumulative nature
of programs -- that every substantial program is
very likely to combine thousands and thousands
of distinct techniques and components;  (3) the
low cost of patents relative to the pretty high
cost of fighting in a patent suit relative to the
very high cost of losing a patent suit.

You can't change (1) or (2).   You can't raise
the cost of obtaining a patent very far or
protect "small guys" from the high costs of
fighting and maybe losing without running
afoul of equal protection.   You can't
streamline the court system to lower the cost
of fighting much.   You can't cap damages
low enough to make a difference short of
essentially scrapping software patents altogether.

Inexorably, the potential patent licensing cost of
nearly every substantial program one would care
to write these days goes up and up and up to
the point where paying all of those license fees
would make it uneconomical to write the program.

The only option left -- to those who can afford it --
is to create a stable of "defense patents", engage in
cross-licensing, and essentially nullify the patent
system (for those who can afford it).

And even that last resort option, available only
to the rich, isn't foolproof.   It invokes a vulnerability
to a class of rich people who create stables of
"offense patents" and demand not cross-licensing,
but tribute.   In the large gap between the low cost
of obtaining a patent and the high cost of losing an
infringement suit, the "offense patent" trolls find
plenty of pricing support for their protection racket.

You have this vague idea, Stephen, which I kind
of like:   programming *is* cumulative.  There
*should* be more "leggo(tm) block assembly"
going on.   Great libraries of algorithms, techniques,
and code components -- well organized for search --
may very well help (people have been saying so
for, like, 30 or 40 years, I believe).   And economically
speaking, if we could create an incentive to contribute
to that library based on rewards for what is taken from
the library -- that'd be a very nice alignment of interests.
But software patents aren't the right mechanism there --
not by a long shot.

-t