The state of software licenses makes me a bit sad. On the one hand we have open source licenses like the MIT and Apache 2.0 licenses that give corporations free reign to enclose and exploit the software commons without any real limit or any requirement to give back to the things they are getting rich off of, and then on the other hand we have the GPL and LGPL licenses which are too aggressive and stringent, while also being somewhat vague — see for instance the almost superstitious fear companies have about using LGPL code even when it would probably be fine — which means that almost no one ends up using those licenses, because companies are too afraid to use software that is licensed under them (and therefore wouldn't be invested in them at all, which means they give back to those projects even less than they do for projects under open source licenses) and because even FLOSS developers just don't want to deal with the dependency headaches of using GPL code. Which in turn ironically means that, despite being designed to very aggressively protect and help the software commons, the GPL and LGPL licenses end up doing worse for the software commons then open source licenses do, in general, because no one uses them or invests in them in the first place, and of course there are going to be fewer contributions to the software commons from a license that is never used or invested in then there are going to be from a license that is widely used and deeply invested in but has fewer requirements, because it's a matter of percentages essentially. So in essence both licenses fail to do what at least I feel like they should ideally do, although for opposite reasons.

Ultimately, I think this stems from the fact that Open Source licenses were explicitly created by people who wanted to be friendly to corporations, and the GPL licenses were created by the FSF, who are essentially the vegans of software. So I think in the long run what we need is a free software movement that is detached from both the dogmatism and absolutism of the Free Software Foundation and the desire to suck up with corporations. A movement that perhaps sees itself as being a check on the balance of corporations in the software world, but in a more pragmatic way.

I think the sort of license a movement like that might produce might end up looking something like the MPL 2.0: it allows combined works that use the existing code in any way they want, while requiring changes or improvements to the existing code to be shared back to the community, so that there is a clear requirement to give back to the things you benefited from, without trying to also take away the things you or your team wrote themselves.

This is similar to the LGPL, but unlike that license the basic unit of separation is clearer: files. Original source code files and any files containing substantial portions of code copied from the original source code are considered part of the original work, and therefore something to which changes must be contributed back to the community, but anything outside those files can stay proprietary. This is a lot clearer and more flexible than the LGPL, meaning developers from FOSS and from corporations can use code under the without headaches, while still not allowing companies to just completely free ride on the things the software community makes, and we get to have both because unlike the LGPL the MPL is willing to sacrifice some stringency and control in return for those benefits.

Additionally, and perhaps more importantly, it doesn't have particularly onerous source distribution requirements or requirements to distribute your own application as object code or provide some other way for users to swap out the version of the free software code that's being used, which likewise does sacrifice some FSF purity, but in return for a massive decrease in the complexity, onerousness, and annoyingness of the license requirements as a whole. So yeah, the MPL isn't perfect — maybe the ideal free software license would be the LGPL with just clearer specification of where the boundaries are between the LGPL code and the proprietary code, and no annoying object code or dynamic linking requirements — but it's a lot closer to where I think we need to move with licenses. I don't think zero clause open source licenses are the way.