W3C home > Mailing lists > Public > www-patentpolicy-comment@w3.org > September 2001

against accomodating patents

From: David McCusker <david@treedragon.com>
Date: Sun, 30 Sep 2001 15:59:46 -0700
Message-ID: <3BB7A3E1.42E0F557@treedragon.com>
To: www-patentpolicy-comment@w3.org
http://www.treedragon.com/ged/map/ti/newSep01.htm#30sep01

30sep01 Sunday @ 
? I almost wrote a new essay on software patents yesterday. 
? This might have made the following a little easier to write. 
? But what I wrote yesterday also helps, though it's abstract. 
? Consider Francisco Varela on emergent patterns from rules. 
? I'll summarize this view shortly before my patent analysis. 

? Note all this material is motivated by Dave Winer today. 
? He wrote a new DaveNet piece on Patents and the W3C. 
? Today is the last day for public comment on patent policy. 
? This big problem is that this gives legitimacy to the scam. 
? Encouraging the patent buggers will only make it worse. 

emergent properties @ 
Complex systems often emerge from very simple local rules. 
Rule systems in living organisms make member boundaries. 
Then emergent behavior often creates insides and outsides. 
This also applies to social organisms as well as individuals. 
(Social rules often focus on who belongs and who doesn't.) 

Obviously this has applications in war causes and strategy. 
Integrity violation provokes fights and subverts coherency. 
But today I want to talk about software patents, and not war. 
(Though of course, software patents are for business wars.) 
Software patents do not have effects as are officially stated. 

The main purpose of software patents is to create barriers. 
They mainly separate developers into insiders and outsiders. 
The losing outsiders face legally enforced barriers to entry. 
Okay, this is the cost to our society. So what is the benefit? 
Mainly it makes the powerful rich without doing more work. 

I explain below, telling why software patents don't do more. 
The actual emergent effect is to support business oligarchy. 
And you'll have a devil of a time seeing this from the rules. 
But you're being hoodwinked by entrepreneurial fairy tales. 
Because software patents rarely if ever contain novel ideas. 

limited choices @ 
To grasp what I'll say about patents, you need background. 
Almost all software is based on extremely few basic devices. 
A very small number of operations generate all end effects. 
Here I mean the higher level patterns than CPU instructions. 
But even there it's possible to reason by very simple analogy. 

For example, one basic idea is find or lookup operations. 
In CPU architectures, this amounts to indexed dereferences. 
Software does the same thing, just with more indirect chains. 
Anyone who tried to patent this basic idea would be insane. 
Or they might be considered a devilishly clever businessman. 

I'd guess there's no more than, say, 100 basic coding ideas. 
Around ten to twenty are the core set used to do everything. 
Some of these are used in very standard group combinations. 
For example, the main workhorse operation is called binding. 
This means (approximately) associating values with symbols. 

For example, your browser turns a URL into this web page. 
That's binding. It occurs at many nested levels in software. 
Lots of my runtime work is just binding in numerous guises. 
Most code complexity involves tuning what binding means. 
Why do mouse clicks in separate places do different things? 

Binding. Software uses spatial context to see click meaning. 
In coding languages, lexical scoping is just a binding effect. 
I'm starting to lose you, right? Okay, I'll get to the point. 
There are no new novel ideas in such code binding scopes. 
But even so, folks patent them anyway despite triviality. 

I'd guess a huge portion of software patents target scoping. 
I wouldn't be surprised to find it as more than fifty percent. 
But I would be surprised if it was less than thirty percent. 
And we're only talking about one basic software pattern. 
Others get patented in silly ways as well, all equally stupid. 

patent grub stakes @ 
Most software patents amount to grub stakes to mine gold. 
They merely announce, "I laid my claim to this plot first!" 
Being the first not only need not be true, but usually is not. 
In effect, software patents only claim an application context. 
Patents say, only I get to apply the same tools to a problem. 

Laymen believe that patents are about describing solutions. 
This is not true in software patents. They claim problems. 
Solutions nearly always involve using the same code tools. 
Given the same problem, good coders have similar strategies. 
The same patterns of binding and optimization always occur. 

The lay public imagines patents inform other practitioners. 
They do not inform. Developers rarely read any patents. 
This is for two reasons. First, the solutions are obvious. 
Reading makes you groan in despair at stupid examiners. 
Second, not reading patents is partial protection from them. 

It's easier to defend against patents if you've ignored them. 
So the standard practice involves forbidding reading patents. 
The patent system is so broken, we can only fight passively. 
But the main overt social benefit of patents does not exist. 
The purpose of capturing ideas for posterity is not satisfied. 

The only main purpose is gratifying software patent holders. 
Folks argue this gives incentive to come up with new ideas. 
This argument makes at least two unwarranted assumptions. 
First it assumes folks will not pursue the new ideas anyway. 
This is so stupid and absurd it's not even with discussing. 

Second, it assumes only new patented ideas are rewarded. 
Not so. Most patents are old ideas, and are richly rewarded. 
So applicants are motivated to claim their stakes everywhere. 
Old ideas are plentiful and cheaper. So guess what happens? 
In practice, software patents have one main emergent effect. 

Larger companies with resources stifle smaller companies. 
The patent system makes a gradient favoring bigger players. 
So the patent system actively interferes with any innovation. 
A patent typically gives a company sole rights to problems. 
One often cannot avoid using described patent solutions. 

This is because one simply must use standard coding tools. 
There's no way you can avoid binding to solve problems. 
So if the patent claims that as novel (uh, right) you're stuck. 
Unfortunately, folks are deluded by 19th century analogies. 
You could see the physical devices back in those days, right? 

Note variety of shapes and combinations in physical devices. 
The sheer number of physical design options is enormous. 
The chance an identical design can be hit by accident is small. 
In software, the chances for equivalent designs is very high. 
The sheer number of software design options is miniscule. 

But somehow patent applicants hornswoggle the examiners. 
Examiners should only be grandmaster software engineers. 
Would you let children write and conduct legal bar exams? 
But that's beside the point. Better examiners won't be a help. 
The truth is that there's not enough new stuff worth patents. 

Anything over 100 software patents a year is way too much. 
It's difficult to convey the extreme lack of software novelty. 
The enormous complexity of application details hides all this. 
The complexity in a patent is usually the same complexity. 
It's all the same stuff software practitioners learn to grasp. 

Large companies are running a public scam on competitors. 
And the US patent system obliges them as enforcement arm. 
At the same time, this also dupes consumers over innovation. 
Patent examiners are giving all A's to D student delinquents. 
Stifling the industry is bizarrely given high creative marks.
Received on Sunday, 30 September 2001 19:08:14 GMT

This archive was generated by hypermail 2.2.0+W3C-0.50 : Tuesday, 27 April 2010 00:13:39 GMT