Obama Administration Files Totally Clueless Argument Concerning Software Copyrights In Supreme Court Case

from the oh-gosh-no dept

The Obama administration made a really dangerous and ignorant argument to the Supreme Court yesterday, which could have an insanely damaging impact on innovation — and it appears to be because Solicitor General Donald Verrilli (yes, the MPAA’s old top lawyer) is absolutely clueless about some rather basic concepts concerning programming. That the government would file such an ignorant brief with the Supreme Court is profoundly embarrassing. It makes such basic technological and legal errors that it may be the epitome of government malfeasance in a legal issue.

We’ve written a few times about the important copyright question at the heart of the Oracle v. Google case (which started as a side show to the rest of the case): are software APIs covered by copyright. What’s kind of amazing is that the way you think about this issue seems to turn on a simple question: do you actually understand how programming and software work or not? If you don’t understand, then you think it’s obvious that APIs are covered by copyright. If you do understand, you recognize that APIs are more or less a recipe — instructions on how to connect — and thus you recognize how incredibly stupid it would be to claim that’s covered by copyright. Just as stupid as claiming that the layout of a program’s pulldown menus can be covered by copyright.

The judge in the district court, William Alsup, actually learned to code Java to help him better understand the issues. And then wrote such a detailed ruling on the issue that it seemed obvious that he was writing it for the judges who’d be handling the appeal, rather than for the parties in the case.

Unfortunately, the judges at the federal circuit court of appeals (CAFC) didn’t pay attention and made a completely ignorant ruling, in which it became so clear that they didn’t understand the difference between software and an API that it was almost embarrassing. The decision quoted people in ways that were completely out of context, where the CAFC judges clearly misunderstood what was being said. This ruling would fundamentally kill off important forms of innovation if allowed to stand. It would be a disaster.

So, of course, the case has been appealed to the Supreme Court — and that’s where Donald Verrilli steps in. The Supreme Court asked the Solicitor General if the US had an opinion on the case. This apparently led to a healthy debate within the Obama administration over the position it should take. I know that there are people within the administration who understand these issues. Hell, Ed Felten has just been appointed deputy CTO for the administration and he, of all people, recognizes the difference between an API and software (in fact, he signed onto an amicus brief saying as much). He also (more than most) understands the copyright side of things and the potential impact of getting this wrong.

But instead of listening to the people who actually understand the technology, it appears that Verrilli sided with the copyright maximilist/technology-ignorant faction in the government. The final brief argues that the Supreme Court should stay out, that the CAFC got it right, and that it’s impossible to distinguish between APIs and software. Because Donald Verrilli has absolutely no clue how software works. That’s a fundamentally ridiculous argument, and argued out of near total ignorance of the basic facts of this case.

Just as a quick refresher, copyright law clearly states that:

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.

An API is, quite simply, a “system or method of operation.” It’s not copyrightable. That should be the end of the story. And yet, everyone who doesn’t get this keeps arguing that an API is the same thing as software itself. This is just flat out wrong. But Verrilli makes the same mistake:

Despite the inherently functional character of all computer code, the Copyright Act makes clear that such code can be copyrightable. Nothing about the declaring code at issue here materially distinguishes it from other computer code, and petitioner has identified no genuine conflict of authority concerning Section 102(b)?s applicability to circumstances like these. Although petitioner has raised important concerns about the effects that enforcing respondent?s copy-right could have on software development, those concerns are better addressed through petitioner?s fair-use defense, which will be considered on remand.

No, no, no and no. Everything about the declaring code distinguishes it from other computer code if you understand the first thing about computer programming. One is computer code. One explains an interface for communicating with computer code. They’re fundamentally different things.

It’s like arguing that there is fundamentally no difference between a recipe and a fully cooked meal.

And yet, that’s exactly what Verrilli and the Obama administration are now arguing to the Supreme Court. Because they don’t understand even the most fundamental things about code, and assume that because an API looks like computer code (because whoever wrote this brief is ignorant of coding), they’re the same thing.

Later in the filing, Verrilli, again, seems to assume that an API is the same thing as “computer code.”

