Subject: Re: GIF/LZW patent
From: Thomas Lord <>
Date: Wed, 27 Sep 2006 14:36:05 -0700

Lawrence Rosen wrote:
> I'll be blunt about it: If we didn't have copyright on software and only had
> patents, we'd be much better off. At least then monopolies would be based
> upon innovation instead of mere writings by armies of programmers of mostly
> me-too code. Programmers would be rewarded for being innovative, and the
> rest of us could otherwise copy and reuse any non-patented or off-patented
> software we wanted, regardless of who wrote it. That's how intellectual
> property works in every other area of technology! Wouldn't that be a better
> world?

No, but nice try.   It's a little hard to convey why it doesn't work but
I'll try.

The problem is that valuable innovation in programming often
falls well below the level of a (useful) patent and also often nicely
matches the protection of copyright.

For example, let's hypothesize that the Scheme programming language,
in light of the new revision to the standard, is about to really take off
as a commercially valuable language.

One thing that's desirable is some new implementations, well tuned
for popular hardware and certain broad categories of application.

There is pretty much no new technique needed to create such
implementations -- nothing that need rise to the level of a patent.

At the same time, what will make a really great new implementation
is making a very careful selection from among thousands of little
choices that come up and combining all of those thousands of little
choices into a single source *text*.    You don't need to understand
these technical terms in detail but maybe hearing just the syntax
of how it could be described will help.   I've marked the terms that
suggest some of the "little choices" that are being added up:

   SCM uses "three bit tags in object references"* and so eight-byte
   aligns objects, "all of which are represented as 8-byte objects"* so
   cons-pairs are very compact and the main allocator is simplified.
   Within objects, are "additional variable-width tag bit sequences"*
   and so dispatch in a graph-code based 'eval' is simple and pretty
   quick.  The result is that there's enough tag space to use a bunch
   of types as opcodes and so 'eval' does "graph-rewriting to incrementally
   compile input forms"*.   This works out to a simple enough `eval'
   that its code fits easily within a typical L1 cache which gives
   it some interesting performance characteristics.

Every one of the ""* terms indicates a technical choice that was well
understood more than two decades ago.    The combination of these
little choices "harmonizes" well -- for example, the way the allocator
and 'eval' are both simplified by the tagging choices is one of the
beauties of this particular implementation.    Thousands of additional
little choices add to the harmony.  

And that's the problem.   With a patent, one could *try* to characterize
the chord.   SCM's author was the first one to put all of these elements
in just exactly this way.    But there's no way to formulate a useful
claim.   Either the patent description of the combination of all of these
choices is so vague that a patent ought to be denied or so specific that,
ok, I'll take his (un-copyrighted, in your world) code and modify it just
enough to evade his claims.

Now, on the other hand, let's suppose that you do speaka-my-language
on tech stuff and you write me up a nice paper describing several hundred
of the most important choices in SCM and tell me to get to work doing
a clean-room implementation.    I can certainly do that, but, hell it ain't
gonna be cheap.   How long does it take to write a really intricate
string quartet?  Or a symphony?    If you want this thing anytime soon,
you're first bet should be to try to get rights to the SCM author's
*text*.   The definitive, operational record of all those thousands of
tiny choice.   And so, it is precisely in your rights with respect to that
text that we should vest the SCM author's exclusive rights.   In other
words, some form of copyright is the right tool for the job.

There *is* a twisted way in which I agree with you but it's more of
a syntactic or tactical agreement than anything deep or strategic.

What we could do, given only patents, is to let the author of SCM
use his program text, perhaps with some notes about the most important
aspects of it, as the specification of his patent.   And then we would
need rules: what infringes, what doesn't?   If I start with his text and
change some stuff, when have I stopped infringing?   Pretty soon we'll
have invented the idea of "derived work" and we'll be counting certain
forms of distribution as practice.   In short, we'll have implemented
the copyright system we have, more or less, as a bunch of special case
rules for certain forms of patents.   And we'll have smooshed together
the legislation of terms and penalties, for whatever *that's* worth.