🚀 go-pugleaf

In article <870@nddsun1.sps.mot.com> waters@nddsun1.sps.mot.com (Mike Waters) writes:

   In article <1991Feb28.111753.2@minerva.inesc.pt> fmhv@minerva.inesc.pt (Fernando Manuel Vasconcelos) writes:
   A previous poster writes:
   >>And since I personally can't afford the $10k it would cost to get a
   >>single patent search, 

   A patent search can be done (yourself) at your local University library
   for very little cost or free. Copies of the patents are available for
   the cost of copying from several sources. It DOES take time though.

A patent search will be of little use with software if you are trying to
ensure your code doesn't violate any patents, because a) it won't reveal
pending patents, or patents not yet applied for; b) it won't reveal things
you aren't aware you've "created" in your code that somebody else doesn't
think is "obvious", especially if you "created" such things by simply running
an optimizing (or especially a globally optimizing) compiler to build your
application (theoretically, such a program could create the concept of
backing store and the XOR cursor solution entirely on its own).

   >>I'm not really likely to go hunting next time I
   >>write an expert system that uses X as its interface and happens to use
   >>a data entry screen to get information from the user.

   If you sell the code then you take your chances just like any other
   business. If you give it away without charge there is no profit in
   suing you is there?

There is if you've got money.  I don't think the courts will care much what
you charged for the product -- the issue is not how much did you get for
the product, but how much should you have paid in licensing fees, and whether
treble damages should be awarded.

   >The first one adresses those who would have to grant the patents:
   >For those the problem would be: What criteria will we use to grant
   >a patent ? This is a difficult problem to solve. 

   A problem which has been hashed out in every country of the world, with
   remarkable similarity in the results - the present patent system!

Not the PRESENT patent system, but the one before around 1982 -- the one
where obvious things and "nature" could not be patented.  In that system,
backing store and XOR cursors and the like could never have been patented,
nor could most of today's software patents.

   >This price would put off every small software company ...

   Why? Why hasn't this happened in fields like instant cameras (Land vs
   Kodak), electronics etc.?

There are several reasons I can think of.  First, software is much more fluid
and new inventions instantly realized -- compare the amount of time it takes
to implement a new idea, say like a new paper clip, where you've got to
prototype it, find just the right materials, come up with (and patent) a
production process, and so on, where "matter" is involved, to a new idea
in software -- where once you have it, you can simply "type it in", see if
it works, and then ride the coattails of all the abstraction software gives
you (i.e. no need to work out the issue of materials or production, since
computer hardware already abstracts that away).

Further, we are as yet nowhere near the point in time where one can build a
machine that, given requirements like "we need a new substance which is
stronger than steel, pliable like wood, cheaper to manufacture than
fiberglass,..." and it automatically figures out what kinds of new (or old)
materials fit the description by analyzing the knowledge base of quantum
mechanics.  So processes and products that are matter-based, the key phrase
being "involving the transformation of matter" in one class of patentable
processes, are quite challenging to invent -- you not only have to conceive
of a new idea for what a useful substance or process might be, but use both
insight and perspiration (plus a lot of expertise, of course) to figure out
what it actually IS and how to build it.  For example, everyone knows that
a process to convert iron to gold might be very useful, especially if it isn't
too expensive to run -- but that idea is no good without the insight and
effort to divine such a process.  On the other hand, if someone invents it,
then our patent system will do a very good job of protecting their effort
for 17 years, and legally prevent anyone else from using the same process
on their own (or of course selling a machine that implements it).

Compare this to software, where for the most part once you think up a neat
new way to do something, it is fairly trivial to implement.  Hence the fact
that most clever programmers create "50 new inventions by breakfast" --
they're not smarter than their physical-scientist counterparts, just working
in a field where realization stands an extremely short distance away from
inspiration.

For example, I understand Apple's Hypercard doesn't have multiple scrolling
text fields in a single card (window), because somebody else has a patent on
that IDEA, which of course Apple probably isn't too happy about.  Think
about it: this means YOU cannot make a product that puts more than one
scrolling text field into a window, no matter what windowing product you
use, or whether you sell the product or just make use of it on your own.
Yet a) it's obviously a useful idea, when you come up with a need for it,
only a constrained windowing system might prevent you from thinking it up
on your own, and b) once you have the idea, it is fairly easy to implement,
and voila, you have a patent??  Sheesh!

As optimizers get smarter and smarter and descriptions (programs) get higher-
level, the "inspiration" won't exist any more in many cases -- the optimizers
might well be "inspired" to create a new invention based on the programs
they've been given along with the requirements and restrictions they have.
If this isn't already happening now, a) it can be shown to be possible for
most software patents in existence today, and b) it will start happening
within 10 years.

In other words, we're far closer to someone typing in high-level requirements
for a general-purpose window-system interface, giving them to an optimizer,
and having that optimizer "come up" with the idea of backing store without
any prompting from the programmer (and little or no awareness on the part of
the programming that such a thing was invented), than we are to giving the
requirements to transform iron into gold cheaply and without annihilating
earth to a machine that either says "here's how" or "can't be done in this
universe".

