Hello,
I'm trying to understand the conditions for an extension to an MPL covered
work to comply with what is called a "larger work". I guess I'm missing some
theoretical background on programming techniques, so this question might
appear a little weird, but then maybe not, well, here it is:
>From reading the MPL (1.3 covered code + 1.9 modifications) I understand a
new file which doesn't contain any original code is not "covered code" and
may be kept proprietary to form a "larger work", right?
So I imagine this new file may e.g. contain some new functions and I could
add some lines in the "covered code", with call to those functions. Is that
right so far?
The MPL doesn't use the term API to specify what is covered code and what's
a larger work. However, the Netscape whitepaper uses the term API in this
context, as follows:
http://home.netscape.com/browsers/future/whitepaper.html
[quote]... if a developer wants to add functionality to Communicator and not
make its source code to that modification openly available, then the
developer can do so by adding that functionality through an API.[/quote]
Also some other authors refer to APIs when talking about the MPL. Rosenberg
does, but maybe the best explanation I found in Hecker Frank, Setting Up
Shop:
http://www.hecker.org/writings/setting-up-shop.html
[quote]Thus an open-source product... may be extended with proprietary
code... as long as the proprietary code is separate and interacts with the
open-source code using a defined API. [snip] If the enabling code for the
API is not already in the open-source product then the changes to the
open-source product to create the API fall under the MozPL...[/quote]
Now, maybe my question boils down to "what is an API?". I found a definition
on the site of CMU (http://www.sei.cmu.edu/str/descriptions/api_body.html)
but from that I understand an API more like an interface for binary level
communication between two independent executables (Remote Procedure Calls
etc.). That's the thing I thaught it was: stuff like an application using an
API for interaction with the OS etc.
However, the MPL draws the line between the covered code and a proprietary
extension at source code level, and the two are compiled into one binary
file. So what does this mean that an API in the covered code is required? Is
this an API, if I insert into covered code a call to a function which I have
implemented in a new, separate file? I would have expected a programming
interface to be more something like a set of functions to be used for
interaction, and not just a function call... Also the figure 2 in the
Netscape whitepaper, which shows the API as a separate "block of things",
seems to suggest that there is more to an API than just a function call.
Now I just hope someone understands what I'm asking, despite my artistic
language ;)
Markus
