> The CPL license requires all derivative works to be released under the
> same license. My impression is that programs written in Clojure Lisp
> are derivative works, and therefore cannot be closed source.
I don't see how. Although Clojure compiles source to bytecode
internally (as does Perl), its external profile is that of a
source-code interpreter (like Perl). So you'd deliver the CPLed
interpreter with the source code of your proprietary program, and
trust that the law's terrors suffice to keep your users from
spreading the source about. There are proprietary programs written
in Perl, for example.
This is completely different from ABCL, which can deliver classfiles
for external consumption. If that feature were to be added to Clojure,
you'd want a similar exception then.
GMail doesn't have rotating .sigs, but you can see mine at
I looked up the CPL when I found clojure, overall it looks like a nice
license, though it is GPL-incompatible (at least v2, not sure about
v3). I don't understand enough about how these laws work though. Could
I distribute a program written in Clojure under the GPL without
problems? At what point are the two entities a combined work and at
what point is one just running the other? Does it matter?
One possible interpretation: I can send you an entire Linux
distribution that happens to include Clojure, Perl, and some Clojure
scripts. Perl works without Clojure, so is not a derivative work and
can be distributed with Clojure under a separate license. The Clojure
scripts are separate modules, but with a clear dependency on Clojure,
so they are derivative works. The definition of "derivative" is not
clear to me.
I am pleased to hear that this is not your interpretation, and I am
content to accept your interpretation.
Don't worry about people stealing your ideas. If your ideas are any
good, you'll have to ram them down people's throats.
- Howard Aiken -
> The Clojure
> scripts are separate modules, but with a clear dependency on Clojure,
> so they are derivative works.
I repeat, works meant to be executed by an interpreter are not
derivative works of that interpreter, any more than code you edit with
Emacs is a derivative of Emacs -- the interpreted code is just
data that the interpreter processes.
Even code compiled with gcc is not a derivative of gcc,
although if a compiler-like program injects substantial parts
of itself into the output, the output may become entangled
with the license. (This used to be true of GNU bison, but
a license exception was written for it.)
> The definition of "derivative" is not clear to me.
It depends on your local copyright law, but in the U.S. it means
a transfomation of the original work by translating, adapting,
adding or removing material, etc. Writing code in Clojure
doesn't create a fork of Clojure, far from it.