Hacker News Reader

Comment by tantalor | Hacker News Reader

From the dissent:

> The Copyright Act expressly protects computer code. It recognizes that a “computer program” is protected by copyright... And it defines “‘computer program’” as “a set of statements or instructions to be used directly or indirectly in a computer in order to bring about a certain result.” §101. That definition clearly covers declaring code—sets of statements that indirectly perform computer functions by triggering prewritten implementing code.

Thomas seems confused here. An API (declaring code) is not a computer program. A computer cannot execute declaring code - by definition - because it is missing the implementation.

Declaring code does not "indirectly perform computer functions". Declaring code does not perform anything. It provides a reference, nothing more, for a compiler to match one computer program (the API client) to another (the API implementation).

View on HN

This argument is hard to swallow:

> declaring code would satisfy the general test for copyrightability.. they are expressed in “words, numbers, or other verbal or numerical symbols

It is common knowledge that mathematical formulae & equations, which are also expressed in words, numbers, and symbols, do not have copyright protection.

> Copyright protection is therefore not available for... mathematical principles; formulas or algorithms

https://www.copyright.gov/circs/circ31.pdf

> public static int MaxNum (int x, int y, int z)

This is literally a mathematical formula, hence does not have copyright protection.

This is not a persuasive argument because, by your logic, function implementations are also mathematical formulas and everyone agrees that they are copyrightable.

The copyrightable part of them is the creative decision making used to organize the workings of the function itself, not the formulas. Two functions could have identical algorithmic performance, but be stylistically and semantically different, have been written independently, and neither would infringe on the copyright of the other.

An API design is also a creative and highly stylistic work. Anyone who has ever designed a large API, or suffered a poorly designed one, can attest to that. A bad design can work just as well as a good design.

Also, you are distorting the argument by making it about one method signature instead of thousands of interconnected types and methods that work together to present an ergonomic interface for the developer.

The quality of good/bad or ergonomic is insufficient to meet the threshold for copyright protection.

A table of baseball batting averages or telephone numbers is not copyrightable, no matter how good or bad it is organized.

An API design is plenty creative. The bar for what is creative enough to get copyright protection is extremely low, basically zero. An alphabetized phone book is literally the example people have to use for something that isn't.

There's a reason the Supreme Court didn't adopt the argument you are pushing and instead ruled on fair use grounds: It's a bad argument because a large API is clearly a creative work.

Arguably API design is the most creative aspect of programming. The space of possible interfaces is infinite, whereas function implementations are heavily constrained by the interface and often there is only a handful of ways to write an implementation for a given interface.

Two equally good programmers may come up with radically different interfaces. Whereas if given an interface and instructed to implement it, they are likely to converge to a similar implementation.

No, definitely not. Computer code is not a formula.

A formula is an idea. It describes the nature of something computable. It does not explain how to compute.

For example: https://en.wikipedia.org/wiki/Euclidean_algorithm

The programmer must understand the formula in order to write computer code that implements it. The result is a creative/expressive work which is copyrightable.

Yes, but neither is an API signature a formula. I was assuming the logic of the person I was responding to, to show that it could not be right.

Consider the following:

gcd(X, Y) = X if X == Y or gcd(X - Y, Y) if Y < X or gcd(X, Y - X) otherwhise.

Is this a formula? Should this be copyright-able?

Of course not, this is math; it is not copyrightable.

It would have made perfect sense to Euclid.

Some computers can understand this and execute it as if it were computer code. That's amazing! Kudos to those compute language designers and compiler authors. But their ingenuity does not suddenly grant copyright protection to anything their clever compilers can now understand.

Any computable function can be written the way I wrote the function that is equivalent to Euclid's algorithm. Does it means no computable function is copyright-able or not copyright-able if written that way?

Exactly. That argument would never fly in a court. I’m always amused when software people think they have some legal checkmate like “any digital work is somewhere in the infinite digits of pi therefore cannot be copyrighted.” That’s not how law works.

The law says nothing about computability (nice straw man) but it does say ideas and math are not protected whereas code is. My point is the API declarations at the heart of this case are not protected by law because they are examples of the former. Like a formula, they are ideas that describe what to do, but not exactly how to do it.

