Patent Trolls or why software patents should be abolished!
The patent system was originally designed to provide exclusive rights for invented ideas to inventors. But, there used to be a catch, the idea must lead to a real world tangible device. The patent system was also conceived long before computers existed. So, at the time when the patent system was conceived, it was designed as a way for inventors to retain exclusive control over their ideas for tangible devices without other people stealing or profiting from those ideas.
The patent system is enforced by the legal system. It is sanctioned by governments (specifically in the US, by the US Patent Office – USPTO and the legislative system) to protect said individuals’ patents from use by others who serve to profit from those previously ‘patented’ ideas. So, enforcing a patent involves suing an alleged infringer and then having a court of law rule whether the alleged infringer has, in fact, infringed. It is, then, the burden of proof of the patent holder to prove infringement. And, of course, it ties up the legal system to resolve this dispute.
Tangible vs Intangible Devices
The patent system was conceived at a time when the ultimate outcome of a patent idea was to produce a tangible physical good. That is, something that ultimately exists in the real world like a pen, a toaster, a drill, a telephone or a light bulb. The patented idea itself is not tangible, but the idea described within the patent should ultimately produce a tangible real world item if actually built. This is why ideas that lead to intangible things were never allowed to be patented and are only allowed to be copyrighted or trademarked.
Fast forward to when the first computers came into existence (30s-60s). Then later, the 70s when the US Patent Office began granting software patents en masse (although, the first software patent was apparently granted in 1966). Software, unfortunately, is not a tangible thing and, for the most part, is simply a set of ideas expressed through a ‘programming language’ with finite constructs. Modern programming languages, specifically, are designed to have limited constructs to produce a structured code. That is, an application that follows a specific set of pre-built rules to basically take data in and present data out (in specific unique ways). Ultimately, that’s what a program does, take data in, process it and spit data out in a new way.
Software Design Limits
Because modern programming languages have limited constructs from which to build an application and which are further constrained by such limits as application programming interface (API) frameworks, operating system function calls, hardware limitations and other such constraints, writing an application becomes an exercise in compromise. That is, you must compromise programming flexibility for the ease and speed of using someone else’s API framework. Of course, you can write anything you want from scratch if you really want, but most people choose to use pre-existing frameworks to speed the development process. Using external frameworks also reduce time to completion of a project. At the same time, including third party API systems is not without its share of coding and legal issues. Programmatically speaking, using a third party API opens up your code to security problems and puts implicit trust into that API that it’s ‘doing the right thing’. Clearly, the functionality derived from the external framework may outweigh the security dangers present within the framework. From a legal perspective, you also don’t know what legal traps your application may fall into as a result of using someone else’s API framework. If they used code within the framework that is legally questionable, that will also bring your application into question because you used that framework inside your app (unless, of course, it’s using a SOAP/REST internet framework).
With all that said, embedding frameworks in your app severely constricts your ability to control what your program is doing. Worse, though, if you are using a high level programming language like C, C++, Objective C, C# or any other high level language, you are limited by that programming language’s built-in construct. So, even if you choose to code everything from scratch, it’s very likely you could write code substantially similar to something that someone else has already written. Because high level languages have limited constructs, there are only so many ways to build an application that, for example, extracts data from a database. So, you have to follow the same conventions as everyone else to accomplish this same task.
Software Patents are bad
Because of these limited high level language constructs, there is a high probability that someone writing an application will write code that has already been written hundreds of times before. And note, that’s not an accident. That happens because do()while, for() and while() loops as well as if conditionals area always used in the same way. Worse, you can’t deviate from these language constructs because they are always the same in pretty much any language. If these constructs didn’t exist, you couldn’t easily make decisions within your code (ie, if X is greater than 3, do this, else do that).
Why are software patents bad? Simply, because languages are written with such limited programming concepts, the probability to reinvent something that has already been invented is far too high. Unlike devising a real world idea where the probability someone could come up with that same exact idea is likely near zero, writing software using language constructs the probability is far higher than 70% that someone could design the same (or substantially similar) code, idea or construct. And. that high probability is strictly because of the limits and constructs imposed by the high level language.
Yet, the USPTO has decided to allow and grant software patents knowing the probabilities of creating substantially similar ideas within the software world is that high. Yes, probabilities should play a part in whether or not to grant patents.
Probability in idea creation is (and should always be considered) how likely someone is to create something substantially similar to someone else. Probability should always be relevant in granting patents. Patents need to be unique and individual. That is, a patent should be granted based on something that multiple people could not devise, guess, build or otherwise conceive accidentally. Because real world tangible items are constrained only by the elements here on Earth, this effectively makes inventions using Earth elements pretty much infinite (at least for all intents and purposes). Because software code uses a much smaller number of constructs that limit and constrain programming efforts, that smaller set increases the chances and the probabilities that someone can create something similar. In fact, it increases probabilities by orders of magnitudes. I’m sure an expert on statistics and probabilities could even come up with real world probability numbers between element based inventions and software code based inventions. Suffice it to say, even without this analysis, it’s quite clear that it’s far too easy for someone to devise something substantially similar in software without even really trying.
Software patents are bad, revisited
Basically, it’s far too easy for someone to devise something someone else has already conceived using software. On top of this, the USPTO has seen fit to grant software patents that are way too obvious anyway. That is, they’ve granted patents to software ideas that are similarly as common place as cotton, strawberries, a nail and yarn. Worse, because of these completely obvious patents, patent trolls (people who do nothing but patent without the intent of producing anything) game the system and produce completely obvious patents. This action has created a land mine situation for the software industry. This is especially bad because it’s virtually impossible to search for existing patents before writing software.
So, as a software developer, you never know when you might step on one of these land mines and get a ‘cease and desist’ notification from a patent troll. That is, someone who has patented some tiny little thing that’s completely obvious, yet your application takes advantage of that thing somewhere because you just happened upon one of the easy to build constructs in a language. Yet, patents should only be granted based on an idea that someone cannot easily create by sheer accident. Yet, here we are.
Ideas now patented
Worse, software is not and has never been tangible. That is, software doesn’t and cannot exist in the real world. Yes, software exists on real world devices, but that software itself is just a series of bits in a storage device. It is not real and will never be real or ever see the light of day. That is, software is just an idea. An idea with a structured format. It is not real and will never have a real tangible physical shape, like a toaster. We will never be able to have tactile interaction with software. Hardware, yes, is tactile. Software, no. The software’s running code itself cannot stimulate any of our five senses: not sight, hearing, touch, smell and taste.. Someone might argue, well software does produce visual and audible interaction. Yes, the output of the software produces these interactions. That is, the software processes the input data and produces output data. The input and output data has sight and sound interaction. You still aren’t seeing or hearing the software code doing the processing. That’s under the hood and cannot be experienced by our five senses. For this reason, software is strictly an idea, a construct. It is not a tangible good.
Patents are a form of personal law
That is, the owner of the patent now has a legal ‘law’ that they need to personally enforce. That is, that patent number gives them the right to take anyone to court to enforce their ‘law’ err.. patent. No entity in government should be allowed to grant personal law. Especially not for intangible things. I can understand granting patents on tangible items (a specialty hair clip, a curling iron, a new type of pen, etc). That makes sense and it’s easy to see infringement as you can see and touch the fake. It takes effort, time and money to produce such a tangible item. Software patents require nothing. Just an application to the USPTO, a payment and then wait for it to be granted. After the patent has been granted, take people to court, win and wait for royalties. This is wrong.
All software patents should be immediately abolished and invalidated
- Software patents only serve corporations in money making ventures. Yet, software patents really serve to bog down the legal system with unnecessary actions.
- Software patents stifle innovation due to ‘land mines’. Many would-be developers steer clear of writing any code for fear of the legal traps.
- Software patents are granted based on probabilities far too high that someone will produce something similar based on limited high level language constructs
- Because software language constructs are, by comparison, much smaller in number when compared to Earth elements (when inventing real world ideas), probabilities say it’s too easy to recreate something substantially similar to someone else in software.
- Software is intangible and cannot expose itself as anything tangible (which goes against the original idea of patents in the first place)
- Software patents will reach critical mass. Eventually, the only people left writing code will be large corporations who can afford to defend against legal traps.
- Software patents are now being granted without regards to obviousness.
As a result, all software patents, past and present, should be immediately invalidated. If we continue this path of software patents, a critical mass will eventually exist such that writing software will become such a legal landmine that developers will simply stop developing. I believe we’ve already seen the beginnings of this. Eventually, the only people left who can afford to develop software will be large corporations with deep pockets. Effectively, software patents will stifle innovation to the point that small developers will no longer be able to legally defend against the Patent Trolls and large corporations seeking to make money off ‘licensing’. The patent system needs to go back to a time when the only patents granted were patents describing tangible physical goods. Patents that do not describe tangible physical goods should be considered ideas and dumped under copyright law only.