If the Copyright Act contained no explicit references to computer code, one might reasonably conclude that such code is not protectable ?expression? at all. Computer code differs in a fundamental way from many traditional means of literary expression. A book or newspaper article is meant to be read and comprehended by a human being as a description of an idea or story. Although many copyrightable written documents explain how practical tasks should be per-formed, there is typically a clear distinction between the written explanation and the actual performance of the task. Computer code, by contrast, is both expression and the actual means by which a computer is induced to perform the desired function. It therefore would not be unnatural to describe computer code as a ?method of operation? or ?system.? Nor would it be unreasonable to conclude that, as between a book on bicycle-building and the actual construction of a bicycle, computer code is more analogous to the latter.

Again, the entire basis of this paragraph is arguing something no one is arguing against. Everyone agrees that computer code is copyrightable. What we’re arguing is that APIs are not computer code — because they’re not. But because Verrilli and others can’t seem to wrap their head around this, they just lump it all together. And the argument, based on this faulty premise continues:

The Copyright Act as a whole makes clear, however, that the functional character of computer code cannot be sufficient to bring it within Section 102(b). If that were so, no computer code would qualify for copyright protection;

This makes no sense. At all. Of course, computer code is copyrightable. But an API that is just a method of how to interact with that code is not computer code.

yet the Copyright Act unequivocally recognizes that a person can own a copyright in computer code…. Rather, the uncopyrightable ?method of operation? or ?system? or ?process? is the underlying computer function triggered by the written code?for example, an algorithm that the computer executes to sort a data set. The code itself, however, is eligible for copyright protection.

Again, yes, of course the code is copyrightable. But the code is not the API. It’s incredible how fundamentally the Solicitor General doesn’t seem to grasp this simple concept.

When the filing eventually tries to get around to the difference between an API and software code itself, it basically just throws up its hands, saying “well, it looks like code, so it’s all the same to us.”

That distinction does not withstand scrutiny. Both declaring code and implementing code ultimately perform the same practical function: They instruct a computer to work. The declaring code tells the computer to call up the implementing code, and the implementing code tells the computer to perform an operation, such as executing a sorting algorithm. Both are necessary components of a Java or Android method. And neither the declaring code nor the implementing code is what a programmer physically types when invoking a method.

Yes, and the recipe and the ingredients are both “necessary components” of a meal, but that doesn’t make them the same thing. Hell, to be more specific, the recipe and the description of how to prepare a meal are both necessary and they look fairly similar. But in copyright law the recipe is not copyrightable, while the description may be. That’s the same thing with software code and APIs. But because the folks who wrote this brief are either ignorant — or ridiculously chose to ignore those who do understand these things — we get this absolutely embarrassing brief from the US government. It’s a travesty.

Furthermore, Verrilli seems to be suggesting that the important Lotus v. Borland case which found that the layout of a computer program’s menu structure were not covered by copyright, was decided incorrectly!

The precise rationale of Lotus is not clear. Parts of the opinion purport to rest on the proposition that Section 102(b) can foreclose copyright protection for original expression…. But other parts of the opinion seem to apply a principle analo-gous to the merger doctrine, to the effect that, be-cause there was only one menu hierarchy that would allow users to operate the spreadsheet program in substantially the same way, the menu hierarchy (un-like the underlying code) could not acquire copyright protection…. Whatever the rationale of Lotus, however, the decision cannot reasonably be read to treat Sec-tion 102(b) as applicable to computer code itself, a form of expression that the Copyright Act clearly protects and that the First Circuit took pains to distinguish.

Also very wrong, is Verrilli’s repeated claim that these are issues that can be handled by a fair use analysis, rather than the question of whether or not API’s are copyrightable at all:

Indeed, many of petitioner?s specific contentions will be relevant to its fair-use defense on remand. For example, although it would be anomalous to use Section 102(b) to distinguish between different segments of a single work of authorship…, Section 107(3) instructs courts to consider ?the amount and substantiality of the portion [of a copyrighted work] used in relation to the copyrighted work as a whole? in adjudicating a fair-use defense. That petitioner copied only respondent?s declaring code while writing its own implementing code should therefore be a relevant factor in the lower courts? fair-use analysis.

