As for relicensing:
Both MIT and Apache require copyright notices be reproduced when you ship binaries.
I'll assume MIT since it is the more permissive (Apache also requires you give the user a copy of the license, etc).
Rust is statically linked by default, IIRC (and even shared linking often ends up with some runtime code statically linked in).
If Rust binaries include parts of the MIT code by default (I haven't looked at how the runtime and ABI support is structured), then anyone who ships those binaries would be required to reproduce the copyright notice somewhere.
You cannot take this code and relicense it at will, actually. But you can achieve the same practical effect as relicensing, as long as you reproduce the notice, so i won't get into it unless you really want me to :)
(But note that reproducing the notice is exactly the issue for runtime libraries, and without CLA's in place, you would hav to go and ask all contributors who have ever contributed to the runtime libraries in order to be able to remove that notice reproduction requirement)
> If Rust binaries include parts of the MIT code by default
> (I haven't looked at how the runtime and ABI support is
> structured), then anyone who ships those binaries would
> be required to reproduce the copyright notice somewhere.
"In addition to the UIUC license, the runtime library components of LLVM (compiler_rt, libc++, and libclc) are also licensed under the MIT License, which does not contain the binary redistribution clause. As a user of these runtime libraries, it means that you can choose to use the code under either license (and thus don’t need the binary redistribution clause), and as a contributor to the code that you agree that any contributions to these libraries be licensed under both licenses. We feel that this is important for runtime libraries, because they are implicitly linked into applications and therefore should not subject those applications to the binary redistribution clause."
The "binary redistribution clause" referenced from the UIUC license (http://opensource.org/licenses/UoI-NCSA.php) reads as follows:
"Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimers in the documentation and/or other materials provided with the distribution."
Given that it seems that LLVM chose MIT specifically to sidestep any need for end users to distribute licenses with binaries compiled via LLVM, I'd be curious to know where the discrepancy here is.
Basically, we messed up when we changed the runtime license (I said MIT license when I meant zlib license, which only requires reproduction of notices in the source code), and had to issue a policy statement on the license to make people happy.
It is not accurate, legally, in its description of the MIT license. Effectively, by this statement, we are giving permission to not reproduce the notice, even though the license would actually require it.
You don't have to take my word for it though, ask any other open source lawyer whether MIT requires notice reproduction for binaries.
I would urge Rust not to make the same mistake.
(This mistake is currently being fixed in a few other "new" languages, in fact)
I'm guessing you can't go giving out concrete legal advice for free, but could you point us towards languages that are fixing this? I see that Julia's stdlib uses MIT for non-external libraries, and Go uses a BSD-style license that explicitly requires distributing the license with binaries, so they're both in the same boat we are. AFAICT D's stdlib uses the Boost license which explicitly allows one to forgo distributing the license with compiled artifacts, but I don't know if solving this issue entirely would require the entire compiler to be licensed under Boost as well. Presuming that interpreted languages can gracefully ignore this issue, I don't know which other "new" languages we could look at for inspiration.
Please note that kibwen is not part of the core Rust team.
If you don't fix this, you end up with two situations:
1. You accidentally create copyright infringers out of a lot of folks, because the number of people who will properly reproduce the license with static binaries is small.
2. Because of #1, you expose folks to a bunch of liability they weren't expecting.
Neither is a great thing to do to your users.
Combined with the fact that you don't have CLA's that grant you explicit sublicensing rights, anyone who contributes could go off and easily have a sane case against someone for not reproducing the notice. Statutory damages for copyright infringement are up to 150k in the US, sadly.
Anyway, as for other languages, this is being fixed for Go's runtime bits (and possibly stdlib), which i can talk about, but it's not really my secret to share in the case of the other languages I know about fixing it.
> Anyway, as for other languages, this is being fixed for
> Go's runtime bits (and possibly stdlib), which i can talk