I found an interesting bachelor's thesis recently, with some ideas in it that I have not seen applied in any sort of library that I've come across before. Thus, I would like to create my own library to apply some of the ideas found in this thesis.
My question is -- as this thesis does not contain a copyright notice, am I free under fair use to make use of the "interfaces" defined in the thesis in my own open-source library (for what it's worth, this will probably be MIT licensed).
I have reached out to the author to clarify on the copyright status of the work, and have yet to receive a response -- but even if they do not give their blessing, am I still able to make use of their interfaces under fair use?
I know that in Google v Oracle, it was ruled that "declaring code" falls under fair use -- but the question is: What exactly is declaring code?
I put "interfaces" in quotes above, because the languages used in the thesis (Haskell and Purescript) do not have a concept directly comparable to interfaces in other languages. So this leads to some questions:
- Are Haskell data type declarations considered "declaring code" in the Oracle v Google terminology, thus making copying Haskell data type declarations fair use?
- Are Haskell type classes considered "declaring code" in the Oracle v Google terminology, thus making copying them fair use?
Type classes in Haskell are pretty similar to interfaces in other languages, so it seems plausible that they could be considered declaring code. However, data types seem a bit blurrier to me. Whereas from an object-oriented perspective, data types (such as, say, a linked list) might be considered "implementing code" rather than "declaring code" -- in Haskell, the equivalent:
data List a = Empty | Append a (List a)
would probably be considered "declaring" code: A List is either
Empty, or a value
a appended to another list. The data structure is the interface, in a sense.
This brings up another question with regard to the exact definition of "declaring code", given that there are entire programming paradigms in which everything could arguably be called "declaring code". Not to mention the fact that if, one tries to define "declaring code" to be "the types/interfaces defined by a program", and "implementing code" to be "the terms inhabiting those types/interfaces", this too faces problems -- as there are languages where the distinction between types and terms is blurred.
Have any legal scholars investigated these issues? Or is "declaring code" in Google v Oracle defined in such a way to decide what is and is not declaring code in some of the "gray cases" mentioned above? Does the distinction come down to intent, or the complexity of the "declaring code" perhaps?