[throwawaykf05]

All code is a formalized description of "methods of operation". Unless you believe software achieves practical results without the benefit of hardware. And that's assuming you write pure assembly, else you also have firmware, operating systems, drivers, libraries, runtimes, or whatever supporting infrastructure is needed for your code to do anything meaningful.

[bediger4000]

I agree that all code is a formalized description of "methods of operation", unless the legal phrase "methods of operation" has some exotic, inobvious meaning, like "secure in their persons, houses, papers, and effects, against unreasonable searches" has taken on.

That's why the US shouldn't allow software patents. Software is either mathematical or a formalized description of a method of operation.

[throwawaykf05]

On the contrary, patents are exactly what are intended to cover methods of operation. A lot of court decisions regarding copyrightability explicitly mention this. Note, patents usually don't cover the formalized description itself (mainly because it would result in an overly narrow patent) but rather what you can use software to do.

Here's a claim from the infamous one-click patent:

1. A method of placing an order for an item comprising: under control of a client system,

displaying information identifying the item; and in response to only a single action being performed, sending a request to order the item along with an identifier of a purchaser of the item to a server system;

under control of a single-action ordering component of the server system,

receiving the request;

retrieving additional information previously stored for the purchaser identified by the identifier in the received request; and

generating an order to purchase the requested item for the purchaser identified by the identifier in the received request using the retrieved additional information; and fulfilling the generated order to complete purchase of the item

whereby the item is ordered without using a shopping cart ordering model.

It's a description alright, but there's nothing mathematical or formalized about it (though a software implementation would be a lot of code - formalized description - that applies a bunch of mathematics).

[bediger4000]

It's good that you're distinguishing "patent" from "copyright" from the vague morass of "Intellectual Property".

The goodness of patents depends on them being inobvious, and the receipient of the patent actually disclosing something useful. Otherwise, once again, the government is just granting a state-enforced monopoly on something, rather arbitrarily.

The problems with "IP" don't rest merely with distinguishing "idea" from "instantiation" (or whatever the legal term is), but rather derive from a much deeper level of problem and paradox.

[Zigurd]

Code is a specific implementation of a method of operation. The code can be copyright protected. But not the formats the code reads and emits. Not the language the code is written in. Not the machine language the computer processes. Not the method signatures in the code. Etc.

[throwawaykf05]

Actually, formats and languages are not, but the generated machine code is copyright protected as a "derivative work". This is how binaries enjoy copyright protection, because they are "derived" from copyright-protected human-produced code. I think that's a bit crazy that a potentially useful product by itself has no intrinsic protection.

As for method signatures, at a human readable level, they are as protected as any other code. Note that copyright protects expression rather than what the code does. So File.open(fname) and open(fname, 'r') and new File(fname) are all different expressions of the concept of "open a file with a given name)". The concept is not covered, but the specific expression is. Of course, a single method is not sufficient, but this case involves a collection of hundreds of such signatures.

[Zigurd]

I agree about generated machine code. I was referring to an instruction set architecture, that is, the format of the machine code, not the specific sequence of code generated from translating a higher-level language.

I can't agree about method signatures, though. They are like a language, a format, a protocol, none of which are protectable.