Google v. Oracle

The Supreme Court now has before it a case in which some very important copyright principles are at stake.


The briefs have started to come in [see here], and the Supreme Court will soon hear oral argument (date TBD), in the Google v. Oracle** case.

**Connoisseurs of case captions will appreciate the nice "two-heavyweights-going-mano a mano," "Ali v. Frazier" quality of this one; no et als, no d/b/as, no on behalf ofs … just the two titans facing off. It has some of the flavor of my favorite captions of all, cases (one or two of which the Court usually hears every year) involving competing State boundary claims or water rights or some-such, whose captions always sound like college football or basketball games: Nebraska v. Oklahoma, Michigan v. Wisconsin, etc.

It is, perhaps, the most important copyright case the Court has heard in over a decade, and interest in the case runs high, to put it mildly. Twenty-six amicus briefs supporting Google's position, submitted by an exceptionally broad range of individuals, commercial entities, and non-profits—from Microsoft and IBM to Mozilla and Reddit and the Internet Society to the National Association for the Blind and the American Antitrust Association to a raft of law professors and computer scientists—were filed last week (plus two in support of neither party).*** That already puts the case at the high end of the distribution of the number of amicus briefs submitted per case (the average, in the Supreme Court, is around 10 or 11; see here), and we still have yet to hear from amici on Oracle's side, who have until Feb. 19th to file their own briefs.

***Jonathan Band has provided a helpful summary of these briefs here.  [Disclosure: Band represents one of the amici (the Computer and Communications Industry Association), and I have signed on to one of the law professors' briefs supporting Google's position in the case.]

The case involves a claim by Oracle that Google, in developing its Android operating system, infringed Oracle's copyright in the Java programming platform. A little technical background is indispensable for understanding Oracle's claim and why it is so important.

A program written in the Java language contains two different kinds of code: "declaring code" and "implementing code." Declaring code (sometimes called a Java "declaration") invokes (or "calls") other programs from within a pre-existing library of Java programs, in order to accomplish some basic task—finding the larger of two integers, say, or summing a string of figures. The pre-written programs that are "called" from the library constitute the "implementation code."

Oracle gives this example in one of its briefs:

The URLConnection program, for example, has the following declaring code:

public URLConnection openConnection()


An app programmer who wanted to connect her application to without writing her own code can call on Oracle's pre-written code by typing:

new URL('').openConnection()

Then, when the program runs, the Java platform recognizes the declaring code and invokes the corresponding "implementing code" to connect to

The availability of a library of pre-written implementation code for thousands of tasks—pre-written and pre-tested subroutines, in effect—is one of the things that has made Java such a popular language in which to code applications, enabling Java programmers to accomplish a wide variety of tasks without having to re-invent the wheel and devise their own implementing code for these basic functions from scratch.

Oracle's library of implementation code programs (sometimes also denoted as "methods") contains over 30,000 such programs, containing many millions of lines of code, and is one of its most valuable IP assets. Oracle owns the copyright in these programs—nobody disputes that—and it actively issues licenses for their use. Anyone may obtain a royalty-free "open source" license to this entire collection of Java subroutines. Because open source licenses require users to make any alterations they make to the pre-existing code available to the public, many commercial entities are unwilling to enter into them, and Oracle accommodates them by also issuing commercial royalty-bearing licenses, at a negotiated price.

When Google began work on the Android operating system in the mid-2000s, it entered into negotiations with Oracle to obtain a commercial license for this implementing code—Oracle's entire "Java Platform"—but those negotiations broke down. Instead of abandoning its decision to use the Java language for the Android operating system, Google chose to have its own engineers re-write those implementing programs (or, in some cases, to acquire code from third-party sources). [This new, non-Oracle implementing code, incidentally, makes up around 97% of the code for the Android operating system.]

So that's the first important thing to understand about this case: Oracle has no copyright claim—and it has asserted no copyright claim—based on its immense and valuable collection of implementation programs, because Google did not end up copying any of that code.

