James’s Musings

thoughts, photography, and geeky stuff
from an unrelentingly curious Silicon Valley entrepreneur

About those APIs–Do You Believe Me Now?!

by James G. Beldock on July 8, 2012

Last mon­th, I post­ed what turned out to be the most pop­u­lar post I’ve writ­ten in years about a top­ic many peo­ple would con­sid­er not too ter­ri­bly fas­ci­nat­ing (or there­fore too ter­ri­bly pop­u­lar!): APIs, or Application Programming Interfaces, the ma­chine-to-ma­chine con­nec­tion pro­to­cols used by one piece of soft­ware to talk to an­oth­er. “It’s the API, Stupid! Or How to Crowdsource Your App Ecosystem” turned out to be both pop­u­lar and some­what pre­dic­tive of lat­er events. In short or­der the tech uni­verse brought us a se­ries of com­plete­ly con­tra­dic­to­ry de­vel­op­ment in API World, but I was dis­tract­ed with the birth of my sec­ond child, so here we are, a mon­th or so lat­er, catch­ing up.

First, the big API news (un­til Friday of last week): Oracle v. Google, in which Oracle, the ac­quir­er of the Sun’s Java in­tel­lec­tu­al prop­er­ty in­clud­ing its copy­rights and patents, con­tend­ed that Google’s im­ple­men­ta­tion of func­tion­al­i­ty com­pat­i­ble with the Java APIs con­sti­tut­ed (a) patent in­fringe­ment; (b) copy­right in­fringe­ment; or (c) both. The tech world should be grate­ful that it was Judge Alsup, a pro­gram­mer, Harvard Law School (and Kennedy School) grad, and erst­while clerk to a US Supreme Court Justice William Douglas, who presid­ed over the case. We’re for­tu­nate both be­causqe Judge Alsup had enough savvy to let the ju­ry reach a ver­dict on copy­right in­fringe­ment and be­cause he then (af­ter al­low­ing the ju­ry to re­turn a ver­dict) had enough do­main knowl­edge to rule the APIs were not copy­rightable in the first place:

So long as the speci­fic code used to im­ple­ment a method is dif­fer­ent, any­one is free un­der the Copyright Act to write his or her own code to car­ry out ex­act­ly the same func­tion or spec­i­fi­ca­tion of any meth­ods used in the Java API. It does not mat­ter that the de­c­la­ra­tion or method head­er lines are iden­ti­cal.

Under the rules of Java, they must be iden­ti­cal to de­clare a method spec­i­fy­ing the same func­tion­al­i­ty — even when the im­ple­men­ta­tion is dif­fer­ent. When there is on­ly one way to ex­press an idea or func­tion, then every­one is free to do so and no one can mo­nop­o­lize that ex­pres­sion. And, while the Android method and class names could have been dif­fer­ent from the names of their coun­ter­parts in Java and still have worked, copy­right pro­tec­tion nev­er ex­tends to names or short phras­es as a mat­ter of law. (( Order Re: Copyrightability of Certain Replicated Elements of the Java Application Programming Interface, Case 3: 10-cv-03561-WHA, doc­u­ment 1202, filed May 31, 2012. ))

Judge Alsup has drawn the bright line be­tween com­pat­i­bil­i­ty and du­pli­ca­tion around which the in­dus­try has been tip­toe­ing for years. Writing soft­ware that works with some­one else’s soft­ware? Always been per­fect­ly fine. Writing soft­ware that mim­ics the be­hav­ior of some­one else’s soft­ware? Fine, so long as you don’t copy their im­ple­men­ta­tion, as con­firmed by Judge Alsup. Translation: open mar­ket for com­pe­ti­tion.

…un­til you have to ac­tu­al­ly use someone’s API, as wit­ness last week’s big Twitter dus­tup. Twitter con­tin­ues to ratch­et down the ac­cept­able us­es of their API, and in­stead of lit­i­gat­ing, they’re sim­ply cut­ting off users whose im­ple­men­ta­tions they ei­ther don’t like or have grown beyond–including, no­tably, LinkedIn’s, as they be­came ev­i­dent last Friday. This isn’t the first time Twitter has tak­en aim at the de­vel­op­ers who have cre­at­ed its much-vaunt­ed app ecosys­tem. Just a year ago, Twitter spent $40 mil­lion to ac­quire Tweetdeck, de­vel­oped of an ex­cel­lent (and epony­mous) Twitter client, and in the process overt­ly di­rect­ed de­vel­op­ers not to at­tempt to com­pete with them on client ap­pli­ca­tions. They didn’t turn any­one off that time, but they cer­tain­ly be­gan to put a fence around their API. The most re­cent changes Twitter made came with more wood be­hind the bat: they turned off their part­ner­ship with LinkedIn on what ap­peared to be pret­ty short notice–thus fur­ther en­trench­ing their po­si­tion that they would con­trol their API at all costs, in­clud­ing some bad press.

It seems the Cloudiverse an­tic­i­pat­ed Judge Alsup’s rul­ing by giv­ing API own­ers the ul­ti­mate trump card: the pow­er to shut off users whose ac­tiv­i­ties they dis­agree with. If those users are in­di­vid­u­als, there is cer­tain­ly no re­course. If they are larg­er com­pa­nies…there is still no re­course. Possession re­mains nine tenths of the law–es­pe­cial­ly when your API acts as the gate­way to your plat­form, and you pos­sess both. Twitter isn’t the on­ly tech tabloid star to tus­sle about APIs re­cent­ly: just yes­ter­day, word got out that Facebook was shut­ting down the APIs they had promised to sup­port when face.com an­nounced it was be­ing ac­quired by Facebook in June. The Twitterverse was rapid­ly filled with de­vel­op­ers fac­ing API-apoc­a­lypse:

So Judge Alsup loos­es the dogs of com­pe­ti­tion and the Cloudiverse re­sponds with its own, pos­ses­sion-trumps-all re­but­tal. These are in­ter­est­ing times in­deed to ob­serve the API World. Enjoy–and pass the pop­corn, please.

Be Sociable, Share!

Comments on this entry are closed.

Previous post:

Next post: