Archives


Atom Feed

Associated Blogs
 
Edge City
 
Numbering Peano
 
Praxis101
 
Prof. von Clueless in the Blunder Dome

Recent Items
 
Merchants of Attention
 
Symbols of Trust
 
The Passing of Salvatore Lombino: Farewell, 87th Precinct
 
Finding an Audience: First, Trust Them
 
Making Wiki's Conversational: Get the RSS Right
 
The power of student-teacher interaction?
 
Happy Father's Day, Steve Jobs
 
Open Minds, Yes Let's Have Some Open Minds -- and Facts, Open Facts, that would be really good.
 
Sponsored Links: Where's the Barf Bag, I'm Feeling Queezy
 
The Heavy Lifting toward Open Formats in Microsoft Office

Consigning Software Patents to the Turing Tar Pit

ACM News Service: Software Patents Don’t Compute.  There’s an interesting problem in the separation of patentable machines and unpatentable algorithms.  The problem is that U.S. Federal courts have found uninteresting machines tied to inventive abstractions as wholly patentable (assuming that the other tests that an invention must pass to receive a patent are satisfied, of course).  Although the argument that Ben Klemens put forward might be taken as a basis for eliminating software patents, I am not sure how judges (or, of greater import here, legislators) will take to it.  Still, it would be interesting to see what the proponents and significant beneficiaries of software patents would marshal in defense.

The heart of Ben Klemens’ July 2005 IEEE Spectrum article is the tag line “No clear boundary between math and software exists.”  Mathematics is viewed as tied to scientific principles, and scientific principles are not patentable.  This process has been blurred in the case of algorithms because when they are embodied in machines (such as video display cards), the resulting device can constitute an invention.  The problem, according to Klemens, is that there is then no longer a meaningful barrier to patenting of abstract algorithms, something that mathematicians understand but jurists and legislators are not compelled to cotton to.

The technical heart of the argument against this patenting-of-mathematics slippery slope is to rule that computing machines (that is, machines that perform equivalently to Turing machines) are devices, but their programs are merely states of such devices and should not be patentable.  This approach raises for me the sticky problem of there always being some algorithm that such a machine embodies:  is the algorithm therefore patented, or is the machine not patentable?  Klemens suggests this is not a problem, and chooses the perfect example, the Java Virtual Machine.  Although a device that implements the JVM on silicon might be patentable (depending on the usual tests), the abstract algorithm as such should not be.  And a software JVM implementation (technically, a simulation having an equivalent abstract algorithm as the silicon JVM) would not be patentable subject matter either way.

This reminds me of the distinction that was made, some of the time, by Sperry Univac in claiming royalties for the LZW algorithm when embedded in devices but not when merely implemented in software (e.g., in creating and rendering Compuserve GIF format).  Note that Klemens argument would have failed to protect the RSA algorithms from their software-only embodiments too, although special hardware for rapid coding and decoding could qualify as devices and might be recognized as patentable inventions.

There are two facets of this argument that fascinate me.  First, it would be valuable if the test is actually easy to apply by patent examiners and to resolve in court when a dispute makes it necessary.  Actually, it might not require any test, if it is simply understood that any embodiment of any invention entirely in software is not subject to the claims of the patent.

Secondly, this relieves a serious problem with software-as-inventions.  The distribution mechanism of software, involving simple and widespread copying rather than any distinctive manufacturing process, along with the ability to easily make derivatives, imposes an awful burden on software developers and anyone who adopts the software for their use. And if you see an interesting idea in source  code, especially for open-source distributions but also in books and other sources, of course you’ll apply it on your own too. For developers to know when they have or have not intruded on territory protected by a patent claim is completely unreasonable to expect.  The fact that programmers adapting software created (and distributed) by others can be entirely ignorant of applicable patent claims (as the original authors may have been as well) is now leaving most software vulnerable to patent infringement claims, once the infringement becomes suspected by the patent holder. 

It doesn’t help that the patent can be issued some time after the software was written.  For example, it is possible to apply the RSA algorithms from the seminal papers in which the mathematics and fundamental methodology are laid out, without any knowledge that a patent, since expired, was issued.  It is generally not known which great published ideas have been accompanied by or followed by successful patent applications.  Those in the know about patents are likely to be on the watch for notices of patents that may impact their development of software, but this is not remotely close to the ordinary behavior of software developers and their organizations.

It is very difficult, as a software developer, on observing a great technique or algorithm or other principle, to resist applying it.  The cool stuff calls out for application, and it would be weird to continue to use an older, inefficient or cumbersome approach now that a better one has been seen.  The problem is that this is not like copyright, where the idea is not protected.  Patents protect inventive ideas, but disclosure of the idea may be everywhere, without any warning of the (future) existence of a patent claim.

Around 1965 I was asked to review an idea that was submitted to Sperry Univac.  It was for a very clever way to accomplish the critical-path method analysis on machines with memory too small to hold all of the activity data at once and having no external random-access storage or tape drives.  The idea was submitted under non-disclosure solely for our evaluation and possible licensing/purchase.  I can’t recall what I recommended, nor what came of it.  But I can’t forget the idea, which is one of those slap-your-forehead simple things that qualifies as novelty and non-obviousness in my book.  Fortunately, I have never been in a situation where I’d be tempted to use it.  But that’s the point.  Some of the greatest inventions are non-obvious until you’re shown them (the safety pin, the little side-mounted toggle-switch that was used to detect that the output stacker of a card-reader was full, etc.), and then they are brilliantly obvious and have great sticking power.   There have been a lot of those in the history of computing, and a great many of them happened before software patents were allowed, thank heavens.  There were patents on pushdown stacks in hardware, but not software, and the idea of “inverted indexing” was definitely novel until we “got it,” and now its the ordinary way of handling structures in computers.  I don’t know what Pascal and C Language would have been like if there’d been a software patent on base-pointer plus offset access to structured data in memory.  And, of course, the subroutine calling and return technique—and the idea of reusing code that way—was an invention.  As were garbage collection (several flavors) and memory-allocation algorithms. There’s a very long list.  I claim that all of the software-only patenting that is happening now is free-riding on all of those unpatented inventions of software’s colorful history, and it’s a bloody shame.

Klemens begins his account by referring to the Amazon.com “one-click” patent.  Unfortunately, that doesn’t seem to be a software patent, even though one-click services are implemented by computer systems.  So ending the patentability of software does not necessarily end the reign of business-process patents.  People who want to replicate a clever feature of a known (or maybe never seen before) eCommerce innovation will still have to be careful.

I should also point out that Turing machines don’t work on interactive principles, and the combination of software in a particular kind of interaction (such as a business process) might fail to have patentable software, but that doesn’t mean there isn’t a patentable process and we’ll have to see what happens to sort all that out.

Maybe the key take-away here is this.  If you have a business model that depends on the patentability of software for survival, perhaps that is a business model for which the patent system really doesn’t owe you a living.

{tags: HonorTagAdvocate software patents innovation}