If you code GCD in a low-level computer programming language then of course you can claim a copyright on that code, but nobody owns the idea of the Euclidean algorithm.

Function implementations are definitely not mathematical formulas. To see what I mean, check out any HN discussions on TLA+ syntax.

It’s when you see an actual mathematical syntax that you realize how different programming really is.

Not try to be tedious here, just pointing out that actually programming is different than math, even for a language like Haskell.

When you get down to it, copyright is a whole bunch of contradictory rules. Courts decide every time there is a new kind of work, whether it is copyrightable or not. Trying to divine whether something is copyrightable by analogy to other kinds of works is a hopeless endeavour.

That was the case with computer software when it first became interesting to copyright. After all, it's just a series of instructions which are often not considered copyrightable. But, in general, copyright has carried over fairly naturally from the printed word to new types of media as technology advanced.

That literally is not a mathematical formula.

   public static int MaxNum (int x, int y, int z)

This is not a mathematical formula. It is a declaration of intent to name some code that takes three ints and returns an int 'MaxNum'. It says nothing about what the code can, should or must do.

Now, if you've come up with some novel way to perform some computation on three integers and produce an integer:

- you might be able to patent that procedure.

- you might write some code that performs that procedure, and you would hold a copyright over that specific set of code

- you might, I suppose, name your algorithm 'MaxNum' and declare a trademark over it

But I don't think any of those could prevent someone from writing

public static int MaxNum (int x, int y, int z)

in another codebase.

- your patent protection might limit their ability to make a substantially similar implementation of such a function

- your copyright protection might prevent them from literally copying your implementation word for word

- your trademark protection might prevent them from passing off their implementation of MaxNum as if it were yours

But in no way does this have anything to do with the uncopyrightability of mathematics.

Thomas may have phrased it badly, but his underlying point that declaring code in a program satisfies the 17 USC 101 definition of "computer program" seems sound.

Declaring code in statement based languages is (1) a set of statements, is (2) used directly or indirectly in a computer, and it is used (3) to bring about a certain result. That hits all the points listed in 17 USC 101.

This is trivial to prove. Take a program that works and remove the declaring code. The program no longer works. That shows that the declaring code is indeed being used by the computer, and it is being used to bring about a certain result.

That the declaring code is not directly used in actually calling the API is irrelevant. The "certain result" the declaring code is used to bring about is the compiler producing output that works with the API.

Declaring statements are pure data. "int add(int, int);" is a piece of data, not a series of instructions. It may as well be a 4-tuple: (int, "add", int, int). You could convert each class declaration to a series of 4-tuples and put it in a CSV file. Database rights are much weaker than copyright.

> Take a program that works and remove the declaring code.

Actually, it will work just fine, because you the implementation necessarily has declarations in them, and you can generate declarations from the implementation.

I think this is a poor argument. I could make this "data" argument about any computer program, or even any copyrighted work. E.g. every statement is an n-tuple that could be stored in a database.

I also took issue with that argument. I suppose you could argue that the declarations are statements for the compiler or JVM. But even then, there is a layer of translation that is problematic, in my opinion. If you were to say that

public int max(int x, int y);

Is a program that tells a compiler or VM to add an entry to its public symbol table that allows it to compile or execute third-party code utilizing this function, and that the declaration, by itself, then qualified as a computer program and could be copyrighted, where would you draw a limit? Would two different programs that produce identical assembly instructions infringe on each other's copyright?

What about system calls for an OS? For example, Linux system calls have names, but they also have numeric identifiers. If someone copied Linux system call names in a new BSD-licensed OS, would they violate the GPL? What if they only copied the numbers?

It's interesting to think about. I'm glad this was the minority opinion.

> Thomas seems confused here. An API (declaring code) is not a computer program. A computer cannot execute declaring code - by definition - because it is missing the implementation.

This standard doesn't really make sense, and the legal standard says nothing about executability. What about programs with external dependencies, or a code snippet? Those won't necessarily be executable in a self-contained sandbox, but I'd certainly consider them computer programs.

Also, per Thomas's dissent:

