It had been hoped that a Federal Circuit judgment would shed light on what makes software eligible to be patented. But, while the court confirmed the patent ineligibility of the specific computerized method it was considering, it was divided on why.

An en banc decision involves all the judges of the Federal Circuit and thus carries a lot of weight.

The specific case under consideration was the appeal in the case of CLS Bank International v Alice Corporation, which related to a computerized trading platform. The original judgment of a Washington DC-based district court, that the patents held by Alice were not eligible for patent protection, on the grounds of them being an abstract idea, was upheld with a majority verdict 7-3. However, there were three types of claim under consideration and the judges were split 5-5 over System Claims.

Five of the ten judges were in agreement that all three types of claims involved abstract ideas; three of them disagreed on all three, finding them patent eligible. Two judges, one of whom is Chief Judge Radar, considered that while the method and computer-implemented claims in the case involved abstract ideas the stems claims did not, arguing:

Here, the claim recites a machine and other steps to enable transactions. The claim begins with the machine acquiring data and ends with the machine exchanging financial instructions with other machines. The “abstract idea” present here is not disembodied at all, but is instead integrated into a system utilizing machines ... the system claims are not directed to patent ineligible subject matter.

The divisions of opinions in this case mean that decisions about whether or not a software invention is abstract will continue to be determined on a case-by-case basis.

The issue of abstract v concrete implementation is particularly painful for any programmer reading the deliberations. For a programmer the distinction between abstract and concrete is blurred. You can think up an algorithm in your head and it is obviously abstract. You then write it down as pseudo code and it is a little less abstract. You then implement it as a runnable program and it is even less abstract. You then take the same code and use it to implement a FPGA, i.e. burn it into hardware, and now it is looking even less abstract. I suppose you could go on and try reductio ad absurdum and implement your algorithm as a Rube Goldberg machine, thus eliminating any possibility that your invention is abstract.

The point being that software is just as much an implementation of an abstract scheme as hardware. 

Chief Judge Radar included this guidance with regard to “computer implemented claims":

[W]hile the mere reference to a general purpose computer will not save a method claim from being deemed too abstract to be patent eligible, the fact that a claim is limited by a tie to a computer is an important indication of patent eligibility. … The key to this inquiry is whether the claims tie the otherwise abstract idea to a specific way of doing something with a computer, or a specific computer for doing something; if so, they likely will be patent eligible, unlike claims directed to nothing more than the idea of doing that thing on a computer. While no particular type of limitation is necessary, meaningful limitations may include the computer being part of the solution, being integral to the performance of the method, or containing an improvement in computer technology.

The real question is which abstract schemes implemented in software are so trivial as not to merit a patent even though, to the uneducated eye, they look complex.