Microsoft recently claimed that open source code (in particular the Linux kernel) violates 235 of Microsoft’s patents. It’s not clear they actually intend to sue anyone for infringement, it may instead be some kind of bizarre publicity ploy. But there’s a great quote from Microsoft’s licensing chief, Horacio Gutierrez:

This is not a case of some accidental, unknowing infringement… There is an overwhelming number of patents being infringed.”

Get the implication? There are so many patents being infringed here, those open source developers couldn’t possibly have done it by accident! It’s just too many!

Which is the opposite of the truth. It’s far more likely that, if there are any infringements, they’re all accidental. Independent reinvention is the norm in software, especially given that the Patent Office frequently grants software patents for techniques which are either obvious or for which there is prior art available. (The Patent Office doesn’t do this intentionally, it’s just that it’s hard for a patent examiner to be skilled enough in all the varieties of programming to know what’s obvious in a given subfield, and also hard to find the right examples of prior art when there’s such an ocean of code out there to wade through.)

Assuming Gutierrez meant his statement sincerely, it reveals a lack of knowledge hard to believe in a high executive at a software company. Can he really be ignorant of the most basic realities of software development? I mean, it’s not like programmers sit around reading patents all day; in fact most programmers go out of their way to avoid looking at patents. Thus, infringements are almost always accidental. At the very least, a tally of 235 (alleged) violations would in no way imply that a single one of those violations were deliberate.

In fact, there may be far fewer violations than that, possibly even zero. For one thing, Microsoft has so far refused to name the specific patents or the infringing code, so the whole charge is FUD for now. For another, even if they do name a specific patent, and it matches (“reads on”, in patent jargon) the program code in question, the patent may still be re-examined in response to a challenge, or invalidated in court.

Anyway, my point isn’t about the degree of danger to free software (though fortunately that appears to be small). It’s about the fact that a Microsoft executive would assert, apparently with a straight face, that some of the infringements must be intentional simply because 235 patents are alleged to be violated. That is laughable.

