Open Source Bait and Switch
debugagent.com
debugagent.com
> The GNU Affero General Public License is designed specifically to ensure that ... the modified source code becomes available to the community. It requires the operator of a network server to provide the source code of the modified version running there to the users of that server. Therefore, public use of a modified version, on a publicly accessible server, gives the public access to the source code of the modified version.
The AGPL v3 and GPL v3 also contain provisions to make them compatible with each other (resulting in AGPL terms for the combined work, but the GPL parts remain GPL).
The FSF goes a bit more into detail on this: https://www.fsf.org/bulletin/2021/fall/the-fundamentals-of-t...
I also think its a bit problematic taken in the absolute, sometimes you have security patches you want to deploy and test out for a week before making the issue public, or perhaps emergency patches for sudden (downtime causing) issues.
AGPLv3 is thus a de facto 'hobbyists only' license, and hobbyists by in large don't go around suing each other; generally they just make good faith efforts to respect each others licenses and maybe use social ostracism when somebody steps over the line. Since hobbyists don't take their community disputes to court, the technical legal minutia of the license doesn't matter to most of them.
As a corporation, I might not want to use it in conjunction with my code, but that's the point. You are free to do what you want, but you in turn must share your code.
Or you engage with the owner to make a financial arrangement for a separate license.
This is like nonfree usage restrictions on otherwise free software, like the famous (if unenforceable) “can not be used for evil” license clause.
therefore the AGPL shouldn't force you to share code if the program runs on a server. but it should force you to share code if the program can be accessed by a user.
this may even apply to running something like a kiosk device where users interact with a program on a device they don't own.
I.e. the gpl prohibits you not sharing code if you distribute the binary. What is the philosophical underpinning of "sharing binary" not being a restriction but "ethernet" being a restriction.
The evil thing is not similar because you are discriminating against a field of endevour (similar to licenses that say educational use only, non-commercial only or non-military only). It seems to be a very different type of restriction.
That's not even remotely near what it is.
I've worked for several large corporations and were in the throes of a major project. Using an Open Source tool would've cut a lot of our dev times by many hours. Three out of three times, all three team leads and managers said "no" to using open source. We had to build several large components from scratch, which did lead to extended development timelines, a ton of working late at night and several "crunch" weekends.
Their rationale? They didn't want to have to maintain a piece of software that was open source. The resounding opinion was it was "dangerous" and not safe - because someone could check in a malicious piece of code and that could end up in our very large, enterprise application when we needed to update it. Nobody wanted to be on the hook if that ever happened.
In the end, it seemed like it was more about upper management types playing CYA instead of trying to put out a solid product.
If that is the case, I don't see how the AGPL qualitatively infringes on any "freedoms" that the GPL doesn't already restrict: you must keep derivatives free. Of course one may argue that the GPL is nonfree when compared to BSD/MIT style licences, in which case fair enough.
I think the argument of FOSS people who don't like it would be something like, as a user, just running the software on my machine can potentially create a legal obligation to set up source distribution, if, like, I forgot to block a port.
In any case, does the AGPL requirement to provide sources apply even if you are running an unmodified version? In other words, would merely pointing to the original repository not be enough?
Regarding the risk of accidental legal obligations, I suppose it depends on the details and technical wording of the licence.
If the requirement broadly covers any use of the software on the machine (e.g. some backend service that happens to help your public webserver to stay online) I can see the discomfort, especially if one must explicitly provide or link to unmodified sources too.
On the other hand though, if the requirement is limited to actual provision of the software's functionality to 3rd parties, I would argue that if someone accidentally provides it due to forgetting to block a port then they have much bigger problems than the AGPL.
https://www.gnu.org/licenses/agpl-3.0.en.html
It just says interact remotely through a network. Interpreting what this means precisely is left as an exercise for the reader / the reader's lawyer.
forgot to block the right port
if you get notified of a security breach caused by your own incopetence, you secure it. which would effectively be the highest harm apgl can inflict on you already: stop hosting the service. which was your point all along.
for a popular program that's not very likely, but lost source code is the bane of software development, so hacing your own version available would be better, at least as a backup
distributions keep archives. Just use a distribution and you're fine.
Not true: only if you made local modifications.
> I forgot to block a port
Also not true. You have plenty of time to close that port.
"""your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice."""
If you expose services on the Internet by mistake you are going to have 1000x bigger problems than the risk of being sued successfully for a honest mistake.
That said, FOSS authors normally aren't the kind of people that pushes to those crazy maximalist interpretations of documents. So if any risk exists, it's not large.
It's not entirely clear what counts as derivative work with regards to GPL. There is a lot of corner cases and workarounds in the real world. It becomes even less clear when you widen the definition of distribution.
I don't understand this stance.
From the point of view of the user, the AGPL offers the same freedoms as the regular GPL. If you use the program, you have the right to see and edit its source code, regardless if the program runs on your own computer or on another computer.
How can anybody call this feature "nonfree" is beyond me.
Granted, the license only asks you to publicize your modifications, but in software that's basically your "first-born".
If you're just talking about the freedom to run things unmodified, basically every software you can download online without paying is "free", and obviously AGPL fits that bill for the uncapitalized "free" software. But that's not what we're talking about here, right?
The situation is funny that AGPL is widely derided as both being to weak and being to strong.
Do you have evidence?
But still, I think the permissive license we picked was the better choice. Especially after our company was formed and we want to use the project for ourself too the (A)GPL would make the community working together with this harder (CLA, dual licensing?)
IMO a permissive license is better and easier for the developer and the GPL is better for the end user.
But even the GPL does not grant you anything without a lawyer :) E.g. I tried to get the GPL source code from Waze (tried it multiple times!) and got a reply: "I've looked into your concern and determined that it needs some extra attention from our end." See also https://2jk.org/english/2014/03/27/israeli-waze-hit-with-gpl...
(btw: you can get the inofficial code from here https://github.com/maximuska/Freemap-waze)
No, as developers we use tons of software. We are users before being developers. As such, GPL protects developers as well.
In this scenario, your company is the thing GPL is trying to protect your community devs from (i.e. the gpl is trying to stop a company from taking contributions donated on the condition they would be open-source, and selling them privately without compensation). You are basically saying the GPL makes it harder to do the thing the GPL was trying to stop.
It's a perfectly reasonable arrangement that adds value to both the community and the GP, and that the GPL "protects against". So, yes, the GP's point stands in that there are uses for licenses other than the GPL. All of the complaints about they only being good for people creating proprietary software are true, they just completely miss the point.
But if you take too long to reach it and forget the context, it does indeed sound like a weirdo complaining that the GPL is copyleft.
The morally questionable situation is where you publish code under GPL, allow community contributions on the code on the condition that the community contributors sign a document transfering copyright to you (without payment or anything like that) and then also use those community contributions in a closed source product you sell.
wat
That's exactly backwards. Releasing your donation under a permissive license doesn't give you that. A permissive license gives others express permission to make derivative works that the original author company might not be able to use themselves—because there's no obligation for others to keep it open...
A permissive license is only better and easier for developers of proprietary software. The GPL is better for developers of free software and for end users.
Two permissive licenses, one headache for the FOSS dev.
Regardless of license, most software projects are either community projects, or corporate projects, but not both. Corporations rarely see fit to invest in the development of a project they're using because some other chump is giving it away for free. And volunteer programmers rarely want to deal with submitting commits to a project with corporate managers who are focused on the needs of the organization and see volunteer programmers as out-of-the-loop nuisances.
Whether you're a corporation open sourcing something to get free community labor, or a volunteer open sourcing something to get corporations to contribute, you'll probably be disappointed.
users don't care, they aint taking the code for changing.
Arguably it also doesn't matter till you are corporation closing the code for profit. If all you do is OSS and are used by people that also release OSS, extra protection GPL gives are not useful. But of course real world is not that idealistic.
And for that of course BSD/MIT is better. No facility for anyone to get anything out of you so you can take and take without ever giving back aside from occasional bug report and outrage over someone having a bug they didn't fix in project they are not paid to develop in the first place
GPL gives one guarantee - that the code you give will not be closed down for money and used to save some corporation some dev-hours. Some devs don't like it because it is making their life difficult (and I'd also argue anything higher than LGPL for stuff like libraries is kinda pointless), but that's kinda the point.
GPL explicitly allows commercial usage. E.g. I take take your GPL code and create a SaaS around it and make a lot of money or I can create a consultancy service around your GPL code.
That's why I chose the license that seems least likely to prevent me from being able to use the code I've written (currently Apache 2).
That's incorrect. As the upstream author you have every right to use your own code any way you want.
Well, that depends on if the project accepts pull requests, and whether they have something like a contributor licensing agreement in place.
Of course you can take your code and license it to said employer in whatever way you both agree on. But this is going to be much easier if the code is already publicly available to everyone, with a known license: the employer doesn't need to even care really who the author is, just the license.
Not at all. The code you are going to submit already has a license file attached. Just update it with an accepted FOSS license before the submission.
You don't have to provide any special license or make it public.
> Of course you can take your code and license it to said employer in whatever way you both agree on.
but that's likely to be a manual step with a lot of raised eyebrows, frowns, and questions involved.
i thought that way i would always be able to use the code in my own FOSS projects but i would also not be able to sell out and make my work proprietary (since it would contain GPL code owned by my employer)
this may seem less beneficial than an apache license but it was aligned with the company goals as far as my work was concerned, so i essentially had them put a verbal promise into writing, and i thought it was a neat way to commit myself to FOSS
As the owner you reserve the right to re-license it to anybody you'd like, under any license you'd like, as long as you don't give that right away.
At a job, or on a contract, the employment agreement or the contract will almost always says you're giving that right to them in exchange for compensation.
You can tell your company to either buy a proprietary license from yourself or reimplement the whole thing.
You won't be able to use it if the future project is under a GPLv2 (or GPLv2+) requirement, since Apache 2.0 and GPLv2 are not compatible.
I don't think i've ever heard someone saying this. Does anyone really believe this? Some concrete examples would be illuminating.
Some of those employers had policies outright prohibiting GPL use...
And linux (GPL) does have paid developers, and so does webkit (LGPL).
Your data is rather meaningless… but I'm happy your statistic that excludes all the data points you dislike proves your theory :)
But yeah it is true that Linux is much more efficient at getting stuff upstreamed, I think Sony has sent more patches to Linux than FreeBSD and the PlayStation runs on it.
There's also the path that--even if you have a permissively licensed project--$corp will see your thing, like it, and decide to just copy it, to overall avoid having to deal with dependencies they do not own. In other words, a lot of places are unwilling to play in anyone else's backyard. They "support" open-source, but only when it's on their terms.
They might even call you, under the pretext of a job interview, and of course they want to discuss in detail the most significant project you've worked on! But you find out there are all kinds of awkward conditions on the job offer, like a cross-country move, or much lower pay than you were expecting, or no actual commitment that you'd be working on your project but just a vague, verbal statement that you could continue "during 10% time". You'll have to interview three more times with 15 more teammates. Everything gets dragged out for months and then you see them announce their own project in opposition to yours.
That is, if anyone pays attention to your project. Most open-source developers are categorically averse to anything resembling advertising. Try building a thing and then posting about it on a topic-appropriate sub-Reddit. So many of them will delete your post or ban your account from the sub for "spam".
The vast majority of the market--including other open-source developers--want open-source developers to write code, shut up, and go away. The minute you start talking about maybe wanting some remuneration for your efforts, you're suddenly "ungrateful" or "shilling" or "spamming" or "selling-out". (EDIT: It's happening in this very thread, further down the page)
A lot of big corporations will not allow GPL dependencies to be used in their codebases, and not having a GPL license will definitely make software more usable by those corporations.
How the developer expects to profit by giving something away for free is definitely a mystery, but there is also some truth to the idea that a GPL license does scare companies away.
Elasticsearch is a good example of a problem that isn't solved by a different license. Amazon is running essentially unmodified versions of elasticsearch, which competes against the business model of the company building elasticsearch. Even with an AGPL license, elasticsearch (the company) is not going to be making any money.
If a company isn't interested in upstreaming changes, it probably won't help that they're using an AGPL license. If the code isn't user-facing, the license won't force them to make their changes available. Even if it is, often changes a company doesn't want to upstream are very specific to them and aren't useful to others. Even if it's business valuable, and the company makes the changes available, they won't be making it easy to integrate.
The AGPL, more than anything, places a burden on users and developers, and reduces the community size. Most companies don't allow the use of AGPL software, and in the cases they do, they often only allow its use in an unmodified way, or only allow modifications if it isn't user-facing.
It's a nasty, complicated situation with bad actors on both sides.
You're probably thinking of SaaS, but, still, what?
I'd argue we distribute software much more than say 20 years ago. Almost every web site you view is distributing non-trivial software (javascript, from maybe a dozen npm packages). App stores are making software distribution much easier for the average user. Programmers are increasingly using dependency managers to download libraries. Even every SaaS service is getting their software from somewhere, and the tech stack is increasingly complex these days, which means even more software being distributed and used.
Perhaps what you mean is "software isn't sold anymore", so the money is all in the services. Which is probably true, and this is probably where GPL is becoming irrelevant.
But then, it can be argued that the services model was in part the industry's response to the prevalence of GPL, which pushed businesses to find workarounds. People need to make money, and if software sales isn't generating enough dollars because GPL software pushes down the prices people are willing to pay, then they'd just invent reasons for users to buy services instead. -- which, if true, could be interpreted as a success story for the GPL.
Maybe I should have been clearer. Most actual products based on OSS aren't distributed anymore. They're SaaS. The majority of the most popular app store apps are clients to a SaaS product.
If you give something away for free, you should not expect money for it. If you license it for anyone to use, you should not be surprised if some of the users end up being big companies. By choosing to give it away, you have chosen to give up control of what happens.
If you want to sell software for money, then do that. If you want control over how it is used, choose a license that gives you that control. But don't just give things away for free and then complain about what users do with the freedom you willingly gave to them.
Open source was originally about the freedom to use software in new and creative ways, and NOT about giving away free stuff.
There is almost a point where, like all language, the original meaning becomes obsolete and a new one takes over.
Really, from the outside it looks silly - "I gave my code away, and now I'm not profiting from it!". Then at the same time all of the biggest, richest companies in the world are software companies because they chose not to do that.
To be honest I have no answers to the problem, and personally find most of the answers that do get thrown around dont pass the most basic of logic tests. So like you the only option I see is for developers to make the change, stop the freedom and the free ride.
There's this idea that open source should be totally free, but then how does the developer writing the software wind up eating and paying their rent? There's the linux kernel and mozilla and other massive open source projects which have large companies and foundations and budgets behind them, but that is the 0.01% of open source projects.
When OSS maintainers setup companies and go the "loss leader" or "bait and switch" or "freemium" models so that they release open source code, but the Enterprise-level offerings are locked behind proprietary licenses then this is looked at as being a betrayal.
The OSS community almost seems to require OSS maintainers to be in poverty, while allowing large corporations to freely consume all of their work. That just isn't sustainable.
First of all, it's been sustainable for a long time -- what changed?
Secondly, a lot of major open source projects are being worked on by developers who are employed full-time by large corporations to do it. And I don't just mean Red Hat or the Linux kernel. Those devs get paid by their employers to work on open source projects that benefit their employers and also the wider community -- it seems like a really successful, scalable, sustainable model.
The people who are having a hard time are the indie devs, but let's be honest, being an indie dev who gives away software for free has always been, and always will be, a bad business model. It's not a good idea to do that for a living. It never will be.
Big failures like OpenSSL fiasco happened - where sure, company was sustainable but due to skewed priorities coz of funding (companies that founded it founded features that from perspective of any other company were bloat, and not enough work went into modernizing the code) the code was shit and full of traps.
And it's still a fact that vast majority of developers of stuff used everywhere wouldn't be able to do it as full or even part time job for financial reasons.
All while the corporate is pushing same "BSD/MIT good, GPL bad" agenda, coz they don't need to contribute anything back to stuff they take
Yeah and people eat it up.
"oh it won't have as many users"
well who cares? It's less hassle. Not like you get anything back from having 100x more downloads.
It isn't just the Indie devs it is the smaller businesses as well. Those are the ones pulling license changes, doing "freemium" models and other things that the OSS community is objecting to and the author is throwing shade at. Those models are NOT working well or we wouldn't be having these discussions.
The models that "work" for the coder are just tossing your code into public and not caring because it is a side project or something that you're doing to learn to code and you'll abandon it in a few years. Or else working for an existing Fortune 500 company getting hired to work on open source, or one of the few large open source foundations (sponsored heavily by massive corporations and/or academia).
And I worked for the past 10 years in open source at a startup-to-small-business getting paid by my employer for open source. That model is not very good, which is why we're seeing so many issues with "bait and switch" at those kinds of smaller corporations.
And that's it, no "enterprise editions", the only extra code you're paying for is backported critical patches, and deterministic builds of software (and all its dependencies) from source. RH puts a huge amount of effort into those builds, it's incredibly painful as an RH dev sometimes, but it seems to be a huge factor in building trust.
But, I can see why it doesn't really work for other companies, step 1 is "Be Red Hat, and have Red Hat's reputation."
I've been involved in Kafka a bit, and it's been very sad seeing Confluent devs having to deprioritise work on FOSS Kafka to focus work on stuff that, well, they can sell for money, but I totally get why.
It's a weird sort of exploitation, because OSS maintainers who don't think they're being adequately compensated are free not to participate by volunteering their time.
- Is well-compensated while working for a for-profit company where the codebase is proprietary.
- Works in open source but is poorly paid or not paid at all.
[1] That they might prefer to work on open source is their problem, and not one for the economy, I think; I say this as an open source developer who gets paid to work on open source and prefers this over working on proprietary software.
I think it's a problem for the economy, not because of individuals' preferences, but because I think there is an overall economic benefit to work being open source.
So companies will generally keep away from my stuff, but people doing open source will happily use it.
I've had several people complain about this and ask me to use MIT. I put in my code of conduct that asking that is forbidden :D
By using aggressive open source licenses like AGPLv3 you have to do more work to keep the door open for yourself to profit later if you so choose, it’s a bad personal economic choice, and while some view it as the ultimate in altruism to prevent this, it’s also an act of denial, everyone who could have used it inside companies or projects that can’t change their license to be compatible are denied the ability to use the code.
Also hot damn, the AFPL license is super aggressive, makes AGPLv3 look downright business friendly: https://en.m.wikipedia.org/wiki/Aladdin_Free_Public_License
Too bad that rewriting something doesn't transfer copyright :D
Ideas aren't copyrightable. IANAL
That's it. I have no plans for using anything more liberal than lgpl ever.
> Things might get complicated if you have other contributors though.
Not really… they distribute under whatever license they got it from.
[0]: https://vadosware.io/post/the-future-of-free-and-open-source...
The maintainers chose OSS. It's like taking out a loan then complaining about having to pay it back - either don't go OSS, or step down as maintainer.
There is an idea pervasive within the developer culture that--through sweat and grit--one can build a project (regardless of FOSS or not) and eventually be recognized for the effort. And not just recognized, but recognized in a specific way. For some developers, that is notoriety. For others, it's money. But the idea is basically "my code in -> my definition of validation out".
And I think it's pretty clear that, for most projects out there, that's just not true. Or, more specifically, there is a huge chunk of the story that is missing. Because it's not hard to find dozens of projects in almost any niche, across thousands of niches. For the vast majority of them, they toil in obscurity. Some of them might be underdeveloped, but I see that more as a result of the failure to receive said validation leading to quitting the project. There is clearly some other factor involved in between creating a project and finding success with that project.
A lot of that missing element is selling. Even FOSS projects that are delivered free of charge to users need to "sell" themselves. Linux wouldn't be anywhere if Linus Torvalds hadn't recruited users. You have to convince people to try your thing and that convincing can take many forms. "Selling" is putting a name to "the act of convincing".
It's not quality code. It's not documentation. It's not a pretty website. Lots of failed projects have those things. Lots of successful ones don't. You have to market your project, and that's work.
Work that isn't coding. And that's why more developers don't do it.
Celebrity developers have people hanging on their every word on Twitter already. They have already done the work of advertising--advertising themselves--and now they cash in on the reputation and can make a successful project just by announcing it. Large corporations have money to pour into actual advertising and marketing for new projects. But independent developers don't have the cache or the money to be able to pull that off, and don't have the visibility into the background work on those other projects to know how their efforts are different from the projects they look up to.
But FOSS advocates keep pointing to the work of celebrity developers, of "open-source aligned" corporations, and saying "see, open-source can work". There's a lot of pressure from other developers to open your work. Most of the loudest voices keep saying, "this path works", leaving out the key element, making it sound like a dream.
I call this the "Field of Dreams Paradox". We have the phrase "if you build it, they will come" stuck in our cultural memory, but have forgotten that the movie is about a literal miracle.
Like, how is even say a single developer of mildly popular lib doing one thing gonna setup financing ? Or get people to pay ? Anything from patreon to tips was tried to mild results at best
What you're probably thinking of is "Public Domain." That's where a creator disclaims most (though not all) rights to the creation.
This is the "bait & switch". It is planned right from the beginning, the tricky part is that you need to make the "it's completely free" phase as long as possible (using borrowed cash, investor money, whatever) to have as large a userbase as possible. And THEN switch.
It's literally the definition of "bait & switch"
They are changing license of the new stuff.
You are free to keep using whatever you were using forever. It's the same as a maintainer just abandoning a project and you having to take over.
If the FOSS license was such that it didn't restrict use, but only redistribution, then only the existing redistributors are licensees. The existing users have no rights.
If the new license says that unlicensed use is not allowed, then the users are now infringing. They didn't agree to any license in order to use the program when it was free and therefore they are not in any agreement that can be grandfathered.
Even if a license says that it's irrevocable (or some doctrine applies which makes it so, regardless) it can only be irrevocable to those users who have entered into the license. Those users may enjoy the continued right to redistribute the program. However, new users receiving the program do not benefit from the irrevocability; they have no existing license contract that can be grandfathered.
If a program has gone from FOSS to "cannot redistribute or use", the situation is like that existing licensees are allowed to give away copies, but the new users receiving them aren't allowed to do anything with those copies.
Software whose copyright holder has expressed revocation of a FOSS license should be regarded by all parties as a piece of radioactive or biohazardous waste.
Don't even think about maintaining a fork or anything of the sort.
No, that's not how it works. If libfoo 2.0 was released under an open source license, it remains so into the future.
If a company was the owner of that source code and decides the libfoo 2.1 is now suddenly proprietary and no longer open source they can certainly do that. But libfoo 2.0 remains open source and can be forked by the community or whoever wants.
There are many examples of this, for example Open Solaris. When Oracle bought Sun they quickly reverted Solaris back to closed source. But not even the (arguably) most lawyered-up tech company in the world can change history and change the license on the the previous Open Solaris releases.
That's how Solaris forked into the proprietary Solaris which Oracle still keeps alive and the open source descendants of Open Solaris (Illumos, etc.)
I would trust that only if the copyright holder makes it clear that they are not revoking the license for libfoo 2.0, but that libfoo 2.0.1 will be under a different license.
If they indicate that they wish to revoke the license for previously released libfoo 2.0, it seems they have the right to do that; I don't want to be the one testing it in court.
I don't know about the details of the Solaris/Oracle situation, but I doubt it hinged around it simply not being possible to revert a license, as such.
A company as aggressively litigious as Oracle would love nothing more than to kill off all Open Solaris forks. But Sun released Open Solaris with an open source license so it's not something they can change.
Consult a lawyer whenever you need to use an open source project, their opinion carries weight that mine does not.
At best they could take back the 100% Oracle-owned parts. The community would have to build to fill in the gaps.
They couldn't revoke any files that have, say, a BSD license, even if Oracle (or Sun, before them) had modified them and added their own copyright notice, simply because they would need to contact the original authors and act in concert with them; those authors would likely refuse.
I'm mainly talking about situations when the revoking party is actually 100% copyright holder to the majority of the files implementing the payload functionality, without which there is no software. I don't see how you the copyright holder would not have the right to revoke a FOSS license over it.
Based on what? None of the existing licensees have a signed contract of any kind, nor has any exchange of value taken place; allowing free redistribution and use was an uncompensated, unilateral action.
Even if there were a doctrine that existing redistributors were grandfathered forever, so they could continue making copies and giving it away, the license would not actually be available to the recipients, who are not existing licensees.
The U.S. Copyright Act indeed has the concept of termination:
https://cdas.com/copyright-termination-prime/
There are limitations to it for various obvious reasons, like that you can't terminate the copyright assignment implicit in a work for hire. (Because, doh, you were paid.)
No, that's not the case. By buying Sun, Oracle owns all the Open Solaris code.
Sun of course could not have open sourced code they didn't own the rights to open source in the first place. It was a long effort within Sun to scrub all the code to make sure. (This is why open sourcing proprietary code is a lot of work and most companies don't bother. Thankfully Sun did.) Some parts had to be distributed as binary blobs because Sun didn't have the ownership (over time there were separate efforts to rewrite these to reduce dependency on binary blobs).
> I don't see how you the copyright holder would not have the right to revoke a FOSS license over it.
Can you provide any examples where this has happened?
According to Section 203 (grants made after 1978), it looks like you have to wait 35 years, and then in a five year window after that, you can terminate.
So there is a way, but the copyright grantees have over three decades' worth of protection.
This law is for specific grantees; like Bob assigns the copyright to Alice (other than as a work for hire done for Alice). Alice is now the copyright holder. 35 years later, Bob has the right to say Alice is no longer the copyright holder.
Bob has five years to do it. Bob must write Alice some kind of letter. The termination date must be no sooner than 2 years, and no later than 10 years, from that letter.
A free software license isn't a copyright grant so the termination business, and its limitations, may be inapplicable. The users of software aren't copyright grantees, and those who are currently non-users aren't anything at all.
Now about the Open Solaris code; while some of it has copyright notices mentioning only AT&T and/or Sun Microsystems, there is a boatload of hits for "Regents of the University of California".
> Even if there were a doctrine that existing redistributors were grandfathered forever, so they could continue making copies and giving it away, the license would not actually be available to the recipients, who are not existing licensees.
Well, that doctrine is there: if you grant someone a copyright license and they take you up on it, they have 35 years before you can revoke it, in the United States.
It's not clear that third parties continue to have the same privilege after you indicate that the license is no longer available to new licensees.
I doubt such a case exists, but if it does I'd love to learn its story.
> If the FOSS license was such that it didn't restrict use, but only redistribution
That's not a FOSS license to begin with.
> If a program has gone from FOSS to "cannot redistribute or use", the situation is like that existing licensees are allowed to give away copies, but the new users receiving them aren't allowed to do anything with those copies.
Users still get the copy with the old license. The company can't go on your disk and edit the license after you obtained the software and the license.
> Don't even think about maintaining a fork or anything of the sort.
Amazon does it… I'm sure their legal department was consulted.
Your understanding is deficient. Some of the most popular free licenses like GPL and BSD don't restrict use. Users don't have to enter into the licensing agreement at all, only those who redistribute.
By using the software, you implicitly agree to the liability disclaimers, and that's about it.
All of the conditions in the license have to do with redistributing.
Licenses that restrict use in any way (e.g. "free for non-commercial use") are not free licenses.
> The company can't go on your disk and edit the license after you obtained the software and the license.
That's just a practical matter. If a license is revoked, the software will continue to be redistributed or used by people who don't even know about it. That doesn't mean it's legal.
The same thing could happen to software that was improperly licensed to begin with. E.g. a rogue employee took some code without company authorization and put it out with a free license. They can't go into people's disks and erase the bits, but the software is not legally free.
If you write a program and freely license it, such that Debian or Fedora pick it up, and then you write them a letter saying that the program isn't actually freely licensed, that it was a mistake, they will drop the thing like a hot potato.
The GNU project requires signed copyright assignments from contributors who make more than a trivial change. That protects (or hopefully protects) the projects from backpedaling problems.
What legal precedent are you talking about?
In general, bare licenses (where the licensee does not give anything valuable to the licensor) can be revoked with sufficient notice. This is law in most jurisdictions I'm aware of. And this is taught to law students in their textbooks (heck if you just look up "bare licenses" in legal dictionaries you'll probably find something to that effect).
Do you have any standing to claim that OSS goes against this general rule?
The practical reason this doesn't happen is that revoking the OSS license of published code is pretty much un-enforceable and pointless exercise. There's no practical advantage that can be conceivably gained from such a stunt (unless you want the infamy for being the first person to attempt this), especially considering the PR fallout.
But I'll assure you that, if you actually try, and send emails to legal departments of sufficiently large companies notifying them that you revoked an OSS license of a project that you own, most of those companies will avoid using your projects and will try to transition away. I can't imagine any half-decent corporate lawyer advising the company that they definitely won't get into trouble because the precedent says OSS copyright owners can't do this.
FWIW I think some of them might actually tell you that you can't do this (which is mostly a bluff), but that's not going to be what they'll advise their clients/employers.
Disclaimer: IANAL but have a law degree.
If the software disappears from mainstream distros and its upstream repo is shut down, with notices that the free license has been revoked and forking isn't permitted, it's only a matter of time before it fizzles away.
If it's something of great interest to individual hobbyists, it might persist for years, but enterprises and institutions will not knowingly want to touch it. (If they really need it, they may seek licensing of the continuing proprietary version, if it exists).
If a security vulnerability is found in the code, it may need expert attention; but the experts will be required to perpetrate copyright infringement in order to fix it; it will have to be done anonymously. Then you need some place to host that and so on.
The proprietary version will have all the fixes and improvements, so that the old once-free version will just recede into the past as a broken old illegal version of a proprietary program, essentially no different from an ancient source code leak.
At least that's their hope. And 90% of customers probably do, if they have reached a critical mass by that time.
* Bait = get as many people to use your software as possible * Switch = THEN change the license (for new additions) so that as few people as possible jump ship. Bonus points if you do it shortly before adding a cool new feature that lots of people are waiting for
Sometimes it works. Sometimes, Amazon is quicker and offers a product based on your version. The trick is to get the timing right...
it doesn't. It's a completely different argument.
You want support buy support.
And then the CEO of megacorp sends employees to come everyday and empty your foodbank and serve the food at the company canteen, because this saves the company catering money, and thus profit.
Yes, technically everyone's welcome at your food bank, but ... it won't be long before you'd stop doing it, right?
The implied nature of a food bank is providing food to those in need - I've yet to see a software where the implication is that the wealthy can't use it.
The point being made is that people getting upset when they are made to feel like their altruism is taken advantage of, let alone abused to ends that are against the spirit of the original work, and getting disillusioned and abandoning projects of love, is quite a natural and altogether human reaction.
OP said they didn't get why anyone would/should be particularly upset by megacorps using their open source software in perhaps not the manner originally envisaged. I was simply trying to come up with a more relatable example to relate why. The induplicability of food is completely irrelevant here.
> The induplicability of food is completely irrelevant here.
Then in what sense is the metaphor valuable? It was merely meant to depict an emotion that the humans on this forum will already be well aware of?
How is this problematic? For most of my career, I also haven't supported OSS -- I too use and leverage it.
Open source is relatively simple: it does what it says on the tin. If you make something freely available under a non restrictive license, you no longer own that thing. Sure, you may retain some copyright, but you've given it away. Why are people always surprised when those free things are leveraged? Is everyone truly this naive?
GPL, AGPL, BSL... they all solve different problems. There's no right answer. If you're building something and want to make money, then it behoves you to choose a license that strengthens your position to make money, rather than introduce a vulnerability.
While there are legitimate arguments in favor of different open source licenses, the BSL is a proprietary license and is always the wrong answer. I'd agree with this if it used a real open source license like Apache or MIT as its third example instead.
And well the other BSL (Business Source License) may be appropriate for proprietary software that you want to be released under a open license at a later time.
Although I am also not really aligned with the idea on a ideologically plane.
A lot of companies do astroturfing by creating a false impression of community, cooperation, openness and decentralized development.
Later on they add CLAs, switch to open-core or use other tricks to strictly control development and use.
It literally does not. Please refer me to any definition of Free and Open Source Software that refers to anything beyond the text contained in the license. Please stop spreading such woefully sore interpretations. This is exactly how you burn out authors and maintainers.
> A lot of companies do astroturfing by creating a false impression of community, cooperation, openness and decentralized development.
I've said it elsewhere, but these elements do not inherently have anything to do with Open Source. It's beyond foolish to presume them.
> Later on they add CLAs, switch to open-core or use other tricks to strictly control development and use.
If this bothers you (which it shouldn't) then perhaps consider an alternative licenses which restrict the ability to monetize without releasing source, such as AGPL.
Licenses are being wielded as per their lettering. This is a good thing, generally. We all benefit from Open Source regardless of CLAs or open-core.
I as the developer do something nice for the world. I therefore hope that you, as the user, will pay it forward.
When this ethos is subverted by people who don't pay it forward, who just see "Free!" and unthinkingly take and take without ever thinking to give anything back, it rubs people the wrong way.
"Open Source", historically speaking, was the right (and obligation) to have the ability to modify the source code of software you use. There was nothing about 'paying it forward', but rather giving users the freedom to control the software they run.
Do you have any written evidence that this was a commonly accepted "social contract"? Because I've been using FLOSS since last year's of last millennium as well and I've never heard of such attitudes until recent years. (Even today, I rarely see OSS project leaders actually saying they expected all users to give back something -- it's mostly other users who somehow assume everyone else needs to do so. And if I may say, making presumptions on the intentions of OSS developers is a bit... presumptuous to say the least, even if well intentioned.)
One of the few "giving back" contracts I'm aware of is the GPL. Which explicitly states in the license that you need to open source your modifications if you distribute the binary. Vim nags you a bit to donate to Uganda children, but that's explicit as well.
>Even today, I rarely see OSS project leaders actually saying they expected all users to give back something //
I've never seen it _demanded_ of anyone. Also, I think it largely went away in the early 2000s, as more, varied licenses came online bringing OSS a much broader base.
Pay-it-forward seemed to be a growing movement across society (well before Oprah latched on to it) but particularly on the 'net/burgeoning web. I used Slackware as my primary and got a lot of code from Sourceforge as well as using Debian and RedHat packages later.
Perhaps it was our approach [my, and other people with this impression]. That the first [and only] FOSS license I heard of was GPL, that the movement rallied (to my recollection) around that banner and so the idea of giving back was embedded -- I'm not a programmer. My self-apportioned part early on was to share Linux, help people with compilations and installs; act as a helper and advocate I suppose. It wasn't an explicit obligation, maybe it comes from transactional thinking having grown up in a Western Capitalist society under right wing governments?
[I'll have a dig around for some sources if I get chance.]
Why do you believe this to be the case? While I applaud the notion, it is sadly divorced from reality. The notion of "nice for the world" or hoping users "pay it forward" is not, historically speaking, part of the social contract.
The social contract has been roughly either "you, the end user, are granted free access to the source code of these programs, in perpetuity, to use, modify or distribute as you see fit, while either preserving or discarding these properties (depending on the license)", or "this body of work is unencumbered by copyright or liability, enjoy".
> people who don't pay it forward, who just see "Free!" and unthinkingly take and take without ever thinking to give anything back, it rubs people the wrong way.
No? It doesn't. If I write some code and slap the BSD or MIT license on it, it's gone. I've gifted it to the universe. That's the point.
I grow tired of this rhetoric that open source is somehow coupled to community contributions and donation based funding. It's not! Sure, that may happen for some projects, and it's wonderful that it does, but it is decidedly not a characteristic of Open Source.
SQLite is Open Source, yet your contributions are not welcome. Linux is Open Source, haven't you bought Linus a coffee?
1: https://www.joelonsoftware.com/2002/06/12/strategy-letter-v/
I dunno man. That seems like a bait and switch. You start off with "oh. how could we charge you, it's open source" and then turn around and say "pay up or we'll get Eben Moglen to sue you."
Seems like a racket to me.
But YMMV. I release things under a BSD license, but that's just me. Unlike GPL fans, I don't try to tell other people what license they should release their software under. If you're hip to GPL, by all means use it, I don't think that EVERYONE using a GPL license is running a racket. Just mentioning it so peeps might understand the pushback on EFF/GPL some people feel.
Though yes. If a company did do a bait and switch like that, it would be bad. But I don't think Linden did that in this case.
No, you turn around and say "you know how it was cool that you could use that thing to do what you wanted ? Well, continue this tradition and make your thing available for others to do what they want. Recognize you're standing on the shoulders of giants by giving back to the community".
The only reason one might not want to release under the same license is because one does need money to live. That's a necessity of our current political system and changing it is the logical conclusion of being in the camp of those who want to spread Libre Software
> even though they were only distributing the viewer internally.
That is explicitly allowed. You just have to live with consequences of it being legal for any of the users to take and "bring back to the light".
It is either that this company didn't wanted their inside people to do that, or that Linden lied to them about what GPL implies
I don't have a good solution, but I sometimes wonder if we are heading in the right direction.
This is a fundamental misunderstanding about how copyright works, the author could have closed the source completely without changing the license, because the license only applies to third parties trying to use that licensed code, not the authors.
I know plenty of people who do open source consulting professionally, (in an ethical fashion). I myself did it briefly (not really my thing)
Yes predatory people and scammers exist. But lets not dismiss an entire field because some people are assholes.
Also, i have no idea what the bait and switch the author is talking about is. Did anyone really think that google open sourcing android meant that it was open sourcing the entire android ecosystem? There has to be an intention to mislead for it to be a bait and switch. Someone doing something you dont like is not a bait and switch unless they try and trick you.
Anyways, as a php dev, i can assure you im not working on whatever the popular trend is right now.
Certain tech stops being a fad but stays entrenched and in a certain, while not overwhelming, demand. Hiring for PHP and C++ jobs will continue for a loooong time.
My impression is that it's relicensing a product from a FOSS license to a proprietary one after it's gotten a bunch of users.
Companies release and contribute to open source because the open sourced code isn’t their primary business and there is more value in having outsiders contribute than the competitive advantage of forcing competitors to create their own version of whatever the open source code does. This works fine without making money.
Individuals work on open source because they want to participate in the community and might want improvements. This works fine without making money.
Yes, we would lose companies that are created solely to develop and release open source software, but I am kind of ok with that.
We wouldn't even lose them. If open source were incompatible with software development companies, then Red Hat wouldn't be in business.
I don't think anybody claimed "simply releasing your source to the public [will] lead to monetary success"
From a pure business perspective, I feel like there are more data points out there that have won (as in, "survived") by shipping proprietary software.
Don't want to make moral judgements here about proprietary-vs-FLOSS but within my hacker bubbles, one biases themselves to be partial to FLOSS very easily. If I were to ship "some things" (it really depends what the thing is) as proprietary, this community may not take too kindly to that move (and neither may I).
On the other hand, I don't think that the world at large really cares. Sometimes it feels that one can either be a) financially well off or b) more beloved by the hacker community. These things are not mutually exclusive like that but the union of these is rather rare. Hard choices!
Proprietary software doesn't save you from having to make decisions like this. Proprietary software can be licenced under many different terms. Are you going to sell perpetual per-seat licenses? Subscriptions? Selling updates? Support contracts? Avoiding future regret is always going to be a speculative affair.
They spotted an opportunity to sell a version of an open source thing to commercial customers. This, in turn, made product development out of what looks on the surface like open source contribution.
That worked really well for Red Hat, but the wrong lesson to take away is that there is big money in open sourcing software.
It is supposed to advocate a lack of restrictions upon what users can do to the software to balance against what software can do to the users, or more importantly, forbid the users from doing at all. (or permit doing with varying levels of convenience/inconvenience).
but then, with a debate that software is better made in an open source development/collaboration style, and a political and economical state-society built around exclusivity and deceitful exploitation, there's no discourse around freedom left near the open-closed source debate.
also, the earlier FOSS advocates (GNU crowd) thought they could 'hack' the system and use one of its own tools, specifically copyright laws, in order to 'trick' (hacker mindset) the law system into guaranteeing that the software was not going to be locked down and turned to work against the users. It's become clear now (in retrospect) it did not work.
Why is payment required? If payment is a major motive then don’t use an OSS license. If you’re doing it because, in general, you support OSS as an ideology then be realistic and understand that compensation for your time equivalent to a corporate swe job isn’t likely, and you’re almost definitely never going to be compensated commensurate with the popularity of work that hits mainstream. If you find yourself complaining about how much time it takes to maintain and how demanding users can be, walk away in the satisfaction you’ve created something worthwhile and other people will continue the work if enough feel the same way.
No, its not like that at all.
It would be like if you volunteered in a soup kitchen, where every single day, half of the patrons were individuals that couldn't afford the soup, and the other half were businesses that were taking the free soup, putting their name on it, and selling it. The first group of people I am fine with. Thats why soup kitchens exist, and pro bono exists. But once someone gets the ability to pay, they should pay. Thats why I support non-commerical licenses:
Although under this metaphor the soup, once a single can is made, has an infinite supply at zero cost save the nominal costs a business has to transport cans from the kitchen's infinite pantry... or they can take a single can and build their own infinite pantry... well, all metaphors break down if you try to map their attributes 1-to-1 onto the target domain. In this case though I intend the metaphor to extend only to the labor aspect of running a soup kitchen because that is a significant & necessary aspect of keeping it going, as with OSS projects. OSS projects have an advantage over soup kitchens in that non-labor resources are proportionately very small.
The point is, the businesses are abusing the social contract. The unspoken agreement is, that the item is for people who cant afford it. The businesses can afford it. They just see that its free, so they are taking advantage of that fact.
Yes, some licenses explicitly allow the business to do that. However I don't think some developers take the time to actually think about what their license means, and they end up giving up more rights than they would if they had a better understanding. If you told an open source developer that even AGPL allows commercial use, some might be surprised by that fact.
I think I see the social contract differently, that it has evolved over the decades as OSS has permeated software culture. At this point in OSS history I do think developers generally understand what their license means. It seems like a developer would have to ignore most industry news to avoid having at least a general understanding that different licenses have commercial implications.
As such, I don't see it as abusing the social contract when a business-- even a massive FAANG-- uses software with licenses that permit commercial use. I would certainly prefer that they give something back to those projects either in dev time by their own paid swe's working on the project or financial support. The later simply isn't possible though if the project has not set itself up in some way as a formal organization. GAAP doesn't really have a way for businesses to account for financial support to non-employee individuals when it isn't either a contractor relationship or formal non-profit status.
If a developer does not understand the broad distinctions between licenses (such as the AGPL) then I have some sympathy for them if they make choices early on that don't align with their financial goals or social values. They should change their license in, if possible, a non-disruptive fashion. However I also regard such a situation as an easily avoidable mistake.
In general I think it is fruitless to look at the status quo & rail against businesses that violate whatever you may perceive to be unspoken agreements or social contracts. It is highly unlikely to change businesses' behaviors. It would be much better for OSS developers to change their behavior so that it requires businesses to use their work in the way they intend.
I view the four freedoms of FOSS as personal freedoms. Rights granted to individuals. And, US Supreme Court rulings notwithstanding, don not regard businesses as having attributes of personhood. It seems like the arguments for support/compensation models for developers of OSS imply similar values, and so proponents of those arguments should spend their time advocating for developers to choose corresponding licenses rather than advocating for businesses to change their practices.
Expecting people to donate thousands of hours of unpaid labor toward anything seems a bit extreme. If it is considered whining to expect some compensation for what amounts to another full-time job, then we should not expect anyone to stick with it for very long.
It's whining to expect compensation when a person knew what they were getting into or decides to stick with it even after it becomes more than they thought they were getting into & complains about compensation.
Not sticking with it for long is exactly what I think people should do when it grows beyond their desire to devote so much time to it. If I created a charity and it grew to the point where I didn't have enough time to run it, and couldn't get enough donations to cover my financial needs if I stopped my normal job, I wouldn't write blog posts about how "The model for running charities is broken because volunteers can't get paid enough to keep them running!" If no one else was interested in running it I'd scale things back or gently, perhaps regretfully, wind things down.
An OSS project is essentially a charity organization. And, while developers may not like it, charitable organizations that reach even modest sizes have to spend a significant amount of time soliciting donations & volunteer time. St. Jude's couldn't function and wouldn't be such a highly successful charity without having built up such a newtwork and put in that effort.
OSS doesn't need a compensation model because one already exists-- that of other charities. For projects that get large enough to start experiencing problems like this I'd encourage them to incorporate as a charity, a 501(c)(3) in the US. That gives them an excellent pathway towards covering labor or other costs and provides an excellent pathway for corporate users to contribute financial resources in formal & tax deductible fashion than when someone puts up a paypal donate button or similar.
Oddly enough, that's been most of my career. A fair number of people have paid me a goodly amount of money to install and keep running OS software, and to answer questions from people using it. When I discover problems, I report them to the original developers, including a patch if at all possible.
There aren't different degrees of open source. Either your license meets the OSD or it doesn't. What companies get vilified for is choosing licenses that are unambiguously not open source, but then trying to capitalize on the trust and goodwill associated with open source anyway.
The source code for Windows is public and available.
No its not.
The negative reaction to Elastic was not because they changed their license, but because they made their own proprietary license, rather than an understood OSI-approved license, like AGPL.
We need to make it dead simple for companies to open source their code. And we need to popularize the hires that happened because of a company's open source, or their outreach in the FOSS community. An organization dedicated to this work could have a huge impact.
As far as I'm aware, not all foundations pay their core contributors, including the Rust Foundation.
On top of that, we don't have any big tech company in our board of directors and never will, this is another difference with the Rust Foundation (and many others).
imho, you shouldn't care whether companies make money from your code. licenses won't stop them - take a look at Linux.
if your whole deal is to stop companies from using your code for free, consider never releasing the source code at all. :shrug:
> Open source is becoming a corporate-only game. It’s used as a weapon between battling tech companies.
i wrote a little bit about this: https://j3s.sh/thought/drones-run-linux-free-software-isnt-e...
> if you’re an open source advocate. Tune down the rhetoric. It isn’t helpful.
i think the author should consider who they're blaming and why.
But the bait and switch, and the retail "loss leader" practices? Hundred percent. He gave some good examples, but some others you might not have thought about are Google and Chrome, and Microsoft and VSCode.
We're already approaching Chrome being your only choice, and what do you think Google will do on that day?
Much more difficult to get to is VSCode being the only game in town, but I can imagine it being the only one that matters at some point.
Would it be better if VS Code was completely closed source?
Same with his Android example. It's _technically_ open source, but not for most practical cases (similarly with VSCode, there's a version you can download right now that's fully open source, it's just not very practical).
I don't believe this is the case for most OSS. Many of these companies (e.g. Sun) had the greatest intentions, however at some point the purpose of a company is to make money.
Some (like Automattic) are lucky enough to do this through hosting and/or a marketplace, but for most it will be some form of open/closed model or lock-in.
Whenever I see a company whose product is OSS take on investor money, to me that is a red flag for the longevity of that OSS software.
As far as making money, governmental and educational programs should hire technical professionals who keep their open source systems secure and updated, and who also contribute updates and improvements to open source code.
Yes, this cuts the investment capitalists and monopolistic tech corporations out of the taxpayer-financed public sector, while also improving the quality of governmental and educational programs, and likely saving on expenditures as well. Sounds like a win-win.
I'm conflicted with this statement. In 2008 I was consulting and I had a longer, than usual, backlog of work at the time. I would drive to my clients and remember the dichotomy of what was coming from the radio and my situation. It seems as though some organizations view consulting as a cheaper way to get things done in tighter financial times - I'm curious how the next few years play out, but I would gather that open source solutions, and the consulting around them, goes up as organizations look to cut op and capex.
As a broke college student, I revelled in free-as-in-beer Linux, emacs, R, and LaTeX. Now that I'm on the other side, I can't help but regret Torvalds and Stallman giving away the farm (yes, I'm inclined to take not give). As much as we hated Microsoft in the 90s, it was an economy in which a coder's skill translated directly into shrink-wrapped profits. Now we're all coding in service to high-latency cloud crap and selling customer data.
licenses and "for profit" mindset has to disappear asap, just like with patents, bottleneck of humankind
let the knowledge be shared and known by everyone, let people unlock what's yet to be discovered
This is a common misconception. "Very few" is subjective, to be sure, but using a de-Googled device is not only possible for enthusiasts, but for anyone willing to make a minor effort to look for alternatives, of which there are plenty. The F-Droid store has many high quality apps, and Play Store apps can be installed via the Aurora Store. Even if they depend on Play Services APIs, projects like microG work pretty well to bridge the gap, and notifications and even banking apps work well over it.
The more difficult change is abandoning the Google / Meta ecosystem of services, but you can always use the browser or another device for these. There's no support for paid apps, unless you want to keep using your Google account with Aurora, or apps offer alternative payment options.
I've been running GrapheneOS on my main device for a few months now, and /e/OS on a secondary one for years, and haven't missed or needed to depend on any Google services.
easy for software to commoditize hardware... hard for hardware to commoditize software. (Spolsky 2002)
Linus effectively killed the golden goose of writing OSs, a super-difficult task that deservedly propelled Gates and Allen to the stars.
All it takes is a college kid and a laptop to ship software. I wouldn't know where to start building and shipping chips and circuit boards. And that's why Azure, not Office, is where Microsoft's placing its bets.
They had to release those sources after the fact because they didn't change the license in the general release.
and other 3rd party GPL dependencies.
1) RoboVM had to use the GPL license because they used other people's GPL code - which they presumably pulled out / rewrote themselves in their new closed-source version
or
2) the author mistakenly believes that RoboVM is bound to the terms of the GPL license, or forced to offer new GPL licenses, on code they own 100%, just because they have offered GPL licenses to other people in the past
You do not need to grant yourself a license to distribute your own works. You always had that right.
Besides, who would sue you? The only person who has standing is the copyright holder. You're gonna sue yourself because you failed to honor the terms of a license, which was granted from yourself to yourself?
If they didn't own 100%, then see 1).
That doesn't make it desirable, but I hope it helps to explain it.
1. Go outside
2. Look up!
3. Take a picture !
Now you have a hi res photo of the very beautiful sky of Planet Earth . For free !
I mean, if a person is only ever going to write a single blog post, then yes, absolutely, post a personal photo of something beautiful. Why not? But if a person might post more than one blog post, then presumably there's some motivation to tying each (required) photo to the post in question in some way, even if tangential, right?
> "take a picture of anything, every time you make a blog post!"
If you're saying one can actually find things relevant to my blog posts by doing that, I'd love to hear more. Because it doesn't seem plausible to me.
Using AI images isn't really as easy as one may think. It takes a couple minutes to generate a large image, and sometimes the AI messes up. A couple iterations later, you've already used 20 minutes. If I could generate better images with a camera pointing at random things around me, please enlighten me on that.
PS: I don't think anyone is compelling you to reply -- you chose to do so.