Replies

They are trying to get the judge to extend coverage to APIs which here-to-fore has ALWAYS been considered outside of copyright.

Say I have a website where people can log in and post comments, and I write a library that I port to both Windows and the major linuxes, and the function of the library is to allow people to make client applications that can reads items from my website and post comments to my website.

Here's the header file, myweb.h

/* (c) 2012 myco, inc. */

int myweb_login(char * userid, char * pwd);
char * myweb_get(int sessionid, int itemid);
int myweb_save(int sessionid, char * text);
int myweb_logout(int sessionid);

and I have a download that:

1) has the user accept the terms of a license or reject it
2) the terms say they can't modify it, reverse engineer it or use it in any derivative works, etc., they simply can link with it and call the functions from their compiled, end-user application programs, then they can sell those compiled programs or give them away, whichever they prefer. Open source licenses would be incompatible with this, because I'm not releasing my source, just the headers and library files.
3) if they accept, they can download
4) they download either a windows or linux shared library and the corresponding header .h files so they can compile and link with the library

then...

the header files are exactly the thing that is copyrighted.

Say I have 1,000 customers.

I want that copyright to avoid people (say Billy Bob) creating other libraries and distributing them widely, where they create a bunch of functions that rely on my functions and sell their library as an add-on to mine to tons of my customers. Even if they offer to pay me a royalty, I politely reject the offer.

Billy Bob is customer #46. All other 1,000 of my customers are using the software themselves. I have just enough hours in a day to support them; if they contact me with issues, I send them a debug version and diagnose the problem. If the latest and greatest will fix it, I tell them to download the latest headers, libraries and docs and recompile. If not, I fix the problem, include it in the latest and greatest and get them to download.

Billy Bob has 37,492 developer customers that use his library compiled in with their software. Billy Bob creates his own copy of myweb.h where he includes my code and adds his own and redistributes myweb.h to his customers with my library files, myweb.so, etc., along with his library file, billy.so, etc.

In my next release, I may make changes to my functions; say I add some parameters to existing functions.

Now all of Billy Bob's 37,492 customers who are using HIS library are calling ME and bashing ME on the internet saying my library doesn't work. But it's because Billy Bob called the new parameters everywhere in his code but his install wound up calling my old shared library instead of the new one.

Regardless of pay or no pay, copyright means I have right to control what copies are made of works that I create.

It certainly covers obvious ripoff copies where there was a trivial change made to an obvious copy, like this:

int my_web_login(char * userid, char * pwd);
char * my_web_get(int sessionid, int itemid);
int my_web_save(int sessionid, char * text);
int my_web_logout(int sessionid);

Why would we not want this type of work not protected, when another author could work on his own easily enough to make something like this:

handle * site_open(char * userid, char * pwd);
int site_find(handle * mysite, int thing_id);
int site_create(handle * mysite, char * text);
int site_add(handle * mysite, char * text);
int site_end(handle * mysite, char * text);
int site_close(handle * mysite);

Of course, my example code was very simple.

Everyone obviously should be allowed to create their own open/read/write/close type functions.

But if you take my simple example, and expand it to thousands of lines of code, there are tons of POSSIBLE ways to design a complex API.

And many programmers may some day desire to release and either give away or sell such an API and restrict who can do what with it.

Some developers may not care how their work is used, but many others may want to continue working on it and not want their API messed with by others.

While "cornering the market" on open/read/write/close is clearly not valid, if you or I have worked on hundreds of thousands of lines code for a development toolset that was built from scratch and licensed out, and someone else took our whole framework (against our licensing agreement) and wrote all the functions themselves as their own framework, then sold that as their own product without paying us according to the agreement, I think we'd be more than a little miffed.