But this, too, is wrong. There’s a big difference in saying “this is not copyrightable” and “this can be used thanks to fair use.” Fair use is (unfortunately) limited and dependent on a number of factors. Something that is not covered by copyright is open to all comers. The difference is really important and the Solicitor General doesn’t even care at all.

Unfortunately, the Supreme Court often follows the Solicitor General’s advice on cases (though, not always). If it does so here, it would be a travesty and truly dangerous for innovation. As a ton of top computer experts (including now deputy CTO Felten) noted in their own brief (put together by the EFF), the lack of copyright in APIs has been a key element in defining the way the digital world works. To find otherwise would be a massive hit to basic innovation. As that brief explained

Today, open, uncopyrightable APIs continue to spur the creation and adoption of new technologies. When programmers can freely reimplement or reverse engineer an API without obtaining a costly license or risking a lawsuit, they can create compatible software that the interface?s original creator might never have envisioned or had the resources to develop. Moreover, compatible APIs help enable people to switch platforms and services freely, and to find software that meets their needs regardless of what browser or operating system they use. Without the compatibility enabled by the open nature of APIs, consumers could be forced to leave their data and programs behind when they switch to a new service.

The freedom to reimplement APIs also helps developers rescue ?orphan? software or data?systems that are no longer supported by their creators. When a company stops supporting a computer platform or service, the ability to freely reimplement APIs protects the communities that rely on that software. Government entities and non-profits are especially susceptible to the orphan programs problem as they often cannot afford to upgrade and are left using legacy technologies for years or decades.

It would be truly ridiculous that, just because the MPAA’s former top lawyer is so ignorant that he can’t comprehend the difference between an API and actual software, that the Supreme Court would allow such a terrible ruling as CAFC’s to stand.

Filed Under: , , , , , ,
Companies: google, oracle

Rate this comment as insightful
Rate this comment as funny
You have rated this comment as insightful
You have rated this comment as funny
Flag this comment as abusive/trolling/spam
You have flagged this comment
The first word has already been claimed
The last word has already been claimed
Insightful Lightbulb icon Funny Laughing icon Abusive/trolling/spam Flag icon Insightful badge Lightbulb icon Funny badge Laughing icon Comments icon

Comments on “Obama Administration Files Totally Clueless Argument Concerning Software Copyrights In Supreme Court Case”

Subscribe: RSS Leave a comment
John Fenderson (profile) says:

Re: Let me see if I can help

That doesn’t capture the difference. Better:

API: A specification for how one piece of code talks to another piece of code. The API itself does not consist of any code whatsoever: it’s a specification.

I think that some of the confusion comes because programmers use a shorthand when they talk about APIs: they refer to specific implementations of the API as “the API”. It’s not accurate, but in most cases it’s close enough.

Some more confusion comes from the choice of language. Some popular languages (such as, say, Java) are constrained so that you can’t use a binary interface. This means that you need to use certain specific strings. Those strings look like code, but are in fact part of the specification (the API), and not actually code at all.

Cdaragorn (profile) says:

Re: Re: Let me see if I can help

I was simply joking around, but the point is a lot simpler than it looks.

An API is just a public member you can call. That’s it. There’s nothing more complicated about it.

Saying it’s a specification is IMHO not correct. A specification describes the API, it is not the API itself. An API absolutely is code. The difference is just the public members, which are the API, vs the private implementation details, which are not.

Dingledore the Flabberghaster says:

Re: Re: Re: Let me see if I can help

A specification describes the API, it is not the API itself. An API absolutely is code.

Entirely disagree.

The implementation of an API is written in code. This very sentence demonstrates that the API is not code itself, but a standard. You can implement the API in code any way you want as long as it meets the standard. The API doesn’t care how it is implemented, as long as it meets the standard.

Cdaragorn (profile) says:

Re: Re: Re:2 Let me see if I can help

From Wikipedia:

“In computer programming, an application programming interface (API) is a set of routines, protocols, and tools for building software applications.”

