Patent Eligibility of Software

Posted Saturday, December 31, 2011.

Software patents have had much written about them recently. Inventors wonder whether software is patent-eligible, and if so, whether it even should be patent-eligible.

At one time in my career I was a software engineer. Thinking back on my experience writing code has been helpful as I consider patent eligibility of software.

I once worked for a company that manufactured high-speed printing systems. The company combined printing presses, on which rolls of paper passed by a printer mounted to the press at up to 150 feet per minute. As the paper went past the printer, the printer would print an image. Later in the process, the paper was cut into individual sheets, and sometimes folded or glued or otherwise turned into a direct mail piece, or a ticket or a label, for example.

I worked on software that controlled the printers. Often, the software was a mail-merge, the end result of which was a form letter or direct mail piece individually addressed to recipients. Sometimes the software produced individual labels or tickets. I worked on code that was used by a state department of transportation to make vehicle registration stickers that drivers would affix to their windshields. I even worked on a project to produce lottery scratch tickets, where the input data file had been seeded with random numbers that corresponded to images of bells and cherries to print in a certain location on the scratch ticket.

One day, my supervisor told me he wanted me to work on a method of enabling a customer to send a print job to one or our high-speed printing presses by fax. The concept was that a printing system with a fax board in Kansas could receive content to be printed by someone sending a fax in New York. I didn’t really know anything about how fax machines worked, but it was my job to figure them out and then design a way to receive a fax and dump the contents to a printing press 150 times a minute.

As I mentioned, the printing press had a printer mounted to it. That printer had a microprocessor, memory, an input bus and storage. Basically, it was a computer, just without a keyboard and display. We controlled it with programmable logic arrays. I would write a program that would then get burned into the programmable logic array, which was then inserted into a socket on the control board for the print controller.

Code for programmable logic arrays was very basic and low level. For complex tasks, like decoding an incoming fax, it would have been very challenging to create a program to burn to a chip and get it right the first time. So the process I personally used was to first create the code in a high-level programming language, and then once I had the algorithm working correctly, to transform the algorithm to lower levels until I was ready to burn it into a chip and install it into the printer.

First I wrote a piece of software in the Pascal programming language. The software opened an incoming fax data stream and analyzed the stream, rendering it as an image on my computer’s display. This was when I began to understand how fax machines work, and how the ones and zeroes that make up a fax transmission can actually represent an image destined for a printed page.

Once I had an algorithm that could reliably take any incoming fax data stream and correctly display it on my computer monitor, I rewrote it in assembly language for my PC. Assembly is essentially a lower-level language that more directly manipulates the microprocessor and memory of a computer. The reason I re-coded my Pascal program in assembly was because assembly more closely resembles the code that gets burned into a programmable logic array. Now, I had a low-level program running on my PC that interpreted an incoming fax stream and rendered it on my monitor.

The last step was to take the assembly code and re-write it as code for the programmable logic array. The actual commands and syntax weren’t the same, but the order of the steps – the process – was the same. This step was essentially a line-by-line language conversion from a piece of software running on a PC to a program implemented in a chip that got inserted in a socket of a computer control board.

The end result was that we had created a 150 page-per-minute fax machine. The heart of the system was my code that was burned into a programmable logic array -– a chip –- and inserted into a socket on the control board for the printer. That code once existed as an assembly language program –- a piece of software -– running on my computer. The code on the printer wasn’t exactly the same as the software running on my computer because I had translated it. However, the process –- the steps that each piece of code took to handle the incoming data stream -– was exactly the same.

The above example illustrates why software is, and should be, patent-eligible. 35 U.S.C. 101, a portion of our patent laws in the United States, says “Whoever invents or discovers any new and useful process, machine, manufacture, or composition of matter, or any new and useful improvement thereof, may obtain a patent therefor, subject to the conditions and requirements of this title.” My assembly code embodied a process of opening an incoming data stream, chunking it up into individual segments representing single horizontal lines of dots, and further converting each single line of dots into the alternating blacks and whites of each line which altogether make up a faxed page. The previous sentence represents a process, and whether you run that process from a chip in a 150-fpm fax machine or as a piece of software on a PC, the process itself is patent-eligible.

Put another way, are you going to tell me that a 150-fpm fax machine isn’t eligible for a patent? Now, take all the logic that drives the fax machine and vacuum it up into a piece of software code, which you then run on a computer that has a modem installed for receiving calls from fax machines. What’s the difference? Why is one patent-eligible and the other isn’t? The answer is, they are both patent-eligible, because at the process level (a process being statutorily patent-eligible) they are the same.

Technology has progressed to the point that the difference between hardware, firmware and software is merely a design choice, representing a series of tradeoffs between speed, cost, flexibility of updates and other factors. But give me any piece of software and I’ll distill it into a process -– an algorithm -– which could be easily recoded into a chip and installed in a portable device of some type. That device, by the way, is a machine – a different patent-eligible category.

In my mind, software is patent-eligible. Having the benefit of some experience with creating software and transforming it into different types of machines has helped me better understand why.

Blog Archive