I would understand if Canonical want a new cow to milk, but why are developers even agreeing to this? Are they out of their minds?? Do they actually want companies to steal their code? Or is this some reverse-uno move I don’t see yet? I cannot fathom any FOSS project not using the AGPL anymore. It’s like they’re painting their faces with “here, take my stuff and don’t contribute anything back, that’s totally fine”
The unfortunate reality is that a significant proportion of software engineers (and other IT folks) are either laissez-faire “libertarians” who are ideologically opposed to the restrictions in the GPL, or “apolitical” tech-bros who are mostly just interested in their six figure paychecks and fancy toys.
To these folks, the MIT/BSD licenses have fewer restrictions, and are therefore more free, and are therefore more better.
Add to this, the constant badmouthing of GNU and FSF from the crony bootlickers and sadly this is what we get
The tech crowd is also more of a consumer kind these days than the hacky kind, so it’s much easier to push corporate shite with a little bit of polish on top
Yeah, that’s all there’s to it, along with pure ignorance. In a past not so ideologically developed life, I’ve written code under Apache 2 because it was “more free.” Understanding licenses, their implications, the ideologies behind them and their socioeconomic effects isn’t trivial. People certainly aren’t born educated in those, and often they reach for the code editor before that.
“apolitical” tech-bros who are mostly just interested in their six figure paychecks and fancy toys.
This, I understand.
laissez-faire “libertarians” who are ideologically opposed to the restrictions in the GPL
This, I do not. Apologies for my tone in the next paragraph but I’m really pissed off (not directed at you):
WHAT RESTRICTIONS??? IF YOU LOT HAD EVEN A SHRED OF SYMPATHY FOR THE COMMUNITY YOU WOULD HAVE BOYCOTTED THE MIT AND APACHE LICENSE BY NOW. THIS IS EQUIVALENT TO HANDING CORPORATIONS YOUR WORK AND BEGGING THEM TO SCREW OVER YOUR WORK AND THE FOSS COMMUNITY.
I feel a bit better but not by much. This makes me vomit.
I write code for a living. I cannot, by any means, utilize a GPL library to support the needs of our customers and will either have to write my own replacement or dig to find something with less restrictions like MIT.
On many occasions, we will find bugs or usage gaps or slowdowns that can get pushed back to the MIT licensed open source cause we were able to use it in the first place. If your goal is to make sure your library gets used and gets external contributors, I don’t see how GPL helps the situation as it limits what developers can even choose your library in the first place. If your goal is spreading the ideology that all software should be free, go keep banging your drum for GPL.
I work in a company that deals with both commercial and government (military) software. The government is becoming more and more fixated on the software supply chain, or sw dependencies so to speak.
Existing dependencies are largely getting a pass for now, but with each new one I need to give a justification for. This includes the license of that software. I can’t use GPL at work.
Thank you for your work. If people like you were all around us, then I wouldn’t mind as much projects using MIT since we would still see contributions. But I doubt there’s that many people out there like you. Thank you for contributing to FOSS.
Like 80% of the top 10 most contributed libraries on github are either MIT, Apache, or BSD. I think you underestimate how many corpo folks do contribute or wholly support open source libraries.
Since you seem so reasonable…
The restriction that some people object to is that the GPL restricts the freedom of the software developers (the people actually writing and contributing the code).
Most people would agree at first glance that developers should be able to license code that they write under whatever license they like. MIT is one option. Some prefer the GPL. Most see the right to choose a proprietary license for your own work as ok but some people describe this as unethical. I personally see all three as valid. I certainly think the GPL should be one of the options.
That said, if we are talking about code that already exists, the GPL restricts freedom without adding any that MIT does not also provide.
MIT licensed software is “free software” by definition. Once something has been MIT licensed, it is Open Source and cannot be taken away.
The MIT license provides all of the Free Software Foundations “4 freedoms”. It also provides freedoms that the GPL does not.
What the MIT license does not provide is guaranteed access to “future” code that has not yet been written. That is, in an MIT licensed code base, you can add new code that is not free. In a GPL code base, this is not possible.
So, the GPL removes rights from the developers in that it removes the right to license future code contributions as you want. Under the GPL, the right of users to get future code for free is greater than the right of the developer to license their future contributions. Some people do not see that as a freedom. Some even see it as quite the opposite (forced servitude). This “freedom” is not one of the “4 freedoms” touted by the FSF but it is the main feature of the GPL.
What freedom in the sense of writing code does the GPL inhibit? GPL simply says that changes to the source must be published. MIT is just a scapegoat for companies to get stuff for free without helping the developer that’s giving their time and soul for it
developers should be able to license code that they write under whatever license they like
What if they choose a license that limits the freedom from all other developers to improve that copy of the software? is allowing a developer to restrict further development actually good for the freedom of the developers? Because I would say no.
The spirit of the GPL is to give freedom to the developers and hackers (in the good sense of hacker). The chorus of the Free Software Song by Stallman is “you’ll be free hackers, you’ll be free”.
the GPL restricts freedom without adding any that MIT does not also provide
“Your freedom ends when the freedom of others begins”
The only “freedom” the GPL restricts is the freedom to limit the freedom of other developers/hackers that want to edit the software you distribute. This is in the same spirit as having laws against slavery that restrict the “freedom” of people to take slaves.
Would a society that allows oppression (that has no laws against it) be more “free” than a society that does not allow oppression (with laws to guarantee the freedom of others is respected)?
fyi: GNU coreutils are licensed GPL, not AGPL.
there is so much other confusion in this thread, i can’t even 🤦
If you’re developing software for a platform that doesn’t allow users to replace dynamic libraries (game consoles, iOS, many embedded/commercial systems), you won’t be able to legally use any GPL or AGPL libraries.
While I strongly agree with the motives behind copyleft licenses, I personally never use them because I’ve had many occasions where I was unable to use any available library for a specific task because they all had incompatible licenses.
I release code for the sole purpose of allowing others to use it. I don’t want to impose any restrictions on my fellow developers, because I understand the struggle it can bring.
Even for desktop programs, I prefer MIT or BSD because it allows others to take snippets of code without needing to re-license anything.
Yes I understand that means anyone can make a closed-source fork, but that doesn’t bother me.
If I wanted to sell it I might care, but I would have used a different license for a commercial project anyway.Sorry, I’m not much of a software dev so bear with me:
If the libraries are GPL licensed, is there a problem? Unless you’re editing the libraries themselves.
Now if the application is GPL licensed and you’re adding functionality to use other libraries, please push upstream. It helps the community and the author will more likely than not be happy to receive it
Using a GPL library will require you to re-license your entire project as GPL, regardless of whether you made a change or not.
LGPL is a bit better, because it allows you to dynamically link the library. But you’re required to provide a copy of source for the library, and any users must be able to swap the built library with their own copy.
Eg; you can use an AGPL-licensed .dll in your closed-source windows program, because users can swap that .dll easily.
You can’t do the same for a ps5 game because users aren’t able to replace any files that the game uses.
If the only problem is that you can’t use dynamic linking (or otherwise make relinking possible), you still can legally use LGPL libraries. As long as you license the project using that library as GPL or LGPL as well.
However, those platforms tend to be a problem for GPL in other ways. GPL has long been known to conflict with Apple’s App Store and similar services, for example, because the GPL forbids imposing extra limits that restrict user freedom and those stores have a terms of service that does exactly that.
I guess I forgot to mention that those platforms usually require you to sign NDA’s that prevent you from releasing any code that references their SDK.
This makes it impossible to license your entire project as GPL/AGPL, as you would be breaking the NDA.
Its simple: its to exploit it in a corporate setting. I license under MIT because a lot of my things are of small convenience, but never without debating the ethics of why I am licensing it.
GNU is the enemy to capitalism and if you need more proof, look at what Apple has done with LLVM/Clang and CUPS. We need GNU more than ever.
I understand that if your boss tells you to write MIT/Proprietary code, you do so. I just wish that the ones who had a choice would use GPL
The author explicitly states that this is not the reason.
https://github.com/uutils/coreutils/discussions/4358#discussioncomment-8027681
For me, my personal projects are generally MIT licensed. I generally don’t like “restrictions” on licenses, even if those “restrictions” are requiring others to provide their source and I want as many people to use my projects as possible, I don’t like to restrict who uses it, even if it’s just small/home businesses who don’t want to publish the updated source code. Although, I admit, I’m not a huge fan of large corporations potentially using my code to generate a profit and do evil things with it, but I also think that’s not going to be very common versus the amount of use others could get from it by having it using MIT who might not be able to use it otherwise with AGPL.
With that said, though, I have been starting to come around more to AGPL these days.
I wohld agree, because you really downplay the scenario.
As soon as you accidentallt create something, which everyone starts to use or has an use case, then some Cooperation will copy that thing, make it better and make your community dissappear because there is the newer tool which you cant change the code of anymore and need to use a monthly subscription or something to even use.
So, it somehow seems like you’re gaslighting yourself by downplaying the use case.
Mostly it will be small buisnesses and hobbyists, which I would like to code for them too. Especially when they are nice and friendly. But as soon as Microsoft, Google, Meta, Amazon gets hands on it and sees a potential to squeeze money through it by destroying it, then they will surely do it.
I edited my comment to better and more fully reflect my thoughts. It’s hard to properly express myself when I’ve been as sick as I have been with bronchitis and possible pneumonia for the past 4 weeks.
Hopefully my comment now better reflects my thoughts.
I still feel like, the point where you say more people can use it and will use it, can create a dark pattern.
Imagine you create something and make people depending on it. Another cooperation copies it and advances it with a lot of money. Somehow, the ecosystem is so changed, that when you depend on that project, you need to use the newer version of the cooperation and soon they will paywall it heavily.
Then, your wish for people using the code as much as possible got nuked.
I assume that many scenarios will allow the usage of your old MIT project without relying on the new version of someone. But rare cases exist, where this happens. Its like predicting the 30th step in chess or smth. (Idk chess that well)
Its… unlikely that it will happen, but yeah. I can understand your perspective, but slowly going to AGPL sounds right.
Had bronchitis as a child nearly every few weeks for years. All gone but sucks to have it.
Get well soon.
Here’s a fun idea, let’s fork these MIT-based projects and licence them under the AGPL :-)
You could do that. MIT is a very free license.
Of course, that would only be a useful thing to do if you were also going to contribute to the code.
True, but the mere existence of an AGPL project that follows the MIT one might be enough to convince would-be contributors to choose our version instead.
It may also be more likely to be adopted by non-corporate Linux distros that favour the AGPL over MIT (Debian for example) which in turn could help make the AGPL version the dominant one.
Note that AGPL can take changes from MIT but MIT can’t take changes that are purely AGPL without following the AGPL.
So, as far as I can understand, any improvements done to the AGPL version cannot be carried over to the MIT version (without very painful and careful re-implementation / re-engineering). That alone would be a big advantage to the hypothetical AGPL fork.
It would be a bit of a legal nightmare, since it’s theoretically possible that, even without really knowing it, the same feature might be implemented the same way in both forks separately, and the MIT devs might have no sure way to prove they did not copy it. So this would be like walking on eggshells for them.
Thats the point of GPl licenses. You cant close source it.
MIT is a free and also heavy closed source friendly. GPL fixes the greed
Yes. Did I deny that?
Can anyone confirm or deny if what I said is wrong?
I get downvoted for stating one advantage an AGPL fork would have, and yet nobody seems to be disagreeing with what I said… *shrugs* 🤷
A glitch in the matrix.
Ok idk. Your message felt like it wants to explain why we shouldnt use GPL/lgpl
If I could code at the level that these people do, I definitely would. If I ever publish anything that I’ve written for myself it will never be MIT/BSD licensed
Apple makes the source code to all their core utilities available? Nobody cares but they do.
Why do they?
They are BSD licensed (very similar to MIT). According to the crowd here, Apple would never Open Source their changes. Yet, in the real world, they do.
Every Linux distro uses CUPS for printing. Apple wrote that and gave it away as free software.
How do we explain that?
There are many companies that use BSD as a base. None of them have take the BSD utils “commercial”.
Why not?
Most of the forks have been other BSD distros. Or Chimera Linux.
How about OpenSSH?
It is MiT licensed. Shouldn’t somebody have embraced, extended, and extinguished it by now?
Why haven’t they?
Apple makes the source code to all their core utilities available
Apple makes the source code for many open source things they distribute available, but often only long after they have shipped binaries. And many parts of their OS which they developed in-house which could also be called “core utilities” are not open source at all.
Every Linux distro uses CUPS for printing. Apple wrote that and gave it away as free software.
Apple did not write cups.
It was was created by Michael R. Sweet in 1997, and was GPL-licensed and used on Linux distros before Mac OS X existed. Apple didn’t want to be bound by the GPL so they purchased a different license for it in 2002.
Later, in 2007 they bought the source code and hired msweet to continue its development, and at some point the license of the FOSS version was changed to “GNU General Public License (“GPL”) and GNU Library General Public License (“LGPL”), Version 2, with an exception for Apple operating systems.”
I loved this comment as much as a person is allowed to love it
“Commercial” is not the opposite of free/libre. In fact, GPL licensed software can be “taken commercial” with a guarantee that it will remain libre, whereas BSD-licensed software doesn’t have those guarantees.
MIT/GPL is fine for smaller tools.
Yeah, specifically for something like coreutils I can’t see the malicious endgame that is suggested by others here. Is the fear that a proprietary version of
catorpwdorprintftakes over the ecosystem and then traps users into a nonfree agreement? Or a proprietary coreutils superset that offers some new tool and does the same thing? Or a proprietary coreutils that generates profit for businesses without attribution to the developers? What would stop anyone from just writing their own proprietary set of tools to do the same thing now, even if uutils didn’t exist? Clearly not much, since uutils did exactly that (minus the proprietary bit).I personally don’t see a compelling reason to change to MIT, but I also don’t see the problem.
What’s stopping people from doing that today is network effects. There are enough differences today between bsd coreutils and gnu coreutils that substituting one for the other doesn’t work out of the box.
The chain of events that would cause a problem are: due to Ubuntu popularity rust MIT core utils overtakes gnu coreutils and people drop support for gnu coreutils, then a large and we’ll funded corporate entity could privately fork rust coreutils and lock people in.
To me, the problem is not really so much about “locking people in” (it’s also unclear what you mean by that, if they were already using that ecosystem before using uutils aren’t they already locked in?)
To me, the problem is how the MIT removes legal protections when it comes to ensuring accountability to changes in the source… how can I be sure that the version of uutils shipped with “X Corp OS” has not had some special sauce added-in for increased tracking, AI magic, backdoor or “security” reasons? They are perfectly free to make changes without any public audit or having to tell their users what their own machine is doing anymore.
I’m with you until the lockin. How does that happen?
For small programs the FSF/GNU even suggests considering not using the GPL https://www.gnu.org/licenses/license-recommendations.html
Yes, and a cp or ls clone isn’t that meaningful to stick GPL to.
Speaking for myself, it’s because future monetization can be easier under mit when using a foss utility and private code.
My project would not exist at all unless there were ways to make money off it.
True, others can also use that same code too, in the exact same way, but that requires quite the investment, and those of us that are doing this are banking on not getting the interest of a monopoly in that way. We are competing against other small businesses who have limited resources.
At the same time the free part can get a boost by the community.
I comment a lot in politics here, and am sometimes an ass, so cannot name this project
I assume this is in reference to the rust coreutils being MIT-licensed. How would using GPL benefit them?
Improvements would be upstreamed. Not with MIT
GPL would not require that. It would only require publication of the source. There is no requirement to give back or even make your changes compatible with upstream.
True.
Though, you are probably going to have a much easier time implementing a change to your code that is present in a company’s published code, than you would trying to reverse-engineer a binary.
Sharing of the code I would consider “giving back” in it of itself.
Yes, publication of the source is enough. However, you are correct and I should have worded it better. In practice, publishing the source allows the developers of the software to make improvements unhindered by licensing and other IP-based hindrances which are otherwise present in closed-source software
Honestly it’s probably just because so many devs are involved more in their code and don’t want to worry about the nuances and headaches involved in licensing. MIT is still open source.
I guess I can’t really fault that. Developers not interested in the license they use to publish code baffles me
Does anyone use MPL anymore? Is it a decent middle ground or the worst of both worlds?
Bruh instead of all this speculation, you guys could have just looked it up.
https://github.com/uutils/coreutils/discussions/4358#discussioncomment-8027681
There is a big difference between what someone says they are doing vs why they are actually doing it
Well the dev said that he does not care about the license. He wanted to create a coreutils alternative with better concurency using Rust as a pet project. He had even stated that he was not interested in the MIT vs GPL drama, yet people here were acting like children over it.
People think it’s some kind of Canonical evil master plan, yet it’s just some random dude slapping a license on his cool new code, without really thinking about it. Also this conspiracy does not make sense at so many levels. For one Canonical would shoot themselves into their foot if they created their own proprietary coreutils, because admins would not want to deal with non-portable scripts. Also there are already the BSD utils, so if they wanted to create their own fork, they would have already done that by now. They won’t because they prefer free labor from FOSS devs.
The license matters. MIT allows for the embrace extend extinguish approach, or for companies to completely ignore contributions back to the main src.
Whatever he says he is doing doesn’t matter. In the long run a MIT license won’t be good. There’s a reason why the gnu core utils get so much work done on them. Because it’s required if you wish to use the code in your commercial applications
As I said there are many alternative coreutils (BSD utils, toybox) for the embrace extend extinguish. I just don’t see a model situation because that seems to me like embracing, extending and extinguishing a programming language. Nobody does that because it is not financially viable.
It’s not required to do work, if you want to use GPL licensed software for commercial applications. You need to share your source code, if you modified the GPLed code. But most people don’t modify the coreutils’ code. Are coreutils getting so much work done on them? To me it does not seem like it when this new uutils project managed to dwarf them in performance in some benchmarks.
Anyways I think I’ve read somewhere that the project author is open to change the license, if the contributors want to. I guess someone could open a discussion about it. The issue is that it cannot be people from this comment section because they cannot engage in an adult discussion. I do think it’s worth considering the advantages of changing the license to GPL, mainly that users will be forced to share their potential bug fixes. But people have to cut their Canonical conspiracy crap, which just does not make any sense and only makes it harder to convince the uutils author.
There’s no conspiracy, just people learning their lessons from years of abuse at the hands of corporations.
I like BSDs more than GPL just personal choice
Squeek, squack. Your opinion is whack
lol grow up
Sorry, but I or rather many hate your Opinion.
Its ok if you dislike my Opinion about that. But I will show you, that many dislike your Opinion with a little fun and humour.
I believe that this has nothing to do with growing up, but I think thats your opinion you can attempt to follow.
Lol even GNU and fsf failed at implementing gplv3 at all levels in Linux. And with gplv3 redhat gets awa with what they do. Also see recent agplv3 lawsuit. Gpl enforcement is real issue. If fsf wants why no create true copy left strong license no exceptions!
Canonical still licenses most of their stuff under GPL3, including new stuff. The license (other than it being open) was probably not even a consideration in deciding to experiment with uutils.
