Hacker News Reader

Comment by segfaultbuserr | Hacker News Reader

Although Apache-2 is sometimes seen as a license-of-choice by major proprietary software companies like Google, the license itself is actually well-written. It explicitly offers a patent clause to protect contributors and distributors from patent lawsuits from the copyright holder. I found even RMS recommends using Apache-2 as a permissive license for minor programs that don't need copyleft. So unless you explicitly support BSD/ISC, perhaps you could give some consideration of using it as a license for your next program.

AFAIK, whether ISC/BSD/MIT style licenses offer a patent clause is still unsettled.

UPDATE: See JoshTriplett's post, Apache-2 has license compatibility issues that prevent some code reuse, now I think BSDplusPatent license instead of Apache-2 is a better idea for small programs.

View on HN

Apache 2.0 is not a great choice if you care about license compatibility, unless you include an exception as LLVM is doing here.

Another good choice is https://opensource.org/licenses/BSDplusPatent , which combines the 2-clause BSD license with the explicit patent clause from Apache 2.0. That gives you GPLv2-compatibility as well.

(Note that this is unrelated to the unfortunately similarly named license from Facebook, which is not a FOSS license.)

IMHO the license incompatibilty problem is rather minor:

Firstly, AFAIK all of the licenses that ALv2 is incompatible with are obsolete and superseded versions.

Secondly, the ALv2 is file-scoped, so you can typically combine a library licensed ALv2 and another one with an incompatible permissive or weak copyleft license.

In practice this means that you'll have a problem combining ALv2 with old versions of strong copyleft licenses, e.g., something licensed GPLv2-only.

This is certainly an issue to consider for a project like LLVM, but of lesser importance for the majority of smaller scoped libraries.

GPLv2 comes up reasonably often.

Thanks!

I was always searching for this license, but I had previously only found The Clear BSD License, the BSD license with a PATENTS-NOT-INCLUDED clause (oops), and the Universal Permissive License, which is a general permissive license WITH a patent clause, but too obscure to inspire confidence among other developers.

Now I'm going to recommends BSDplusPatent instead of Apache 2. Simply and clear.

FWIW, Apache2 has other really useful aspects such as being self executing. We looked at options very similar to BSD w/ a patents clause and they ended up being less good on several fronts. Of course, YMMV, this was specifically in the context of LLVM.

What does "self executing" mean in this context? I assume there is no JIT compiler embedded in the license right ;)

> being self executing

Please elaborate.

Why wasn't this used instead of Apache 2.0? Reads to me a much simpler while providing ( All ? ) the benefits of Apache 2.0?

What is it missing?

From having dealt with some legal departments in the past, the reason they like these licenses is that they create clarity. For them patents are an orthogonal issues. Having licenses that may or may not affect their own patents or any patents of their competitors is hugely important when considering whether to use particular software, whether to contribute to particular software, etc. At the minimum, it increases the workload for them and worst case there are all sort of things that suddenly have to be considered. Doing legal checks is super tedious.

My personal license choice at the moment is to dual-license my work under both MIT and Apache 2.0. This way the user can decide which license to use.

Personally, one of my favorite things about Apache 2.0 is the license doesn't include any references to the copyright holder or year, so the exact same license text can be used everywhere, so if you have 20 dependencies all covered by Apache 2.0 you only need 1 copy of the license text rather than 20 nearly-identical copies.

FWIW, we definitely looked at a dual-license style approach.

One thing that I keep pointing out is that the Apache provides a way for the license to be self-executing. This is really cool (although also one source of objections) and IMO super important for an Open Source project like LLVM. It avoids the need for us to force every person who ever posts a patch to sign a legal agreement before we incorporate the patch because the Apache license itself handles those kinds of issues.

Unfortunately, we wouldn't get that w/ a dual-license approach. And we would add a lot of complications due to the duality. =/

I didn't actually realize Apache 2.0 was "self-executing". That's pretty neat. My usual tactic is to just have a section in the README that says

> Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you shall be dual licensed as above, without any additional terms or conditions.

immediately after the section for the licenses, though I have no idea if this is remotely enforceable. Though it hardly matters, as while my libraries have users, they don't generally get pull requests.

FWIW, Microsoft used to prefer AL for its open source projects early on in its F/OSS forays (after experimenting with its own custom licenses), but has since moved to MIT as the default.

Reply on news.ycombinator.com