By implication, this means that when we do get such a machine, I'd suggest
(and this should be agreeable to most everyone) that many patents regarding
the transformation of matter would become invalid.

Once we get sufficiently robust global optimizers, it'll be a bummer if we
all have to incur the expense of doing patent searches on every "interesting"
thing we find in the machine code they produce to make sure nothing too
radical has come about that might be patentable OR already patented (or
might be in the process of being patented), because that'll cause the
industry to fall apart (due to high costs) in no time -- small businesses
first, of course.  In fact, if you're writing programs in C++ using someone
else's class library, I'd suggest you already are at risk of violating
patents, especially if the library provides inline implementation of various
algorithms.

The patent process is one that protects not the idea, but the sweat and toil
and inspiration that goes into making the idea PRACTICAL.  At least, until
around 1982, when the patent office decided to "give businesses a break"
and allow more leniency in patenting things it never used to allow, like
laws of nature -- which is what backing store and XOR cursors are, in
essence.  With software, making the idea practical is not what gets
patented, because it is nearly a "nil" effort -- certainly dressing up an
algorithm in a main(argc,argv) function wouldn't be patentable, would it?

On the other hand, if somebody gains some incredible insight and/or puts in
tons of human-mind (i.e. not machine-reproducible) work to discover something
like, say, that most American English text has certain frequently repeating
patterns that nobody else has noticed before, allowing incredible degrees of
compression, then I'd say that such a discovery should be patentable even
though it is, in essence, a "software patent" -- because is isn't a law of
nature, nor is it obvious.  Things like statistically based compression and
such, however, are ridiculous to patent, because although some new ideas are
involved, they appear (to a nonexpert like me) to be largely a stab at trying
a new statistical technique, seeing how well it works on a large body of
sample text, and picking the best "stab".  This is too easy, especially
compared to things like inventing a new drug, to allow a patent for it.
Spend 5 years analyzing English and implementing various AI algorithms to
help you analyze it, and show how the knowledge you've gained can improve
compression of text by an order of magnitude or so, and you probably should
deserve a patent for it; spend 5 days plugging in various fairly well known
statistical methods to a compression program skeleton and trying them out
on sample text to pick the best, and you deserve only a copyright on a
program you write to implement it, but no patent.

   >It's very difficult ( if not impossible ) to grant software patents judiciously.Even if we could manage that the prices involved would be enourmous
   >This proces would put off every small and medium software company.
   >Thus making more damage then good ....

   Please explain just what makes software so uniquely vulnerable? More so
   than say circuit design which has always had patents, innovation and
   small companies.

Software is uniquely vulnerable because the patent office refuses to use
computer science people to assess the patentability of software patents,
whereas they use chem people to assess chem patents and so on.  Nobody in
the patent office who figures out whether a new software patent is obvious
or based on prior art has any idea what IS obvious or prior art in the
software field.  Certainly they have no idea what can be derived by machine
simply by entering various general descriptions of a problem, as proved by
backing store and XORing cursors and such becoming patents.  MOST software
patents, I'm told, boil down (and the boiling process is itself tedious,
because patent lawyers ensure patents aren't readable) to laws of nature,
obvious things, or prior art.

The other problem is that it is so trivial in software to combine several
general, obvious/law-of-nature/prior-art features in a new way.  Backing
store is simply combining the general knowledge that "if a given function
is hard to compute, and if you've computed it before on a given set of
inputs, then save its output because then you can use that output directly
if an attempt is made to reevaluate the function on the same input" --
though only when the time vs. space tradeoff is worthwhile -- with the
domain of a windowing environment where the function is the set of drawing
primitives applied to text/data, its output pixels on a bit-mapped display,
and evaluation the act of exposing or reexposing a window or a portion of
a window.  There isn't anything concrete I can think of that separates
this patent from a potential patent on almost any caching or optimizing
function, including things today's optimizing compilers do, except that it's
been narrowed to the field of windowing systems!  Yet that kind of
specific narrowing is an anathema to software growth, since what makes
our industry grow by leaps and bounds is largely the ease with which we can
apply working algorithms and ideas in one domain to another entirely different
domain (which is what the process of porting applications to another machine
is, in essence, for example).  Note that in the backing store case, the
tradeoff was usually in favor of time vs. space, except for certain cases
like MIT's Lisp Machine (for which I'm told backing store was "invented")
where lots of memory was available -- once memory became cheap, it was
basically trivial to start trading off space to gain time, and this is all
that the backing store patent really does -- it says "as of this date, AT&T
decided to trade space for time in windowing systems, because memory became
cheap enough to do so" and, in esence, nothing else, except "and we reserve
the right to apply this tradeoff to windowing systems and the redraw
function for 17 years, and license use of this tradeoff to anyone who pays
us enough money".  Make sense to you?

--

James Craig Burley, Software Craftsperson    burley@ai.mit.edu