(By the way, I found Gutierrez’s quote here, but you can probably find it many other places too, just do search://microsoft linux patent gutierrez/.)

I’ve written elsewhere about how software patents harm software development. This article is about how there’s very little corresponding benefit to justify that harm.

Ostensibly, our patent system is supposed to stimulate innovation and progress, by granting those who come up with a genuinely new and useful invention a temporary monopoly on that invention, as long as the inventor describes it by publishing a description in the government’s public registry of patents. (Already we’re on shaky ground, because this isn’t actually how the modern patent system came to be, but let’s leave aside the history for a moment — interesting and unexpected as it may be — and concentrate just on the present-day realities of software patents.)

The first sign that there’s something wrong with software patents is that (as any patent attorney working in software can tell you) they are overwhelmingly collected as a defense against incoming patent infringment suits. Most companies don’t intend to collect royalties on their software patents, they just keep the patents around in case some other company decides to bring a patent infringement suit, at which point the target of the suit goes digging in their patent portfolio and comes out with some patents that the plaintiff is probably violating — at which point the two sides sit down, work out a cross-licensing deal whereby each gets the rights to the others’ patents, and neither has to worry about it again. It’s a classic arms race situation: in a world where everyone is armed to the teeth, everyone must be armed to the teeth. Except, of course, that small players can’t afford the overhead of filing patents and keeping patent attorneys on staff, and are therefore vulnerable to infringement suits that they cannot defend against, regardless of the suits’ merits.

Another sign the system is broken is that filing software patents is almost always a byproduct of normal software development work, rather than the intended goal of research projects. In other words, programmers are solving problems in new and useful ways just in the normal course of their work. Typically, their employers instruct them to say if they’ve done anything that might be patentable, so the company can file for the patent. (I’ve received such instructions myself, as have most programmers I know.) So the innovation precedes the intent to patent, and would have happened anyway without the patent, since it was needed to do whatever the programmer was trying to do in the first place.

“Ah”, some would say, “but that’s missing the point. The patent still does society some good, because it forces the programmers to publicly describe their solution, so we can all benefit from it. Without the requirement to publish, the secret trick would remain hidden in their private source code, where others cannot learn from it.”

That argument would make sense if programmers ever used the patent office as a research aid, but in fact, they don’t. I’ve never heard of a programmer turning to filed patents to get help solving a technical problem. (I once made this assertion in the company of another programmer, who said he had heard of someone doing this, but when pressed, he thought about it more and realized the person was actually just examining patents for competitive analysis: he was trying to get news on what his competition was up to, not looking for information on solving technical problems.)

Even if filed patents did contain interesting technical information, which for the most part they don’t, they’d still be a pretty cumbersome way to find out that information, because patents are written in a special language designed for making claims that are defendable in court, not for communicating technical details clearly. Companies naturally want their claims to be as broad as possible, while still being defensible. But these goals are orthogonal to, and often opposed to, the simplification and reduction that are the heart of technical clarity. Learning a programming technique by reading a patent would be like learning to cook by reading municipal health inspection regulations: boring, painful, and in all likelihood unsuccessful.

But as I said, programmers rarely read software patents to learn from them anyway. The vast majority of the time, when they’re reading software patents, they’re doing it to determine whether they or someone else might be infringing. Don’t take my word for it — go ask a programmer about their actual experiences with software patents. You’ll find they’re either filing patents on work they were doing anyway, or spending time analyzing patents (solely to determine infringement, not to learn something new in their art), time they would almost certainly rather spend doing just about anything else.

Are you ready for the final irony?

Most programmers are instructed to consciously avoid looking at patents at all. This is because when you knowingly infringe on a patent, you are liable for triple damages as compared to accidental infringement. I don’t know what legislators came up with that doctrine, but what on earth were they thinking? We now have the paradox of a system whose supposed purpose is to spread knowledge, yet which those capable of using take pains to avoid, for fear of increased legal liability.

To summarize:

  • Software patents are mainly used as a defense against other software patents — a zero-sum arms race.
  • Filing software patents is generally a byproduct of work the programmers would do anyway, that is, the acquisition of the patent is not a motivating factor in the development of the new technique, it is merely a result.
  • Programmers do not use the patent office as a research tool, even though that was supposed to be part of the point.
  • Patents are written in a special style which is antagonistic to communicating software techniques clearly anyway.
  • Due to the triple-damages rule, programmers must consciously avoid looking at other software patents whenever possible.

I’m mostly leaving aside the issue of patent duration here. While it’s true that the length of time a software patent lasts is ridiculous (20 years from the earliest claimed filing date, in the U.S., for all patents, not just software), the term length is not in itself a philosophical objection. Although the harm of software patents would be greatly reduced if the term length were only, say, 3 years instead of 20, that would still do nothing to address the other concerns. No matter what the term length, we just don’t need software patents. If the purpose of patents is to stimulate innovation (a debatable goal in the first place), they are having the opposite effect in software: programmers are forced to avoid using the best tool for the job, for fear of infringing on a patent, and are forced to avoid building on each others’ work, for fear of triple damages. And even granting that innovation were a goal worth sacrificing freedom for, there would be no need to artificially stimulate innovation in software, because tremendous innovation already happens in the natural course of things.

How often do you find yourself writing an email in which you tell someone to do an Internet search? If you do it often enough, you’re probably familiar with the following cycle, the one that starts with you saying:

Just Google for “there will also be corn served”.

Then you realize it’s unclear whether or not you meant a phrase search — that is, whether the double quotes are part of the search string, or just there to separate the search words from the rest of your email. So you add:

Make sure to include the double quotes!

Then you remember that your friend works at Yahoo and always gets annoyed when people equate searching on the Internet with Google, as though there were no other search engines in the world. With a sigh, you go back and edit the text to be service-neutral, turning it into one sentence while you’re at it:

Type “there will also be corn served” into your favorite search engine, and make sure to include the double quotes.

Gosh, what a lot of work just to tell someone to search for a six-word phrase. And the recipient still has to manually cut and paste the phrase into a search engine, aiming the mouse carefully so as to catch the double quotes. There’s got to be an easier way!

Introducing search://

Most people, if they saw the following in an email, would know what to do:

search://"there will also be corn served"/

It means “Go to your preferred Internet search engine and enter the string of text between the second and third forward slash, exactly as written here.” It works for non-phrase searches too:

search://thumbnail image dimensions standard/

And for combinations of word- and phrase-searches

search://tommy's tequila "san francisco"/

Note that it’s not actually a URI, so it need not obey the URI syntax rules (which involve, among other things, special sequences to represent spaces and double quotes). You can just write the search string exactly as it would be entered in the search engine’s text box. The search:// syntax takes advantage of two convenient facts:

  • All the major search engines support the same basic search string syntax, e.g., using double quotes for phrase searches.
  • “/” isn’t normally used in search strings anyway (the search engines don’t track forward slashes, although they do remember that there’s a word boundary there), so we’re free to use “/” for the delimiters around the search string.

This syntax is both human-readable and machine-parseable. The former property is crucial, because you want people to know what you’re telling them to search for before they do the search. The latter property is also crucial, because it means software can automatically recognize a search description and Do The Right Thing when you click on it (namely, take you to whatever search engine you’ve configured as your preference, enter the search string into the input box, and submit the form). “Software” means web browsers, of course, but also mailreaders and all other text-reading environments.

I’ve already starting using this syntax in email messages, and in one case even on a poster. So far everyone seems to understand it right away; that is, no one has asked me what it means, and several people seem to have done the suggested searches. Once this syntax is widespread, I expect software support to emerge organically, as happened with email addresses, with http:// syntax, and many others. When something useful is machine-parseable, software is usually quickly adjusted to recognize it.

Confidential to J. Random Hacker:

You’re probably thinking “But this isn’t even compatible with URI generic syntax as defined in RFC 3986.” That is correct. It’s not a URI. In addition to the tolerance of double quotes (which can never appear unencoded in a URI), the spaces need to remain unencoded anyway, because the string has to be comprehensible to humans. It may seem counterintuitive to use a syntax so similar to URI syntax, but there are good reasons for doing so. Nothing else would have the immediate comprehensibility of search://, because many people are now accustomed to the general format foo://bar/, and will intuitively grok what this new syntax means. I spent a fair amount of time trying come up with something better, and couldn’t. If you can, let me know… But it’s probably already too late: I’ve set the meme loose, and no one can control it now. Mu-wa-ha-ha-ha-haaaaah.

Brief background for those who haven’t been following this particular bit of theater: The radio commentator Don Imus, while watching a college women’s basketball game, called one of the teams “nappy-headed hos”. This was going too far, even for a shock jock like Imus. Advertisers started pulling their ads, and eventually Imus’s employer cancelled his show entirely, despite his going around and apologizing to everyone in sight.

Now, I’m totally in favor of Don Imus getting fired. In fact, I’m in favor of him not having been hired in the first place — who needs talk shows like that anyway?

But I was bemused, and disturbed, to hear Imus on NPR quoted saying that while he regretted his comments, he’s not a racist, and if he’d really been guilty of racist hate speech, he ought to be thrown in jail. (I wish I had the exact quote here, but I was just listening to the radio in the kitchen and not taking notes. I tried to find a transcript on the Internet, but couldn’t, even at npr.org.)

It’s obvious what Imus was trying to convey. “I’m not one of the bad guys! I’m a good guy! I’m not really a racist! It was all for show! Racists are bad people who spew hateful speech and deserve jail; I’m not one of them.”

Still, how can someone whose entire career has been utterly dependent on freedom of speech — by which I mean, freedom from government-enforced penalties for speech — turn around and stab the principle in the back like that? Sure, people lose their jobs for speech all the time, and that’s fine. Freedom of speech doesn’t mean that there’s no such thing as bad, harmful speech: there certainly is such a thing, and there are times when it should cost you your job. (Universities are a special case, and the tenure system is in part a formal protection for controversial speech by academics.) But jail? Or other state-mandated penalties? Those should be completely off the table, because otherwise people wouldn’t feel free to disagree with the government.

Thanks for nothing, Don Imus. If you want to make it up to the rest of us, send a big check to the ACLU. They’ll still defend your right to free speech, even if you won’t.

The debate about lesbian/gay marriage has reached a stage of pure symbolism: many people are now comfortable with the idea of “civil union” laws, which grant all the privileges of marriage without calling it “marriage”. Some state governments have even passed such laws, and more will undoubtedly follow.

Understandably, not everyone is happy with this. It’s clearly a deliberate slap in the face for people who want to marry partners of the same sex — a slap that stings all the more because it is legitimized by democratically-elected legislatures. We’ll give you everything you want, except the right to call it marriage, because that’s sacred, you see. You will always be a second-class citizen, because we’ve passed a law that contains a clause whose only purpose is to make you feel second-class.

There’s a solution, though.

Let’s treat marriage as though it’s really sacred. Let’s get the government out of the marriage business entirely, and do only civil unions, leaving marriage for religious institutions. Effectively, that’s what we already do anyway. The secular, state-supported side of marriage is represented by the marriage license; the government doesn’t care about the religious details (if any) of the ceremony, even though that’s the part everyone thinks of as the “real” wedding.

So we’d all get civil unions, and those who want to also be married (and can find a priest willing to perform what is essentially a religious ceremony) are free to do so. If a lesbian couple wants to be married, that’s between them and their church. There’s no reason for the government to get involved in the matter, and no reason for a secular democracy to try to define the spiritual meaning of marriage, as opposed to its legal meaning.

The book Beautiful Code: Leading Programmers Explain How They Think is
about to be released, says Greg Wilson, one of its editors (the other is Andy Oram, who was my editor for Producing Open Source Software). I wrote a chapter for this new book: Subversion’s Delta Editor: Interface as Ontology, about the svn_delta_editor_t interface in Subversion. When the book is released, I’ll put the chapter online under a free license (a lot of the other authors are planning to do that too, I believe). All profits from the book go to Amnesty International.

The letter below was sent by my friend Jim Blandy to the governor of Oregon, Jim’s state. In it, Jim asks what Oregon can do to avoid a disaster like the recent group deportation of immigrants in Massachusetts that resulted in children being abandoned, as described on National Public Radio and in the Boston Globe.

Before I say more, please read Jim’s letter:

From: Jim Blandy
Subject: Abandoned children
To: [a mailing list we're on]
Date: Fri, 9 Mar 2007 21:53:37 -0800

Folks, I'd never use [this mailing list] for campaigning, but I think
this goes far beyond politics, and well into the territory of national
disgrace.  I've sent the following letter to Oregon governor Ted
Kulongoski; please read the articles I've linked to, and think of
*something* you can do.  If abandoning 7-month old children doesn't
move us to more than a sophisticated sigh about how far things have
gone, we don't deserve a decent country.

---

Dear Governor Kulongoski,

NPR's March 8th Morning edition and the March 9th Boston Globe
reported on an egregious and shameful dereliction of our
responsibility to the most helpless in our country: a Massachusetts
factory was raided on March 6th, and scores of workers accused of
being in the United States illegally were flown to a Texas detention
center before state authorities could determine whether there was
anyone able to take care of their children.  According to the Globe:

 Two young children were hospitalized yesterday for dehydration after
 their nursing mothers were taken away, state officials said.
 Another 7-year-old girl called a state hot line seeking her detained
 mother.  It was unclear last night where their mothers were.

I can't express how angry and ashamed this news makes me.  Let us
assume all of the people transported to Texas were indeed in the
U.S. illegally; there is no imaginable justification for abandoning
their children in this way.  When we imprison a murderer who is a sole
caregiver, we take better care of their dependents than this.  There
is simply no legitimate law enforcement need that could justify such
negligence.

I have three questions:

- Oregon has its share of illegal immigrants.  I am firmly in favor of
 enforcing the laws that our state and national legislative bodies
 have agreed on.  What assurance can you give me that a disgrace of
 the sort occurring now in Massachusetts will not happen in Oregon?

- Who is responsible for ensuring, when a sole caregiver is found to
 be residing in Oregon illegally, that the children they care for
 will be taken care of appropriately?

- What is that responsible party's position on the Massachusetts raid?
 Do they feel it was properly conducted?  If so, would they do the
 same here?  If not, what steps have they taken to ensure this will
 not happen again?

I understand that the Department of Homeland Security conducts
immigration raids, and that the DHS is a federal department, not
controlled by the state of Oregon.  But if a debacle like this were to
occur here, Oregonians would hardly be satisfied to hear that there
was nothing to be done, and from what I have read of you, I do not
believe you would offer such an explanation.

Sincerely,
Jim Blandy

[URLs given here]

Bravo for Jim — we should all ask the questions he’s asking. What Governor Kulongoski probably won’t say in reply is that this is how our immigration system is supposed to work. The whole point is to have a large number of people around willing to labor at low wages, but unable to be involved in civic affairs. Solution: make them officially illegal, but unofficially tolerated, as long as they don’t raise too much of a fuss — and brutally deport a few now and then to make sure they stay in line.

I’ll bet African Americans recognize this pattern pretty well.

Am I too cynical? Ask yourself this question: why don’t we simply crack down on businesses that employ illegal workers? After all, if we wanted to end illegal immigration in this country, we could do it in two seconds. Illegal immigrants aren’t exactly hard to find. Just go to every restaurant, farm, landscaping company, etc, in your precinct, and start fining the employers. That would end the “problem” pretty quickly, wouldn’t it?

But no, instead we harass and hound the immigrants. We talk, incredibly, of building a seven-hundred mile fence along our border to keep them out, as though they’re not right here next to us the whole time, busing our tables, picking our fruit, cutting our lawns. This is just the American way, apparently: bully the weak, before doing anything that might annoy businesses or put upward pressure on wages.

I don’t think what happened in Massachusetts was some sort of one-time exception. Perhaps it was unusually cruel… but more likely it was just unusually publicized. Here’s another raid that made it into the press: Lockdown in Greeley, excellently reported on by Marc Cooper in The Nation.

How many times must this happen before we admit what we’re doing?

In 2005, Nat Torkington edited a series of posts called Burn In over at O’Reilly Radar. He described them as “stories about how alpha geeks got into computers in the first place“. I’m not really an alpha geek, but he ran my essay anyway. I asked Nat if he’d mind my using the same material to start my own blog (which I hadn’t yet done at that point), and he said it was fine. Here it is, slightly revised.

————————————————————–

In the early 1990’s, the Oberlin College Computer Science Department was a hotbed of free software activity. The sysadmin, Chuck Van Tilburg, encouraged the students to help maintain the department’s servers; the students responded by installing GNU programs and documentation, and tutoring newbies in how to use them. Quite a few even contributed code back to the GNU project. Now, I’d used computers before coming to Oberlin, and I thought I understood how programs worked: you started them up, they did something, and when you were done you shut them down. If you wanted different functionality, you shopped around for a different program. So I still remember the shock that went through me the first time I started up the GNU ‘info’ browser on the Oberlin CS machines. The screen gave a few basic instructions for navigating the Info hyperlinks, then below that it said: “PLEASE ADD DOCUMENTATION TO THIS TREE. See blah blah blah for instructions on how to do so.”

The system was inviting me to improve the system! No computer had ever done that before. It had never occurred to me that the system documentation was just files, no different in principle from the files I saved from my word processor when writing a paper for class. But when I saw the Info tree inviting me to make it better, I suddenly understood. Perhaps it is only one of those ex post facto artificial memories, but I recall that I formed a tentative hypothesis then that the entire system worked this way, and that if I learned the right technical details, I could Make Things Better too. Testing this hypothesis became my highest priority; perhaps it still is.

The other important thing about the Oberlin CS Lab in those days is, in retrospect, a sad commentary on the nature of progress:

College dorms were not networked then. If you wanted access to the CS servers, or even just to check your email, you had to go to the Computer Science Lab. This was a small room with twenty or so workstations, mostly 9600 baud text terminals but also a few graphics workstations. So at any hour of the day or night, you could wander into the Lab and find other CS students, working on programs, or installing some new software on the department’s servers, or just hanging out.

I realize now that we had caught a brief, golden moment in time. The Internet was up (without the World Wide Web at that time), but networking had not yet penetrated to every corner of life. Those wanting to get serious work done on a computer were forced to be in the same room with each other.

This had a tremendous effect. People shot questions across the room; people traded code; people came and looked over each others’ shoulders and offered tips on how to use the editor (usually Emacs) better; people maintained files of hilarious quotes overheard in the Lab, and wrote programs to serve up a randomly chosen quote at login time. People played games together, did their homework together, designed cool hacks together, explored the nascent Internet together.

It was a true programming community. Shortly after my epiphanous encounter with the Info browser, a Lab regular named Jim Blandy (now a GNU toolchain hacker at CodeSourcery) pointed me at Richard Stallman’s GNU Manifesto, and I remember reading it and thinking “Yes, I understand, this makes total sense.” At the time I didn’t know why, but now I think I do: the GNU Manifesto made sense because I was already living in a sharing community. And since my first exposure to computer programming took place in that environment, I simply assumed that kind of community was the norm.

After college my first jobs were in free software, and (except for a brief interlude) that’s what I’ve been doing ever since. I have an idea that, at least in terms of information if not physical goods, the whole world could be like the Oberlin CS Lab was: a sharing community where people assume that improving the system is within anyone’s reach.

That’s probably a lot to hope for… but why not see how close we can get?