Re: Why are software patents wrong?

[Rex Ballard]

threeseas <timrueAT@mindspringDOT.com> wrote in message 
news:<TF_bd.5313$gy1.3939@newsread1.news.pas.earthlink.net>...
> Two catagories of answers:
> 
> symptoms and cause
> 
> or from the other direction:
> 
> cause and effect.
> 
> Seems to me many have found arguement against software patents that only 
> deal with the symptoms or effect of software patents, rather then the 
> more fundamental underlying reasons why software doesn't qualify for 
> patent status.

Up until about 20 years ago, the patent office agreed with you.  After
all, software is an expression of an algorythm, and algorythms are not
patentable.  The particular expression of that algorythm is
copyrightable, but not patentable.

In the early 1980s however, the lines began to blur.  The invention of
gate arrays made it possible to "program" circuitry.  Was a programmed
gate array an algorythm, or an electrical circuit?

A court ruled that a programmed gate array was an electrical circuit,
therefore it could be patented.

At that same time, we also got the microcontroller.  This was a small
device which contained a CPU, RAM, ROM, and I/O pin/ports - all in a
single chip.

When a microcontroller was programmed, it could perform the same
functions as a programmed gate array - such as encryption,
compression, or other logic.  The court was shown two single chip
devices, one implemented as a programmed gate array, the other
implementetd as a software algorythm on a microcontroller.  The court
couldn't even tell which was which, neither could expert witnesses. 
The court ruled that such a device was patentable.

Still, it was very difficult to get a software patent.  Most software
patents were initially rejected then appealed to the court.  The court
might then award the patent, but just as often, it did not.

Eventually, in 1995, changes were made which made it easier to apply
for patents and made it easier to grant patents on software. 
Unfortunately, this meant that there was no prior record of software
technology from 1940 to 1995, upon which to search for prior art.  As
a result, millions of patents have been granted for prior art.  In
most cases, the patent grantee is applying for a "defensive patent". 
That is, they are applying for the patent to make sure that they don't
get sued by some "slip and fall lawyer" who helps someone who claims
to have invented a technology from filing for a patent and filing a
lawsuit against a big company who has deep pockets.  Even if the award
is minimal, the legal fees are paid by the loser, and if the award is
big, the contingincy fees can be huge.  Either way, not having
something patented before you start shipping it is an engraved
invitation for these "shark" lawyers to rack up huge legal fees.  Even
if you win, you spend hundreds of thousands of dollars defending the
frivilous lawsuit.

Of course, these types of patent applications also have the benefit of
including volumes of "prior art" into the public record, especially
the patent office archives.  Typically, someone seeking a defensive
software patent will cite precedents going back 20, 30, even 60 years,
as a way to make sure that any attempt to sue or claim "prior art" is
thwarted by further claims of prior art.  A good defensive patent can
often be nullified by it's own "prior art" citations, which is also an
acceptable outcome when the patent owner is the defendent.

The problem we have seen more recently is the suddent emergence of
"software patent specialists", lawyers who will help someone file a
patent, often ignoring ALL prior art not in the patent office archive.
 They are granted the patent, then they proceed to attempt to file
lawsuits against companies with deep pockets.  In most cases, they are
just hoping for a quick and cheap settlement, preferably for enough to
cover the legal fees, with just a little extra for the client.

> So how about it?
> 
> why do you think software should not be patentable? and is your answer 
> cause or effect?

In practice, about 99.99% of all software isn't really patentable. 
With the availability of public specifications and standards, or just
simple observation, the average college freshman in computer science
can implement much of the so-called "patented" software.  The
implementation may be different, and might even be significantly
different, but implements the same claims.

The counter-argument is that it's the software CLAIMS that make a
patent legitimate, and that it's the claims that can be enforced. 
Patent claims are the part of the patent that explains why this device
is useful.  There have been several situations now, where people have
tried to file patent lawsuits based not on a duplication of the device
(the algorythm and it's expression), but rather on the claim - even
though the actual implementation of the device was significantly
different from the device patented by the plaintiff.

Many of these claims are very broad and general, which is something
that lawyers  love to do in patent filings.  And when someone
implements a piece of software that performs the same function - no
matter how different the implementation, the patent lawyer can file a
lawsuit based on the claim.

The real creativity comes when the case is heard before a jury.  In
some cases, when there is a home court advantage, when the jury has no
knowledge of software and wouldn't know a "for loop" if they saw it,
the jury can do very strange things.  They can rule in favor of the
plaintiff even when a qualified expert clearly states that the
patented device and the defendent's device are completely different.

In addition, there is always the risk that the Judge will limit the
use of prior art.  For example, the judge may reject thousands of
pages of usenet archives, because the original authors couldn't be
verified and/or cross-examined.

There is even the possibility that public domain software archives
would not be admissable because the original author's identity could
not be verified.

Remember, in most of these cases, the plaintiff's lawyers are doing
everything they can to prevent disclosures which would demonstrate the
existence of prior art, therefore making the device unpatentable.

The problem is that the rules of legal evidence required to apply for
a patent, and the rules of legal evidence required to defend a patent
are different.  Before a patent can be granted, a patent search must
be conducted.  This search covers all of the prior art that might be
similar to the patent being applied for.  The patent has to
distinguish itself from these prior patents in a non-trivial way.

The problem with software patents is that algorythms haven't been
patentable until about 9 years ago, but the prior art not archived by
the patent office covers nearly 10 million staff-years of invention. 
You have 60 years of prior art, and millions of programmers and
software developers ranging from students and hobbiests to full-time
professionals with PhD degrees.  But none of their contributions exist
in the archives being searched during the application for a patent.

The problem is that there is no watch-dog to make sure that these
archives are searched before a new patent is granted.  It's entirely
possible and legal to mine some great idea out of a public archive
such as a usenet newsgroup not covered by Google, or a mailing list
not covered by Google, patent the idea, file a lawsuit against IBM,
Microsoft, or some other company with huge pockets, demanding $1
billion in damages, then suppress as inadmissible, the very archive
from which the patented device was "stolen".  After a few preliminary
motions, you get a settlement offer for a few $million, and this fuels
and even more frantic "feeding frenzy".

The Kodak vs. Sun case was a perfect example of why software patents
are such a terrible idea.  The prospect of protecting, for 20 years,
some device that was first published 20 year ago, simply because the
archive doesn't "legally exist", just creates a rediculous series of
opportunities for scams and hustles.

Software patents are way too easy to get, way to too easy to defend
through obstruction of justice, and way too easy to exploit. 
Fundamentally, there might be some patents that might have been
legitimate - such as RSA encryption or Limpel-Ziv-Welch compression,
but these are the very rare exceptions.  Most of these software
"devices" are more like trying to patent a recipe in a cookbook.

Software development is both science and art, and should be treated as
such.  This is why copyright licenses were implemented in 1977.   The
problem has been that we have this "nondisclosure disclosure" abuse of
copyright law.  The binary code is copyrighted, but then the source
code and the reverse engineering - the understanding of "how" it
works, has been protected under trade secret laws - simply because it
is almost trivial to create new artistic expressions of the same core
algorythm.

The big problem now is that you have about 3 billion lines of code,
including much of it Open Source, which is not being checked as "prior
art" before granting a patent.

The current implementation of patent law, as it has been implemented
by the current patent office structure has became little more than a
"free-for-all", with little regard for original creators.  It's the
biggest "property grab" the United States Cavalry drove the Indians
from the plains and the southwest onto reservations in the deserts of
Arizona, New Mexico, and Colorado.

Rex Ballard
http://www.open4success.org