> I'm not aware of any Open Source license,or Free license for that matter,that has a give-back clause. Source code is available to -users- ,not prior-authors.
In essence, copyleft licenses are exactly that. They oblige the author of a derived work to publish the changes to all users under the same terms. The original authors tend to be users. So, a license which would grant this directly to the original authors would end up providing the same end result since the original authors would be both allowed to and reasonably expected to distribute the derived work to their users as well.
This aligns with the reason why some people publish their work under copyleft licenses: You get my work, for free, and the deal is that if you find and fix bugs then I get to benefit from those fixes by them flowing back to me. Obviously as long as you only use them privately you are not obliged to anything, the copyleft author gives you that option, but once you publish any of this, we all share the results.
That's the spirit here and trying to argue around that with technicalities is disingenuous. That's what Copilot does since it ignores this deal.
All this Free Software movement started by something really similar to "right to repair", a firmware bug in a printer that was proprietary software.
Free Software is about being in control of software you use. The spirit was never "contribute back to GNU", the spirit was always "if you take GNU software, you can't make it non-free". Those GNU devs at the time just wanted a good and actually free/libre OS, that would remain free no matter who distributed it.
You are using expectations of modern day devs in the world of a lot of social development thanks to Github.
You might claim that GP was using the technicalities of the licences, but you can actually check the whole FSF philosophy an you note that they align perfectly with "giving forward" not "giving back".
Free Software is about user's freedom. Not dev rights, or politeness, etc.
Now obviously, some devs picked up copyleft licenses with the purpose of improving their own software from downstream changes (Linus states that is the reason he picked GPL), but that's a nice side effect, not the purpose. Which ofc, with popular social sharing platforms like github, those things gets confused.
> All this Free Software movement started by something really similar to "right to repair", a firmware bug in a printer that was proprietary software. Free Software is about being in control of software you use. The spirit was never "contribute back to GNU", the spirit was always "if you take GNU software, you can't make it non-free". Those GNU devs at the time just wanted a good and actually free/libre OS, that would remain free no matter who distributed it.
Distinction without a difference. The end result is the same.
GPL software is a box that must be kept open, so that everybody would be able to take from it.
If you pick the box and build an altered version of it, you must keep it open, you are legally prohibited from attaching a lid to it.
There's nothing about any expectations, let alone obligations, to put anything back into the original box. Usually it's not very easy (you must follow strict standards) or even impossible (see e.g. SQLite).
It is a pretty big distinction with different end results in practice. Look at Android, you can use the source in a "right to repair" manner but Google doesn't take patches so you can't give back even if you wanted to.
The same goes for Apple and Google's OSS browser. The source is there, but there is more or less no way to give back, and they certainly don't.
> Look at Android, you can use the source in a "right to repair" manner but Google doesn't take patches so you can't give back even if you wanted to.
Well, license obliging the original author to take patches back would be weird one.
But Google could suck in any change to their own and make it better.
> The same goes for Apple and Google's OSS browser. The source is there, but there is more or less no way to give back, and they certainly don't.
That's a different problem that's a bit orthogonal to licensing and has more to do with project leadership. Like, you don't even need to have OSS license to allow users to contribute to project.
The four freedoms[1] of free software specifically state that:
> The freedom to distribute copies of your modified versions to others (freedom 3). By doing this you can give the whole community a chance to benefit from your changes. Access to the source code is a precondition for this.
Emphasis in "give the whole community a chance to benefit from your changes".
I'm not sure I agree with this as a general point of view.
Speaking generally, I'm not sure that one can claim
>> The original authors tend to be the users
There are endless forks of say emacs,and I expect RMS is not s user of any of them.
Of course RMS is free to inspect the code for all of them, separate out bug fixes from features, and retro apply it to his build. But I'm not seeing anything in any license that requires a fork to "push" bug fixes to him.
>> This aligns with the reason why some people publish their work under copyleft licenses: You get my work, for free, and the deal is that if you find and fix bugs then I get to benefit from those fixes by them flowing back to me.
I think you are reading terms into the license that simply don't exist. I agree a lot of programmers -believe- this is how Free Software works, and many do push bug fixes upstream, but that's orthogonal to Free Software principles, and outside the terms of the license.
>> That's the spirit here and trying to argue around that with technicalities is disingenuous.
Licenses are matters of law, not spirit. The original post is about this "spirit". My thesis is that he, and you, are inferring responsibilities that are simply not in the license. This isn't a technicality,it goes to the very heart of Free Software.
But also, i think even the spirit of the original copyleft movement is being misunderstood. As a GP said, the spirit was about centering users, requiring developers to be responsible to _users_, in order to create the kind of society where our _use_ of technology would be unconstrained in certain ways.
It was not about anything owed to the "original" developers, it was not about developers responsibility to other developers. In original spirit, even. It was definitely not about creating a system where people could make adequate income from writing software. That was not even the spirit in which the licenses were devised.
(To be fair, it also imagined/hoped that a large portion of (but not all) users could also be "developers" in the sense they could tweak software to meet their needs -- for their own and others use, though, not for money. Even if users would be coding, the "spirit" still centered them as users, and centered the conditions of use, their needs and desires for how that software would work, not conditions of profit or income from charging people for software use).
Most people don't actually want to maintain a fork. They would prefer that their patches are mainlined.
Consider Linux. It's huge and most vendors really don't want to maintain a fully independent fork. One reason they might do it anyway, is if they could keep their patches private. But the GPL means they can't, so most just choose to upstream patches.
> Most people don't actually want to maintain a fork. They would prefer that their patches are mainlined.
But that's a downstream decision regarding efficiency in their developing process.
That's not what free software is about, there is nothing about that in its principles nor licences.
That's just Development Process and maintenance decision, offloading patch integration to upstream, which they might or not accept depending on your changes. None of that is about Free Software. You can see similar decisions/trade-offs taking place in any org with multiple software dev teams with ownership over libs etc, regardless if it is free software or not.
It's like everyone here is a lawyer nitpicking the license as it exists today. But absolutely before the licenses existed Open Source was about those principles, to share code, to share bug fixes, to publish any improvements. So everyone would get better. To say the 'license' doesn't make this explicit it really missing the point.
You'd think so, but there's also a good chunk of copyleft code that's just "here's our source code, go figure out how to deploy lol".
You can try to fork it into something workable, but that can sometimes literally mean trying to figure out what the actual deployment process is and what weird tweaks were done to the deploying device beforehand. In addition, forking those projects is also unworkable if the original has pretty much enterprise-speed development. At best you get a fork that's years out of date where the maintainer is nitpicking every PR and is burnt out enough to not make it worthwhile to merge upstream patches. At worst, you get something like Iceweasel[0] where someone just releases patches rather than a full fork (and having done that a few times, it's a pain in the neck to maintain those patches).
FOSS isn't at all inherently community-minded; it can be and can facilitate it, but it can also be used as a way to get cheap cred from the people who are naïeve enough to believe the former is the only place it applies.
[0]: "Fork" of Firefox LTS by the GNU Foundation to strip out trademarked names and logo's. It's probably one of their silliest projects in term of relevancy.
People do release software as open source for the "street cred" (perhaps unsurprisingly given the school of thought that you don't deserve a developer job if you can't show off a GitHub repo). A lot of people also create something and figure "why not?" They may just not be interested in doing any serious community development and maintenance. There are even significant open source projects that are pretty much a closed development process.
> They oblige the author of a derived work to publish the changes to all users under the same terms. The original authors tend to be users. So, a license which would grant this directly to the original authors would end up providing the same end result since the original authors would be both allowed to and reasonably expected to distribute the derived work to their users as well.
I might be in the wrong, but this is not how I understand GPL [0]. Care to correct me if I'm wrong.
What I get from the license is that you have to share the code with the users of your program, not anyone else.
AFAIK you could do an Emacs fork and ask money for it. Not only that but the source code only needs to be available to the recipients of the software, not anyone else.
A company could have an upgraded version of a GPL tool and not share it with anyone outside the company. Theoretically employees might share the code outside, but I doubt they'd dared.
> What I get from the license is that you have to share the code with the users of your program, not anyone else.
You're correct, but it's sort of a meaningless distinction because those users are entirely within their rights under the GPL to share that code on with anyone they want, which is why we don't really see the model of "secret GPL" you describe, in the wild.
I'd argue that this is exactly what you see in the wild. And it's why the AGPL license was created.
GPL code has to be shared with users who receive binaries. SAAS happily didn't shop binaries, so quite legally didn't ship source code.
AGPL redefines this in terms of "user" not "binary". That refinement completely exists to cater for unexpected use cases. No doubt new licenses (AIGPL?) will be needed to address this issue.
The whole need for Open Source protection played out with the (Apache licensed) Elastic Search. Switching to a ELv2 and SSPL license was controversial and in some ways "not open source", certainly not "free" because it limits what a user can do with the software.
So the distinction is far from meaningless and in some ways rendered GPL obsolete.
> That's the spirit here and trying to argue around that with technicalities is disingenuous.
First, I am not a lawyer, but don't licenses exist precisely for their technicalities? This is not like a law on the books in which case we can consider the "Letter and Spirit of the law" because we know in what context in which it was written in/for. With a written license however, someone chooses to adopt a license and accepts those terms from an authorship point-of-view.
Exactly. We all benefit from sharing contributions to the same code base. I use your library, you use mine, we fix each others bugs, add features, etc... The code gets better.
In essence, copyleft licenses are exactly that. They oblige the author of a derived work to publish the changes to all users under the same terms. The original authors tend to be users. So, a license which would grant this directly to the original authors would end up providing the same end result since the original authors would be both allowed to and reasonably expected to distribute the derived work to their users as well.
This aligns with the reason why some people publish their work under copyleft licenses: You get my work, for free, and the deal is that if you find and fix bugs then I get to benefit from those fixes by them flowing back to me. Obviously as long as you only use them privately you are not obliged to anything, the copyleft author gives you that option, but once you publish any of this, we all share the results.
That's the spirit here and trying to argue around that with technicalities is disingenuous. That's what Copilot does since it ignores this deal.