What, then, is Oracle's claim based upon?  Google did indeed copy something: it copied Oracle's hierarchical system for organizing these 30,000+ implementation programs. A little more technical background: Oracle organizes its collection of implementation programs/methods into a hierarchy consisting of about 3,000 "classes" of code performing different but related functions, which are then grouped together into around 150 different "packages" (aka "Application Program Interfaces," or "APIs") of related higher-level functions. It is, as Google describes it in its opening brief [here], the equivalent of an ordinary filing system: each package is a file cabinet, each class is a drawer within one of the cabinets, and each individual program containing a "method" is a folder within the drawer within the cabinet.

Google copied this hierarchical system for organizing Java methods because the corresponding declarations/calls must replicate this hierarchical system precisely if the calls are to operate correctly and find the proper "method" to run. For instance, "max" is a method/implementation program that finds the larger of two integers; a Java program seeking to invoke and run the "max" program would have a declaration that looks like this:  java.lang.Math.max(5, 10). This indicates that the code for "max" is to be found within the Math "class" within the java.lang "package."

The structure and text of the declarations, in other words, are tightly constrained by the hierarchical structure of the methods, classes, and packages; indeed, they are entirely determined by that hierarchy. As the district court put it, "the rules of Java dictate the precise form of certain necessary lines of code called declarations, whose precise and necessary form explains why Android and Java must be identical when it comes to those particular lines of [declaring] code."

And Java programmers have already learned thousands upon thousands of declarations that are based on the Oracle organizing scheme. That is, in fact, a major component of what a Java programmer learns in order to become a Java programmer. Google's use of Oracle's hierarchical system for organizing the library of methods meant that Android programmers would be able to use the declarations with which they were already intimately familiar, without requiring those programmers to learn thousands of new declarations/calls to perform common tasks.

Thus, within the Android operating system, the declaration described above—java.lang.Math.max(5, 10)—does what it always does in a Java program: it finds the larger of two integers by running an implementation program (called "max") that is located in the class Math in the java.lang package.

As Google puts it in its opening brief:

Google understood that developers would want to use their existing Java language skills to create Android applications, including their knowledge of familiar declarations and shorthand commands to trigger common operations. For those commands to work on the Android platform, Google had to replicate the syntax and structure of the Java API declarations exactly; any change to those declarations would have prevented developers from reusing the same commands, thereby forcing them to learn new commands for each routine task. Google accordingly used the same declarations for certain methods in 37 Java API libraries that were determined by Google to be "key to mobile devices." For every one of those methods, however, Google wrote its own implementing code, tailoring the code to accommodate the unique challenges of the smartphone environment.

That's the heart of this dispute: whether copying the hierarchical structure of the library of implementation programs—not the implementation code in those programs, but the system by which those programs are organized—and the declarations that reflect that hierarchical structure (e.g., java.lang.Math.max(5, 10)) infringe Oracle's copyright in that structure and those declarations.

Google argues that it does not. I agree, and so did the district court, which held, correctly, that the structure of the libraries, and the corresponding text of the declarations which reflect that structure, are not protected by copyright at all. Without diving too deep into the copyright weeds, the short version of the court's reasoning is simple and straightforward. The Copyright Act, a hopeless muddle about many things, is transparently clear on point: copyright protection is not available for systems or processes or organizing methods or the like. Section 102(b) says this explicitly, and reads in full:

"In no case does copyright protection for an original work of authorship extend to any idea, procedure, process, system, method of operation, concept, principle, or discovery, regardless of the form in which it is described, explained, illustrated, or embodied in such work." (emphasis added)

This is one of the truly fundamental principles underlying our entire intellectual property regime: No matter how original or creative your system may be, or how much time and effort you put into developing it—and Oracle spends a great deal of time in its pleadings showing how original and creative and useful and valuable its hierarchical organizing system for Java methods is, and how much time and effort it expended on its development—copyright law does not allow you to prevent others from reproducing and using that system.***  