An API exists whether anyone has taken the time to document it or not. The specification cannot be the API, or by definition an API could not exist until someone took the time to write a specification for it. All the specification does is tell you what’s in the API.

Chris Brand says:

Re: Let me see if I can help

How about this for understanding the distinction:
“The declaring code tells the computer to call up the implementing code, and the implementing code tells the computer to perform an operation, such as executing a sorting algorithm.”
(yes, that’s the next sentence after the one you quoted).

Almost Anonymous (profile) says:

“Unfortunately, the Supreme Court often follows the Solicitor General’s advice on cases (though, not always).”

Even if they didn’t, what makes you think that SCOTUS will be any more technically capable to make a reasonable ruling than CAFC? None of the sitting judges gives me the impression that they would be willing to do the homework that Alsup did to actually understand the issue.

Anonymous Coward says:

Re: Re:

The technical details in the Myriad case are frightening. How they managed to reach a tolerable decission on that issue with such a lack of grasp on the absolute basics is beyond me.

This is a very different case, but if SCOTUS aren’t willing to distinguish between different types of code, the precedence will be extraordinarily destructive.

JD says:

Future Verrilli arguments

“Nothing about the pre-1920 work at issue here materially distinguishes it from other creative work.”

“Nothing about the Gregorian calendar at issue here materially distinguishes it from other human-created works.”

“Nothing about the federal government press reports at issue here materially distinguishes them from other press reports.”

You could probably have fun with this on Twitter. #VerrilliLogic

The Artist Formerly Known as Anonymous says:

Analogy 2.0

It’s like arguing that there is fundamentally no difference between a recipe and a fully cooked meal.

The analogy is slightly off the mark, because a recipe can be entitled to copyright protection. See http://www.copyright.gov/fls/fl122.html. But mere lists of ingredients are never entitled to copyright protection.

So, the difference between APIs and computer code is like the difference between lists of ingredients and the recipe. The possible API calls are mere ingredients; the specific order and number of times in which a third party combines them is a potentially copyrightable recipe. But in no way does the creator of the API hold any copyright in the API definition.

Rich says:

Re: Analogy 2.0

No, recipes are NOT entitled to copyright protection. You are completely misreading your own link. A particular write-up or description of a recipe is copyrightable, but that’s not the recipe. I can take your recipe, put it in my own words, and there is nothing you can do about it.

The Artist Formerly Known as Anonymous says:

Re: Re: Analogy 2.0

You missed the point of the analogy. The link states, “Copyright law does not protect recipes that are mere listings of ingredients.” For purposes of the instant discussion, APIs are analogized to mere listings of ingredients and thus not entitled to copyright protection.

Whether the resulting invocation of the API (i.e., “recipe”) “can be entitled” (note that my post did not say “is entitled”) to copyright protection is not the purpose of this discussion.

tqk (profile) says:

Profoundly depressing.

WTF anyone’s listening to lawyers talking about computer programming code is the mystery to me. They couldn’t even be bothered to try to understand the one judge who researched and laid it all out for them. I wonder if they even bothered to read his treatise.

Are the Vogons here yet, ’cause I’m pretty sure I’ve had enough of this ridiculous planet. Stories like this prove that we’re all really just in the way, and the Universe would be a happier place if we just weren’t here.


Unanimous Cow Herd says:


I am not a duck but have a similar API.

I am a warm blooded organism with bilateral symmetry consisting of a cranium, torso, two upper and two lower appendages.

If I bend a little, stick my butt out, tuck my upper appendages in and waddle, I can walk like a duck.

Using the vocal capabilities of my API, I can also “quack” like a duck.

Fortunately, my API does not depend on duck neural CODE to accomplish that.

mcinsand (profile) says:

Re: Google's use of Java

Feel free to use Google or some other search engine to look up the history. Before Oracle purchased Sun, Sun was encouraging Google to adopt Java and even celebrating Google’s choice of Java to be part of its new Android efforts. Dalvik was not a tool for theft but a result of Google’s concern for some parts of the Java infrastructure not being fully clear of license issues. It wasn’t until Oracle purchased Sun that Google was accused of stealing by responding to Sun’s encouragement.

