The Difficulty with Software Patents

There’s been a huge to-do in courts for the past several years, as numerous holders of software patents duke it out.

And software patents are, to say the least, problematic.

To really understand why, you need to understand a bit about why our patent system was originally invented. Back in the day, the citizenry was concerned that inventors would create crazy-useful inventions, but not disclose how they worked. If said inventor got hit by a bus runaway horse carriage, the country would lose out on their genius, and never be able to reproduce their invention. On the other hand, you couldn’t just demand that the inner secrets of an invention be publicly disclosed, because then everyone would rip it off. So the patent was invented (patents go back further than the US of course, but our story parallels others). The idea is, you tell the world how your doohicky works, and the government protects your right to exclusively produce it for a period of time. That way nobody can rip you off, but if you bite the big one, we still know how it works.

This entire system was predicated on a couple of things, primarily that idea that we don’t know how your patent works. We need you to tell us.

Fast-forward a couple hundred years, and we’re in a huge quagmire. At some point, the law stopped focusing patents exclusively on mechanical inventions, and starting allowing us to patent business processes. Now, I understand the reasoning: processes can take a crapload of research and development to perfect, and the inventors obviously want to protect that investment. To encourage American innovation, we agreed to protect those processes under patent law. Observing a business process makes it easy to duplicate, but the patent protects you. This was a major departure for patent law, because for the first time we weren’t worried about losing the invention. Once you’ve seen a process, you can duplicate it – unlike many mechanical inventions, which are far more intricate. So our idea of patent law changed to protecting the obvious, so that people would be encouraged to invent new things which, once invented, were obvious.

Software, as you may know, can be copyrighted, but that only protects the actual, exact source code – it doesn’t protect what the source code accomplishes, which is far more interesting. So we started allowing what the code does to be patented as a business process.

This has now become silly. Apple has a patent on their “slide to unlock” gesture. Yes, nobody had done it before. Yes, it probably took a lot of time to figure out, make elegant, and so on. Yes, we want to encourage that kind of innovation. It’s very easy to copy once you see it, so (in theory) to encourage that innovation, we have to protect it. I mean, once you’ve seen “slide to unlock,” you can implement it on your own knockoff phone in about ten seconds, negating (the argument goes) Apple’s competitive edge that they spend time and money developing.

But from a common sense perspective, it’s just silly. And the law already protects things like “trade dress,” which means you can’t make something that looks so much like a competitor’s product that consumers might be fooled into thinking you were the competitor. Trade dress lawsuits get incredibly sticky (Apple and Microsoft can attest to that, after spending a decade arguing about Mac’s and Windows’ visual similarities). But that doesn’t change the fact that software patents nearly always strike the layperson as ridiculous.

And you know what? Common sense makes sense. Software patents are ridiculous, no matter how well-intentioned, and their ridiculousness is what causes us to have courts full of nitpicky patent lawsuits all the time. Hardly a good use of our court system, really.

The ultimate problem is that we tried to take a concern – protecting software innovation – and jam it into a centuries-old “solution” that didn’t actually fit the concern. And now we’re screwed by it. We should have invented a new body of law, and we still should revisit that idea. Call it “feature protection,” and require it to be litigated by a simple jury decision. “Guys, look at these two features. If you think they’re remarkably similar, then whoever came first wins.” And that protection lasts only five years, because in software you’d better be innovating faster than that, anyway.

Never happen, of course. But it doesn’t stop the silliness of our current setup.