Exploring the Limits of Copyright Protection for Software – Why Good Programmers May Get Less

Part of the process of any copyright suit is to determine what is actually protected by the copyright. In the case of computer programs, this has led to the generally accepted abstraction-filtration-comparison test of Computer Associates v. Altai.

In this test, the original program is analyzed to determine what is protectable by copyright and what is not. As is well known, the “ideas” behind the program are not protected by copyright. In the test mentioned above, the “ideas” are identified and removed from the program, leaving only the protectable nuggets.

During the analysis, elements of the program are removed from protection if they are the result of mere “efficiency and logic” under the doctrine of merger or scenes a faire. These doctrines state that although an idea may have many forms of expression, there may be only one or two expressions that are truly useful. When there is only one useful expression of the idea, the idea and expression are said to merge, and the expression is not protectable by copyright. This is particularly troublesome to software developers.

Computer languages are fraught with rules, syntax, and commands that are very rigidly defined and can only be used in specific manners dictated by the computer language. The computer programmer does not operate in a world such as a literary author wherein the language may be stretched, messaged, and even misused to communicate the point. The expression of the programmer’s language is painfully and exactingly edited by the debugging process to precisely conform to the required syntax and rules. The result is that the programmer’s latitude in expression is very tightly circumscribed by the logic and efficiency of the computer language.

This means that many if not all of the elements of the computer program that define the function and operation of the program may be excluded from copyright protection if they are expressed with “efficiency and logic.” In practice, the entire program is potentially vulnerable to this test, since every subroutine and function is potentially the most efficient and logical expression of an idea.

In one example, if two programmers were to write a program to perform a certain function, each programmer is constrained to use only the commands available in the language. Further, the sequence of those commands may be generally dictated by efficiency and logic of the overall routine. In the end, the two programmers may produce code that is substantially similar to each other, especially when the code is honed for logic and efficiency. Hence, much of the code may not be protectable by copyright.

After the logic and efficient description of the underlying idea are removed from the program, what is left? In some cases, it might not be very much at all, regardless of how hard and diligently the programmer sweat over the code.

Taken to its logical extreme, this particular filter is especially harmful to good programmers and greatly benefits sloppy programmers. One hallmark of excellent programming is extreme efficiency and logic of source code. Using this test, an especially efficient and very logical program is much likely to contain less copyright protectable subject matter than one that is inefficient and poorly written.