> The majority also belittles declaring code by suggesting it is simply away to organize implementing code. Not so. Declaring code defines subprograms of implementing code, including by controlling what inputs they can process. Similarly, the majority is wrong to suggest that the purpose of declaring code is to connect pre-existing method calls to implementing code. Declaring code creates the method calls.

He clearly has a much better understanding of APIs than some software engineers I've worked with.

> Declaring code defines subprograms

Absolutely not. No points awarded.

Declaring code declares subprograms. They are defined by the implementation.

> A declaration provides basic attributes of a symbol: its type and its name. A definition provides all of the details of that symbol--if it's a function, what it does; if it's a class, what fields and methods it has; if it's a variable, where that variable is stored.

https://www.cprogramming.com/declare_vs_define.html

> the purpose of declaring code is to connect pre-existing method calls to implementing code

That sounds mostly right to me. Without declarations, the compiler cannot connect the function call to the implementation. Thomas ignores a crucial idea that decoupling definition & declaration enables multiple implementations for the same declaration.

> Declaring code creates the method calls.

That's nonsense. I have no idea what this means.

"Declaring code" is a specific term of art used in this case. For an example of what they consider declaring code vs. implementation code, see page 38 of the decision which has a handy diagram and example.

> That's nonsense. I have no idea what this means.

He's referring to how the workflow for an API generally involves gathering requirements, writing the "defining code", and then finally implementing the functionality promised by the interface. From that perspective, the defining code determines what implementation code is created, rather than linking up already existing implementation code.

Agreed. In another part the dissent says: "The Copyright Act protects code that operates “in a computer in order to bring about a certain result” both “directly” (implementing code) and “indirectly” (declaring code)."

But a program that only declares functions never brings about a result.

Declaring code is just the recipe for how to invoke implementing code.

Even if it were computer code, I think the Majority argued that use of 0.4 percent of the code can be considered Fair Use. In films, textbooks, etc., I think (though I'm not certain) there's precedent that up to 5% of the product can be reproduced (copied) under Fair Use, for criticism, academic analysis, etc.

> Thomas seems confused here. An API (declaring code) is not a computer program. A computer cannot execute declaring code - by definition - because it is missing the implementation.

Yup, for all intents and purposes an API is just a data exchange contract between different software.

The court overall seems confused, but whatever, at least they didn't rule wrongly in favor of Oracle, so I'm happy our long national nightmare is over.

Specifically I'm less motivated to read more of the PDF when the opening says "The copied lines are part of a tool called an Application Programming Interface (API)." I don't think any programmer would ever describe an API as a tool. A program implementing an API, or talking to an API, sure, but the API itself, is not itself a tool or program.

>A computer cannot execute declaring code - by definition - because it is missing the implementation.

If you allow null pointer references to a declared variable, then it certainly can.

>Declaring code does not "indirectly perform computer functions". Declaring code does not perform anything. It provides a reference, nothing more, for a compiler to match one computer program (the API client) to another (the API implementation).

I strongly disagree. We understand the obvious difference between declaration and instantiation, as declaration brings a variable into existence while instantiation specifies the variable's value. Declaring a variable is ultimately based upon available language primitives.

Whether or not he realized it, Thomas draws out a deep philosophical element of computing. Consider the creation of a self-hosting compiler. Once created, this compiler has an identity. However, creating this compiler required the usage of other software tools, each of which have distinct identities. Once the compiler operates, its creating tools become unnecessary to it, as the compiler operates independently (though the broader system may not). His phrase "triggering prewritten implementing code" has full-stack implications, whereas the majority opinion considers scope.

To connect to hierarchical processing model of programming, the majority opinion says a top-level processing block is special, whereas Thomas says no processing block differs from one another.

From a business perspective, I agree with the majority. From a philosophical perspective, I agree with Thomas.

This case is about declaration of functions/methods, not variables.

It's generally about acceptable usage of "top-level" programming objects, of which an API is one.

A related concept which comes to mind is killing in self-defense. We may say killing is killing is killing, yet society acknowledges a limited set of circumstances where it becomes permissible. In both self-defense and this court case, the difference in permissibility is context within a broader system.

By the quoted logic, any data file (say, an image) would be considered a computer program.

Agreed. I read the dissent, but not all of the majority. Do they address this point?

Reply on news.ycombinator.com