Code is not a machine
Summary: Input from one of our Australian readers motivates writing a simple essay on why software patents are unnecessary
Our reader from Australia wrote to say: "Remember my attempt in Feb to get Software Patents abolished? Well, it's at the final stage. I need some supporting material, that is less than 300 words. Is that something you can help me with? If you can write about why software patents should be abolished, that would be great."
There was a similar request in Groklaw some days ago, as Reddit invited people to submit text for reading by a movie celebrity (with the same length limitation) and Pamela Jones suggested writing about software patents.
Essays about why software patents are bad would not be unique. They have been written for years in many sites (the facts have hardly changed for decades) and they use technical, economic and philosophical arguments (or a combination of these). I will do this today in Techrights using the angle of a developer, not a customer -- a person to whom patents in general are of no value. It is written in terms that even politicians (usually lawyers) can grasp.
Software Developers Need No Patents
When a developer writes software, he or she uses a computer (or even a piece of paper) to outline instructions to be run in sequence, a bit like solving an equation. These instructions are reducible to pure mathematics, but computers nowadays offer high-level abstractions, which make development more rapid and render instructions readable by a compiler rather than a computer processor. This technology is many decades old.
A lot of programs these days are built by providing a user-facing layer, a GUI, which reuses off-the-shelf graphical toolkits, as well as a back-end logical unit, typically accessible through callback functions. This is where the clever bits of a program usually exist. There is rarely something very innovative or novel in the GUI, which is less science-based in nature.
Assuming that something unprecedented (i.e. no prior art) can be found in callback functions, it is covered by default by copyright law, enabling the programmer to tackle plagiarism. When the program is compiled, plagiarism is impeded anyway. The code turns into binary data. This means that copying of programs is hard and where it occurs there are already laws in place to tackle that, at no cost to the developer.
Patents are an unnecessary complication at two levels; first, the developer needs to waste time filing a verbal description of the program's instructions (distracting from further development of potentially innovative programs) and then pay someone for the infeasible task of identifying prior art; secondly, and quite inadvertently, by introducing this level of protectionism into the system, we render any programmer "potentially infringing", which further impedes development and contributes to uncertainty. Both aspects reduce innovation and productivity. In an age when writing programs is possible by everyone, this creates no incentive to write more programs; au contraire.
Programmers need copyrights, not patents. That is their consensus. For anyone other than programmers to weigh in on this subject would be rather inappropriate and usually opportunistic.
⬆