Personally, I wish Sun had never induced Google to go forward with Java. There are plenty of better languages, and not many that are worse.

JP Jones (profile) says:

The annoying point is that restricting the use of APIs kind of defeats the major purpose of an API. While APIs are certainly used within closed systems the main use I’ve seen for an API is allowing different programs to interact with each other. It basically says “this is generally how my program interacts with X” in order to let other programs also interact with X.

If you’re required to get approval and/or pay in order have your program interact with another program that seems like it would severely reduce the value of APIs and discourage program compatibility. As far as I can tell, most of the value in an API is lost if other people can’t use it, which makes the argument that copyrighting APIs is good for innovation pretty hard to swallow.

tqk (profile) says:

Re: Re:

If you’re required to get approval and/or pay in order have your program interact with another program that seems like it would severely reduce the value of APIs and discourage program compatibility.

Well, yeah, and that’s why we at Oracle offer you this wonderful tool to interface with the premiere Oracle database, which is available for the low, low price of your first three children. Licence only, good for one processor, when used in the contiguous US, Mon. – Fri., 9-5, on-line connected at all times, …

This planet gets sillier every day humans exist on it.

Teamchaos (profile) says:

A bit of background, and a question.

Found a great article out on the eff site (if you’re interested) https://www.eff.org/cases/oracle-v-google

Google developed their own version of Java to use on Android. “But in order to allow developers to write their own programs for Android, Google’s implementation used the same names, organization, and functionality as the Java APIs.” Oracle got upset and took them to court. The issue in question is that Google’s Java uses the same API’s as Oracle’s Java.

For non-developers out there, APIs (Application Programming Interfaces) are, generally speaking, specifications that allow programs to communicate with each other.

From Judge Alsup’s ruling (as quoted by the eff article) “Simply, where “there is only one way to declare a given method functionality, [so that] everyone using that function must write that specific line of code in the same way,” that coding language cannot be subject to copyright.”

So is the judge saying that the API’s in question were such that there was no other way that Google could have implemented the same functionality using different APIs?

tqk (profile) says:

Re: A bit of background, and a question.

So is the judge saying that the API’s in question were such that there was no other way that Google could have implemented the same functionality using different APIs?

You’re oversimplifying. The ideal is I as a programmer don’t need to know the gory details of what’s going on in a programmer’s library. I just need to call the library functions correctly for them to work. If you’re building a library, you want any programmer who wants to use that library to just use the API to access those functions. As a programmer, I don’t want to have to care whether the underlying library came from Oracle or Google. Assuming the language has been standardized (ISO), I just need to understand the API.

Programmers hate having to bloat their code with crap that just tries to figure out if it’s being run in IE or Firefox or Chrome or Opera. They just want to do BLAH and they expect the called library function does it correctly.

Just read some of the history behind the K&R C evolution into ANSI Standard C to understand this. Oracle (and Microsoft, and …) want to lock all this up so to talk to Oracle, I need to use Oracle purchased tools. F-them! They also want to tell Google it’s not allowed to enable functionality that Oracle sells. That’s not how tech should work. We don’t want monopolists deciding what’s good for us.

Zonker says:

Re: A bit of background, and a question.

Google was free to implement any API they wanted, they chose to implement Java for compatibility with existing Java programs since Sun intended Java to be a cross-platform programming language to begin with.

But in order to not infringe on any copyrights, Google wrote their own clean room implementation of the Java API to run on smartphone hardware rather than modify the existing Sun Java implementation. Oddly, what initially offended Oracle is that Google did not use the full Java implementation, only a subset of it that would be relevant for a smartphone. This is why Oracle’s Java Mobile (which Oracle wanted Google to use) failed in the marketplace, because the bloat of the full Java library was not well suited to smartphones or tablets. You wouldn’t run a database server on your smartphone, would you?

This is exactly what an API is supposed to be used for. IBM has their own implementation of the Java API for AIX, Linux, z/OS, and IBM i here which would be infringing too if Oracle gets its way.

Unless Google wanted to write their own computer language that wasn’t compatible with any existing software, they would have to choose an existing API to implement. That implementation is the creative and copyrightable part, not the API it implements. If you needed a license to implement an API, then the API would essentially be useless.