***Incidentally, a posting [here] at the Federalist by David Hogberg gets this case horribly wrong. The inadvertent tip-off is right there in the headline:

"Here's How The Supreme Court Can Stop Google From Stealing People's Ideas."

The Supreme Court can do no such thing, because copyright law does not prohibit "stealing" ideas; copying someone else's idea isn't "stealing" at all, because ideas can never receive copyright protection, no matter how brilliant or original it may be.

This vital principle establishes, among other important things, the line separating the world of copyright from the world of patent. You can get IP protection for a "system" or a "process" or a "method of operation," but only by obtaining a patent on it, which will require you to meet very different, and far more stringent, requirements to obtain protection than does copyright, and which will last for a far, far shorter period of time.

Copyright aficionados will recognize this principle as having been derived from the seminal Baker v. Selden (101 US 99, 1879) case, a delicious case of 19th century commercial intrigue. Selden had come up with a new and innovative method of double-entry bookkeeping—one that, I'm told by those who understand bookkeeping better than I do, has been incorporated into much standard bookkeeping practice. He published a book describing the system, along with several blank data-entry forms that were to be used when implementing his new system. Baker, a stationery publisher, published books containing blank bookkeeping forms, and he included Selden's forms; Selden sued, asserting that Baker had infringed his copyright in the book.

The Court held for Baker. It started with a "proposition so evident that it requires hardly any argument to support it": that Selden, though he possessed a valid copyright in his book, obtained no exclusive rights therefrom in the bookkeeping system itself. Exclusive rights of that kind, the Court declared, "are the province of letters-patent, not of copyright," and any such claim "must be subjected to the examination of the Patent Office before an exclusive right therein can be obtained." Because Selden's system had not been patented, it was "open and free to the use of the public."

And because using the system required using the special forms that Selden had devised—the Court called the forms "necessary incidents" to the use of the system itself—the forms were, like the system itself, "open and free to the use of the public." To hold otherwise—to give Selden a copyright monopoly over the forms—would effectively give him a monopoly over the use of the system. Patent-like protection, in other words, without having to satisfy the requirements of the Patent Act.

In short, Oracle's system for organizing its library of Java "methods" has no copyright protection whatsoever, and Google was allowed—at least as far as copyright law is concerned—to copy it. Only a patent would serve to protect it from replication—and Oracle, like Mr. Selden, didn't get a patent. As the district court put it:

That a system or method of operation has thousands of commands arranged in a creative taxonomy does not change its character as a method of operation. Yes, it is creative. Yes, it is original. But it is nevertheless a command structure, a system or method of operation — a long hierarchy of over six thousand commands to carry out pre-assigned functions. For that reason, it cannot receive copyright protection — patent protection perhaps — but not copyright protection.

[A great deal of ] code had been written in Java before Android arrived. These programs necessarily used the java.package.Class.method() command format. These programs called on all or some of the specific 37 packages at issue and necessarily used the command structure of names at issue. Such code was owned by the developers themselves, not by Oracle. In order for at least some of this code to run on Android, Google was required to provide the same java.package.Class.method() command system using the same names with the same "taxonomy" and with the same functional specifications. Google replicated what was necessary to achieve a degree of interoperability—but no more, taking care, as said before, to provide its own implementations…. Google was and remains free to group its methods in the same way as in Java, that is, to organize its Android methods under the same class and package scheme as in Java.

"Necessary to achieve a degree of interoperability." That language helps explain why the case is so important, and why interest in it is so high. If Oracle prevails here, the ability of software developers to design interoperable programs—programs which borrow enough of the command structure and organization of other, pre-existing programs—will be deeply compromised, and that could well have rather profound and unfortunate consequences throughout the technology industries.

The Federal Circuit, in reversing the district court and holding that Oracle did possess an enforceable copyright in its system for organizing the Java methods library, has perpetrated a deep and substantial misunderstanding of U.S. copyright law.*** One hopes that the Supreme Court will take this opportunity to correct that unfortunate state of affairs and put copyright law back on course.