Full coverage of the original case before Judge Alsup with excellent articles about each major development in the old Groklaw archives: http://www.groklaw.net/staticpages/index.php?page=OracleGoogle

(Still sad to lose Groklaw as part of the Snowden whistleblower fallout, it was a valuable resource.)

masquisieras says:

Re: Re: A bit of background, and a question.

Google did not write a java implementation if it would do that,it will be no problem. It will be fair use for compatibility reasons. As IBM has done with no problem.

The problem is that Google created a different java-like language that is incompatible with java but near enough to attract the java programers but that will be fully controlled by Google an to do so it copied a bunch of declarative code of the java API. So the fair use defense for compatibility is a tough pill to swallow.

So Google wrote their own computer language that WAS INCOMPATIBLE with any existing software but easy for a programer that already knew java to pick up.

Even so Google could have done it if would have keep the openlicense (GNU) of the opensource implementation available of JAVA but it choose for commercial reason to move to BSD license.

Zonker says:

Re: Re: Re: A bit of background, and a question.

Google’s implementation was a subset of Java. It did not include all the Java junk that makes no sense having on a smartphone or tablet, but does on a desktop or server. Because it was a subset instead of full Java, you are correct it is not a complete Java implementation and thus won’t run all Java programs.

Thus Google could not, would not, and does not call it Java. To do so would infringe the trademark or fail to meet the requirements to be a certified Java implementation. That would be what Microsoft tried to do with its Microsoft Java Virtual Machine back in the late ’90s, but there they actually tried to pass off their proprietary Java as Java, not a fork under a different name or a subset.

Sun sued Microsoft because of how they tried to pass off their proprietary extensions on Sun’s own implementation of Java for Windows as Java. Sun endorsed and supported Google implementing a subset of the Java API on smartphones because they did not try to pass off their independently implemented version as Java. Oracle bought Sun, tried to sell their Java Mobile implementation and failed, then sued Google because they wanted Google to use Java Mobile (which was terrible) instead of Dalvik (which was overwhelmingly successful).

Dalvik is it’s own Java based subset largely compatible with existing Java programs that can run on the limited resources of a smartphone, but no it is not Java and programs that require hardware or services you would not find on a smartphone won’t run because those libraries are not there. This is not infringing like Microsoft as there is no attempt to use code written by Sun/Oracle, adding proprietary extensions, and passing it off as Java.

JP Jones (profile) says:

Re: A bit of background, and a question.

So is the judge saying that the API’s in question were such that there was no other way that Google could have implemented the same functionality using different APIs?

That’s correct. The API is essentially something along the lines of “All programs will use port 42 for authentication.”

I think the reason for the confusion is because “API” is used for two different things. There’s API as the technical term which is essentially a protocol definition; in other words, a description of what is needed to interact with the function of a different program. There’s also API as a programming library, which is a set of functions that perform certain actions.

For example, DirectX is technically an API, and is a set of instructions for how to interact with various media and input devices on Windows computers. Technically the DirectX API involves no code at all, and won’t compile or run anything.

DirectX also has the Software Development Kit, or SDK, which consists of runtimes and libraries used for specific implementations of the DirectX API. A programmer can call functions from the SDK without writing them manually, which obviously speeds up development. The runtimes are based on the API but they are not the same thing.

Even programmers will often confuse the two, although in practice it’s not so much “confusion” as “unimportant distinction.” They will often use the terms “API,” “library,” “SDK” interchangeably, although all have fairly significant differences.

The key part is that an API is pretty much a list of variables, dependencies, and a basic structure with “Insert code to do X” here comments. It’s sort of like having a book with a cover, some pages saying “Chapter 1”, “Chapter 2”, etc., and sticky notes with “insert story here.” While it may make the basic structure of your book easier, and create limits to what you can work with, in no way is it the same as a completed book.

In English major terms, basically Oracle is trying to say they copyrighted iambic pentameter, therefore Robert Frost violated their copyright by writing “The Mending Wall”.

In Business major terms, Oracle copyrighted the one-dollar bill’s design, therefore strippers violated their copyright by using them in their performance.

In Political Science major terms, Oracle copyrighted ballots, therefore politicians violated their copyright by using their system to get elected.

In Law major terms, well, I’m not going to even bother. Clearly lawyers can’t understand the concept in the first place, so why waste the effort?

Anonymous Coward says:

Go ahead. Copyright your APIs. And when the cost of your program prices you out of the market, we will replace you with a company who knows how to intelligently do business.
When you’re done suing your customers out of existence for simply using the software for which they paid, you can go out of business, too.

An actual computer scientist says:

Both declaring code and implementing code ultimately perform the same practical function: They instruct a computer to work. The declaring code tells the computer to call up the implementing code…

This is fundamentally wrong. Code declarations are, by definition, not code. They don’t tell the *computer* to do anything; they instruct the compiler/interpreter/linker that a function looks a given way. This is the heart of an API; if you want behavior foo, give function bar arguments z. That says nothing about how function bar achieves behavior foo, and certainly doesn’t instruct the computer in any way, shape, or form. No code is involved. They most certainly don’t “call up the implementing code…”. You know what does? The program using the implementation.

That One Guy (profile) says:

A test of competency

You don’t let someone drive a vehicle without making sure they know how, you don’t let someone operate on someone without making sure they know what not to cut, so judges absolutely should not be allowed to issue judgements on subjects they have no idea about.

I’m not demanding that they become experts in every field, but at the very least they should be required to take a short course so they can at least understand the basics of what’s being presented to them before being allowed to rule on it, with the case being passed to another judge if they fail the required test of competency.

masquisieras says:

my understanding of the situation

Is that

The declaring code is copyrigthable but its use for compatibility reasons is fair use. So no doomsday problem.

The problem for Google is it wrote a java-like incompatible language with 2/3 java APi and 1/3 proprietary API and changed the opensource licence of the 2/3 of java API from GPL to a BSD license so no compatibility anywhere so no fair use defense.

Thomas A. FIne says:

We need better analogies

We need analogies for the non-programmers.

What if you used a dictionary copyright to prevent other people from speaking english? (That one might be a bit too broad.)

What if you copyrighted the names of all the chemicals, and then used that copyright to prevent people from using the actual chemicals in reactions?

What if you copyrighted the blueprint of a bolt, and then used that copyright to prevent the creation of compatible hardware?

Any other ideas?

Thomas A. FIne says:

Re: We need better analogies

[Yes, replying to my own comment]

This is the best analogy I can come up with. What if you used a copyright on math texts as a way of preventing people from writing their equations in your copyrighted format?

Math, like software, is a situation where the text IS the machinery, and maybe it’s familiar enough that people would get that. “No, you can’t call it cosine. And no you can’t use the plus sign as a symbol for addition”. etc.

jms says:

An analogy

Here’s a regular-world analogy. When you get into a car, you will find that the controls are generally arranged the same way. The steering wheel is in front of you. The gas pedal is on the floor on the far right. The break pedal is next to it. Turn the steering wheel clockwise and the car turns right, press the gas pedal to accelerate, etc. The arrangement of the controls is the API. It’s the way the user communicates with the car. To say that APIs are copyrightable would be like making it illegal for new car companies to use the same control operations as existing car companies. They might be required to reverse the gas pedal and brake pedal, or make the steering turn in the opposite direction. The driver would have to learn how the controls worked in each model car on the market. This is the sort of innovation-killing prospect facing computer programmers should APIs become copyrightable.

Add Your Comment

Your email address will not be published. Required fields are marked *

Have a Techdirt Account? Sign in now. Want one? Register here

Comment Options:

Make this the or (get credits or sign in to see balance) what's this?

What's this?

Techdirt community members with Techdirt Credits can spotlight a comment as either the "First Word" or "Last Word" on a particular comment thread. Credits can be purchased at the Techdirt Insider Shop »

Follow Techdirt

Techdirt Daily Newsletter

Techdirt Deals
Techdirt Insider Discord
The latest chatter on the Techdirt Insider Discord channel...