***That the case ended up going from the Northern District of California to the Federal Circuit—the appellate court primarily responsible for hearing patent appeals—rather than the Ninth Circuit was due to the fact that Oracle had originally asserted a patent claim in addition to its copyright claim. The patent claim, however, was subsequently dismissed, though not before it had given the Federal Circuit jurisdiction over the appeal. The judges on the Federal Circuit have little experience with the Copyright Act, and it showed.

In fact, the Federal Circuit reversed two separate decisions in Google's favor in this case. On the first appeal, it reversed the district court by holding that Oracle's organization of its Java libraries was a copyrightable work of authorship, and remanded the case back to the district court for trial. The district court then held a full jury trial on the question of whether Google had infringed that copyright; the jury found no infringement because Google's use of the hierarchical structure constituted a "fair use." Once again, on appeal, the Federal Circuit reversed. That decision, too, for reasons I won't go into here [see here and here if you're interested], has little to recommend it.

NEXT: Today in Supreme Court History: January 20, 1953

Editor's Note: We invite comments and request that they be civil and on-topic. We do not moderate or assume any responsibility for comments, which are owned by the readers who post them. Comments do not represent the views of or Reason Foundation. We reserve the right to delete any comment for any reason at any time. Report abuses.

  1. Software nit: In the third blockquote (Oracle’s example), there should not be a space between “open” and “Connection”.

    1. Thanks – I made that change/DP

  2. I don’t know, it seems to me that Google is relying on copying the one aspect of the organizational structure that might be subject to copyright: The actual names used to identify the structure.

    That is to say, they could have exactly duplicated the structure underlying the names, with different names, and had the command read instead, “expresso.terminology.calculations.max(5, 10)” and they’d be in the clear. (“Max” is common enough as a command name to be uncopyrightable.) But, no, they copied more than the structure, they copied the words used to describe the structure.

    That’s the stuff of copyright, unlike the structure itself.

    1. Does that mean that Selden could copyright the specific naming of terms in his bookkeeping system? Others could publish forms, but they couldn’t call one column “credit” or “debit” or “asset” or “revenue” because those are the words he used to structure it?

      Seems dubious. The use of the structure implies the use of the words commonly used to denote pieces of the structure.

      1. Well, the issue is that those were already standard accounting terms. Where Google would really start to get into trouble is the “java” part of it…

        1. The libraries, method, and procedure calls are all (necessarily) simple, generic labels also. For example even the Oracle brief cited, the procedure call is “openConnction” to open a connection. That’s standard terminology too

          Oracle could make a case that even recreating a logical, intuitive structure, while similar, would not be identical, and that in total they have a copyright claim. Deciding that way would lack the “bright line” that the court would want to create though, it would leave unanswered “how much is too much”

          1. But the leading “java” isn’t generic. They should at least have changed THAT.

            1. You can’t copyright a name. For that, Oracle would have to have a trademark, which they do, for Java. But they are not suing for trademark violation, at least not in this case.

              “Copyright protection does not extend to titles, names, slogans or short phrases, the Copyright Office has made that much very clear. You can not copyright your name, the title of your post or any short phrase that you use to identify a work.

              The reason is that copyright is designed to protect works of creative authorship, it is not designed to protect how that work is identified in the marketplace, the same goes for people and places. Furthermore, such short phrases rarely meet the requisite level of creativity to be considered for copyright protection.”


            2. Actually it is generic, it identifies the language being used

    2. Here’s how Oracle put it in their brief in the court of appeals:

      Ann Droid wants to publish a bestseller. So she sits down with an advance copy of Harry Potter and the Order of the Phoenix – the fifth book – and proceeds to transcribe. She verbatim copies all the chapter titles – from Chapter 1 (“Dudley Demented”) to Chapter 38 (“The Second War Begins”). She copies verbatim the topic sentences of each paragraph, starting from the first (highly descriptive) one and continuing, in order, to the last, simple one (“Harry nodded.”). She then paraphrases the rest of each paragraph. She rushes the competing version to press before the original under the title: Ann Droid’s Harry Potter 5.0. The knockoff flies off the shelves.

      J.K. Rowling sues for copyright infringement. Ann’s defenses: “But I wrote most of the words from scratch. Besides, this was fair use, because I copied only the portions necessary to tap into the Harry Potter fan base.”

      Obviously, the defenses would fail.

      1. The difference is that the chapter titles and topic sentences are not functional. They are part of the literature.

        If something is functional, it isn’t copyrightable. Only the nonfunctional elements are copyrightable. So in a book, “Chapter I” isn’t copyrightable, but the name of the chapter may be.

        If there is no way of performing the function without copying what would otherwise be nonfunctional, then the two are “merged” and the text is in the public domain.

        I suspect Google can hit that analogy out of the park. Oracle’s lawyers shouldn’t have used it.

        1. No, the chapter title isn’t copyright-able.

          You cannot copyright the titles of books, chapters in a book, works of fiction shorter than a book, series of books, or titles of paintings.

          1. That’s why I said “may be”. An ordinary title isn’t copyrightable. However, a title might, for instance, be long or original enough to receive protection as part of the copyright of a longer work.

            (And what makes you think you can’t copyright works of fiction shorter than a book. Bob Dylan’s “Lily, Rosemary and the Jack of Hearts” is certainly copyrighted.)

            1. (And what makes you think you can’t copyright works of fiction shorter than a book. Bob Dylan’s “Lily, Rosemary and the Jack of Hearts” is certainly copyrighted.)

              He doesn’t think that; it was just poorly written, such that it took me several tries to parse it (after initially reading it the same way you did). What he meant was

              You cannot copyright the titles of (books, chapters in a book, works of fiction shorter than a book, series of books), or titles of paintings.


              You cannot copyright (the titles of books), (chapters in a book), (works of fiction shorter than a book), (series of books), or (titles of paintings).

    3. That’s because the verbatim names are *functional*. The system literally doesn’t work if you change the names. (Because google isn’t writing the software which accesses the API – other people are, and expect their code to work with the standard system).

      It would be like someone having copyright in ‘centi’, ‘meter’, ‘kilo’, etc… Then anyone wanting to use the metric system would have to pay them to use the terms necessary to engage in using the system.

    4. It’s an interesting argument, but the Copyright Office has taken the position since forever that “names” and “titles” and “short phrases” are not copyrightable, so I don’t think that Oracle has a viable claim on this score.

    5. That’s the stuff of copyright, unlike the structure itself.

      You are mistaken; names cannot be copyrighted.

      1. For completeness (@Brett Bellmore), names CAN be trademarked (e.g., Harry Potter or Captain America), but they have to be used in a manner which establishes brand recognition to survive the laugh test. So you can stop people from writing even totally original Harry Potter works so long as you hold a valid trademark on ‘Harry Potter’.

        But trademark strength is substantially weakened, if not completely abrogated, by the names being *functional* constructs. (ie, the more true it is that the name solely exists to establish brand recognition, the stronger the case for protectable trademark is). See, for example, Games Workshop’s laughable attempt to claim trademark on ‘Space Marine’ (a functional description) while ‘Adeptus Astartes’ easily passes muster, or their switching to trademarkable names like ‘Aelves’ (instead of elves) in Age of Sigmar.

        1. So you can stop people from writing even totally original Harry Potter works so long as you hold a valid trademark on ‘Harry Potter’.

          Technically you can only stop them from commercially exploiting them. It’s totally legal to write and self-publish Harry Potter fanfic, for instance.

          1. To clarify I should have said “totally legal under trademark law” because it is a noncommercial use. Obviously there could be a potential copyright claim if too much of the Rowling books were used.

            1. I’m not convinced it’s *totally* legal, and nor are all authors and publishers. Just because its non-commercial doesn’t mean it doesn’t dilute brand strength or create consumer confusion.

              Now, as a practical matter, writers of fanfiction are rarely (if ever) sued over trademark violation. Declaiming you are the owners of the trademarks you are non-commercially using is a good way to avoid liability (which at least some fanfiction writers do), because it expressly acknowledges non-ownership, and therefor can’t create confusion in the market. And many fanfics are obviously parody, which is a fair-use carve-out. (See also transformative use).

              There are also several other factors which would go into a thorough trademark analysis of fanfiction. But, end of the day, if a court finds a work causes confusion in the ‘marketplace’, it’s probably liable as a trademark violation, even if non-commercial.

  3. Interestingly, Oracle Cloud does pretty much the same thing that Google did. Oracle implemented the AWS S3 API on their own cloud platform. I’m sure there is some nuance here, but it certainly does demonstrate the value of API consistency.

    1. The computer industry (including Oracle) would not exist in its current form without duplicating the existing functionality by maintaining the calling patterns. The most well known early case of this is Compaq wrote a a version of the IBM BIOS code in a clean room back in 1982 which gave rise to the PC clone market. IBM’s lawyers did find one copyrighted code and Compaq ended up paying over $100 million dollars to IBM. But like all lawsuits in the technology industry – it was too late.

      1. In this case they are relying on the design of, in computer science terms, the hierarchical namespacing definitions.

        Syntactically the . or other level changing symbology is irrelevant. The name is the name, and is part of the API that is not copyrightable as per Compaq. It’s like saying the name O’Reilly is copyrightable because it has a ‘ in it.

        Internally, compilers will use a process called munging to build an old school function name that may have this hierarchy built into its symbol, giving lie to the idea this is even something other than function naming. I have no idea if Java does this, but some of these math library functiins can’t have runtime traversal of these hierarchies or they will be useless for non-trivial math.

  4. I am surprised that the terminology used by many Java programmers (and in other languages that are similar in this regard) hasn’t been used.

    A Java “Interface” is often referred to as a contract. When teaching students how to use the language it is explained this way. The Interface is simply a well-defined grammatical structure that documents 1) what methods a given component of software implements and 2) what it will respond with if any such method is invoked. Java Interfaces are implemented by Java Classes which are software source code which need not be exposed (at least technically) to the user that calls the Interface methods.

    What apparently Oracle wants to copyright is the Interface itself.

    If this is a copyright infringement than legal contracts can also be copyrighted.

    That is, of course, separate from the issue as to whether an Interface aka contract can be held confidential under an NDA, but I don’t think that would apply to the IP that Oracle is trying to control.

    1. Can legal contracts be copied verbatim for commercial use without compensation?

      1. Compensation isn’t necessary but permission is. Some organizations write Standard Contracts for specific situation ans sell them with a license.

      2. “Can legal contracts be copied verbatim for commercial use without compensation?”

        Lawyers have been copying the work of others since 1200.

    2. A Java “Interface” is often referred to as a contract. When teaching students how to use the language it is explained this way.

      This is another example of terminology that is only used in classrooms. As an infosec professional who works in a large tech company where both java and c++ are used in the development of thousands of interfaces – the word “contract” is never used.

      1. I work as a software developer on large systems, and I do sometimes hear the term “interface contract” used. Usually in the context of someone “violating the interface contract” and causing bugs.

    1. This seems legit.

  5. As a small correction. Oracle did not write or develop Java, that was done by Sun Microsystems which Oracle later acquired. Sun was perfectly happy to have people implement Java and said so many times. Oracle changed the story. And oh by the way much of Java uses many terms and constructions from earlier languages, notably C and C++ whihc evolved from earlier languages.

  6. Very interesting.

  7. > Because open source licenses require users to make any alterations they make to the pre-existing code available to the public, many commercial entities are unwilling to enter into them, and Oracle accommodates them by also issuing commercial royalty-bearing licenses, at a negotiated price.

    It would be helpful if this were reworded to clarify that not all “open source” licenses require sharing alterations. The BSD license, the MIT license, the Apache license, there are several. This is widespread. At my day job I help develop software that has an open source license, and my employer is under no obligation to share the work I do.

  8. “open source licenses require users to make any alterations they make to the pre-existing code available to the public”

    This is incorrect. Some open source licenses — generally, the “copyleft” licenses — require this, but many (e.g., Apache, MIT, BSD) do not.

    “Declaring code (sometimes called a Java “declaration”) invokes (or “calls”) other programs from within a pre-existing library of Java programs,”

    I don’t think this is quite right. The declaring code doesn’t “invoke” or “call” anything. It tells *other* code how such other code can invoke or call the implementing code — in other words, it defines an API. For instance, the exemplary “public URLConnection openConnection()” declaration says, “this object has a method called openConnection that takes no arguments and returns a URLConnection object.” But it doesn’t actually call that openConnection() method. *Other* code can call that method, consistent with the declaration, by saying (for instance) “URLConnection foo = [object].openConnection();”. And then the code implementing openConnection() will get executed. But, again, the method declaration itself doesn’t invoke or call anything.

    1. Yes, that is how the FSF and OSI define open source *software* but I think on

  9. On oracle’s theory how does it not have a copyright claim against any program written for use against it’s API. After all such programs include the API information (names which implicitly convey the hierarchy).

    I mean maybe Oracle takes the API use to be licensed to end users but that kind of conclusion would sure be a surprise for many people who call APIs and lead to truly epic scale copyright trolling (buy up an old company with an API copyright and profit)

  10. IIUC, one could copy Google’s search architecture for usage in their own search program? After all, it is just a type of library and filing structure.

    1. Depending on how you mean that, yes you could. But you couldn’t copy the implementing code that determines where in the structure a given website belongs. Google also jealously guards the algorithm itself, but the biggest advantage is the store of already existing data that Google has to train its algorithm against. Bottom line, the organizing structure is like a filing system. By itself it’s instructive but hardly enough by itself to replicate all of what goes into the system.

  11. I’m gonna have to read the transcripts from oral argument for this. I suspect it’ll be a riot seeing how the lawyers and judges tripped over simple CS concepts.

  12. Following IP law developments for my career, I think it’s safe to say that whatever you think you know about Copyright law (or any IP field), a significant majority of the Supreme Court is going to say that your (and the relevant IP Bar’s) understanding is wrong.

    There may be a dissent arguing that you’re wrong in a different way.

  13. Both of them, Oracle and Google are kinda extra top-level devs, that common people can address for some development. Only big corporations can afford them, especially Oracle’s support. I was working with and honestly, its a great alternative for Java development.
    Wish my business would become so huge one day, so I would ask Google/Oracle/Whatever Huge for cooperation 🙂

  14. You write convincingly that the Declaring Code is not copyrightable; the court likened it to a dewey decimal system in a library, and you cite Baker v . But the court did not decide the case on these grounds. It assumed for, sake of argument, that the Federal Circuit had been correct in saying that it WAS copyrightable, and decided that Google’s use was a “fair use” of copyrightable material. I think, because of this, Thomas’s dissent is a far better display of legal reasoning, and his characterization of Oracle’s Declaring Code as a work of authorship is more persuasive than your argument. Key: Microsoft and Apple did the same thing, but wrote their own Declaring code. Google could have wrote their own code as well, but that would have meant their software developers would have had to learn it. Instead, they copied the written code the developers already knew. In your opinion, Google’s resultant competitive advantage, an advantage that produced Android’s several hundred billion dollar market, is OK because of the arcaneness of our copyright/patent system. I agree that the system needs updating to reflect the realities of computer programming languages as systems or works of authorship, but that is not what happened in this case.

Please to post comments