74 replies
4d15h
The AGPL license permits free use, modification, and distribution of software, provided that distributed, derivative works of the software are released under the same license.
Here is the rub: free software permits unconditional use.
The GPL without the A, or MIT or BSD licenses are not EULAs; they place restrictions or conditions on redistribution, not on use. (With regard to use, they have only certain liability disclaimer clauses.)
The AGPL restricts use; it is an EULA: end-user license agreement. The antithesis of free software.
Genuine question, how does AGPL restrict use? From my reading of it, it is only ensuring that any modifications to the source code must be made available if you "distribute" the software, where distribution now includes hosting it as a service.
It seems more or less in the original spirit of GPLv2 but updated for a SaaS driven world. If you consider v3 restrictive then you must also consider v2 restrictive, just in a more narrow way.
Running a program, as a service or not, isn't redistribution. It is use.
The original spirit of the GPL is about identifying people doing bad things we don't like and trying to prevent them. All those bad things have to do with redistribution, not with using the program.
The AGPL is still about identifying people doing bad things we don't like, except now those people are just running the program.
This is no different from Adobe, Apple, Microsoft, ... identifying people using their software in ways they don't like, and crafting their EULA terms to turn those activities into a license violation.
A free software license simply cannot dictate uses, like where and how you run the program, and who can access it from where.
A free software license can only use copyright law, and only be concerned with copying.
EULAs go beyond coypright; they try to connect non-copying activities to copyright by the doctrine that if the user engages in the forbidden activities, their license is terminated (and thus it becomes copyright infringement for them to continue to have a now unlicensed copy of the software).
Its the same "bad thing" as distributing a modified binary without the source. Its a way of denying end users access to the source code.
You can do whatever you like with AGPL code, as long as you make the source available.
it is VERY different from saying "you cannot do this with your software". It is just changing the conditions under which make source available is required to keep up with how people use software has changed.
AGPL is nothing like a EULA. It is a license, not a contract. It is very similar to the GPL
The AGPL is absolutely a EULA.
The user of a program is the one who installs it somewhere and runs it.
Outside people interacting with the program are visitors. They don't have the source code because they don't have the program at all in any form. It has not been distributed to them.
The source code to the program doesn't even do them any good. They cannot use that to prevent harms perpetrated by the operators of that application.
A EULA needs to be a contract. THe AGPL is clearly not a contract nor does it meet the basic requirements for an enforceable contract in common law countries. Can you show me where I am wrong about this?
It does. It means they can run their own instance instead of being permanently tied to the operator of the service. It means they can modify and run the software.
That is sophistry. For the type of software AGPL is designed for the functionality provided is the same as it would if they had their own install. It is called "software as a service" for a reason.
The reason the AGPL exists is because the rise of SAAS has made the distinction you are making meaningless.
Users of GPL software do not "have to program". The point is they can. The same is true with AGPL.
Sorry that was a typo we should have said "do not have the program" (corrected).
But no the same is not true of the user of the AGPL. The GPL user having the source code and being able to program or hire somebody is utterly meaningful. That user controls the installation of the program. They would like the program to do something differently, or not to do something unwanted. With the buildable source code they can achieve that.
The visitor to the AGPL application have access to the source code has no meaning at all. They don't have the administrative access to replace the implementation (and even if they did, that was just create conflict with the other ivisitors).
The ability to set up your own clone instance its completely meaningless. For example suppose that's some government service website is using AGPL software. What do you gain by downloading the software and running your own instance? That's not where your data is; you can't use that cloned instance to communicate with the service agency.
It is the AGPL that's using outdated concepts in a new context where they don't make sense. (Licensing helped us win the open source war in the 1990s and 2000s, so it'll work this time too right?)
You also may be thinking of the software of being something like a photo editor or word processing application that is hosted, but in which the visitor works with only their own files in isolation from other visitors, and from the site operators. I don't think that's the main target for the AGPL. That may be called "strawman AGPL". I tend to agree that the AGPL may be effective in this limited situation. But effective is not the same as free. A "free for personal use" software license is also effective at achieving the aims of its purveyor but isn't free.
Isn't that the whole point?
Yes. But that point doesn't help the users since they don't have the data.
It helps in strawman cases when users have the data, and the platform doesn't have social features. For instance, oh, an online photo editor used by the user in isolation, on either local files or easily downloadable files. User doesn't like that instance, so they find the AGPLed source code and run their own, bringing all their files.
(Why, in that situation, would the user be entitled to the custom modifications in that instance they are abandoning? If you don't like that instance for whatever reason, but like the features, tough luck. Code your own.)
Why would the user be entitled to the commercial SAAS platform's custom modifications?
Because the platform provider didn't pay for the database's commercial license.
Nope. It can just be a piece of text you agree with when opening a classic mass-marked app in a shrink-warpped box ("shrink-wrap EULA") or a dialog box with text where you have to click that by using the software, you agree with the licensing terms.
Exactly the same as when you deploy an AGPL program for visitors, you are agreeing to its EULA.
which is exactly what a contract is.
It's an agreement between different parties.
Regardless, it can't be the case that the GNU Affero GPL is not a contract, whereas some Microsoft EULA is, or vice versa. They are an instance of exactly the same category.
https://perens.com/2017/05/28/understanding-the-gpl-is-a-con...
It might be a ULA, but it's hardly an EULA. The party hosting a web service is not an end user. The end user is that party's customer.
I'm still not following - you're talking about restrictions on use, but what restrictions on use does AGPL apply? What can I not do with AGPL software? What are the forbidden activities you reference?
The only caveat seems to be making the source code available to users of the software, which is also the case with GPLv2, just under narrower conditions.
I have no dog in this race, nor any particular attachment to any particular license, I'm just trying to better understand what these restrictions are that you're referencing.
No it isn't; under the GPLv2, the source code must be available to those to whom compiled code has been redistributed. Whether they are users doesn't matter.
The restrictions are that if you violate the license, your use of the program is infringing.
You cannot change it and run it yourself, without hosting the source code.
You cannot combine an AGPL program with proprietary code and operate it, because you cannot release the proprietary code.
So your point is that people should be free to take whatever they want for free and dont't contribute back? I'm glad there is a license made to put a limit on people like you then
I've spent thousands of hours writing code which is under the BSD license. Nice try trying to make the argument about me.
(I've not put anything under even the dubious GPL license in over 15 years, and never will.)
Yes, a free software license must not require people to "contribute back", or anything of the sort.
For instance, a "free for non-commercial use" license is not free. Even the people who came up with the AGPL understand this, and go to great pains to explain it.
I understand the social problem that the AGPL is trying to combat, whereby visitors are held captive by saas applications over which they have no visibility or control.
The AGPL approach is to use the power of a non-free license against the problem which makes it a cure worse than disease, and repugnant to developers of truly free software.
It's almost certainly the case that the saas problem cannot be engaged via software licensing terms, if those terms are to amount to a free software license.
I don't have a better idea, either, but that doesn't change the fact that the AGPL is a non-free license which crosses over into governing use rather than just redistribution.
Also one issue is that the AGPL doesn't actually solve anything. Visitors having the source code to my evil saas platform doesn't solve the problem that they're locked to it. It doesn't solve the problem that I can change the code at any time and they cannot. Or that I can shut it down and wipe out their data, or share it with third parties. An AGPL conforming application also need not provide visitors with any way to export their data.
Please enlight us about how the BSD license do it much better in this area. You first complain that AGPL is restrictive now complain that it should restrict even more? I agree with you, maybe it is time for another version of AGPL that includes data sovereignty. Let's make it more difficult for corporations to profit from FOSS free labor, not more easy.
It doesn't, but it's a starkly free license which lets you do almost anything you want, short of plagiarism.
Nope; I'm explaining that it's ineffective against the key harms that may be perpetrated by SaaS. No license is; licensing is the wrong tool.
This was in fact Stallman's original vision for Emacs.
https://www.oreilly.com/openbook/freedom/ch06.html
"It is distributed on a basis of communal sharing, which means that all improvements must be given back to me to be incorporated and distributed."
Yes I can. It's only if I let other people use my changed code that they become entitled to a copy.
hmm, gotta say that sounds like the proprietary code is the thing infringing on my usage.
Well no, someone combining the proprietary code with the AGPL code infringes if they run that code such that it is exposed to visitors.
Depending on the license of the proprietary software and who is creating the software derived from both of them, that derivative work could easily be in violation of both licenses. lol
Question (IANAL), but isn't it also the case that you can't combine AGPL code with GPLv2 code? Like maybe you write a patch that glues Minio's (AGPL) and Git's (GPLv2) source code (I just picked the two first projects that came up when searching for those licenses).
Maybe your glue patch can be dual-licensed and that specific patch wouldn't have any problems.
But since (1) both licenses are viral and require that everything touched by them is licensed under that exact license; and (2) you are unable to change either project's license; then it seems to me that you would be unable to release your patch since it wouldn't be considered independent.
Or if you can release your patch as a separate project somehow, I think you still wouldn't be able to host this modified version of Minio because you can't satisfy both licenses at the same time.
So, expanding on your message:
(My addition) "You cannot combine an AGPL program with other open source software, unless their license is compatible with AGPL (e.g. MPL 2.0 or GPLv3)."
My understanding might be wrong though, because IANAL and these licenses are unapproachable to a mere mortal like me, but I just wanted to point out that AGPL also prevents combining with other open source software even if their license is another GNU license.
This is not how I see it at all. The ones using it are the users, and if they sit across the network you are distributing it in a very tangible sense.
The idea that the admin running a service is the one doing the "use" and not the users of your service is debatable to say the least.
So when you compile a program and distribute over the network as a binary, you are also distributing the compiler that created the binary?
From section 13 of the license (https://www.gnu.org/licenses/agpl-3.0.en.html):
From the Merriam-Webster dictionary:
When distributing a binary from a compiler to a user, the user does not act upon the compiler. So the user is not interacting with the compiler, so you don't need to distribute your modified compiler's code any more than you would with the GPL.
That's not what is in question. Of course if you someone has reason to comply with section 13 of the license, then users who download the code are having the code distributed to them.
The disputed claim is that users who interact with a remote program are, by that interaction, being distributed the program.
The GNU AGPL itself explicitly disagrees with this; check its definition of "propagate" and "convey".
Depending on the license of the compiler, yes, the binary is related to the compiler in some way. In practice it literally contains code from the compiler.
The admin uses the software, regardless of who else is regarded as a user.
Among the users, the admin is the one saddled with use restrictions by the license.
The users of the software (not just the admin who is serving the software over a network) has the right under AGPL to request for the source.
That is false; the license doesn't speak about any such right.
Rather, the copyright holder of the AGPLed work is exercising their right to dictate the following:
[Y]our modified version must prominently offer all users interacting with it remotely through a computer network (if your version supports such interaction) an opportunity to receive the Corresponding Source of your version by providing access to the Corresponding Source from a network server at no charge, through some standard or customary means of facilitating copying of software.
Under the AGPL, the visitors to the program need not request the source; it must be prominently available for them to obtain in a self-serve manner. No mention is made that they have any kind of right. They are not parties to the license at all. A copyright license can only grant rights to licensees.
By the way, "all users interacting" could be interpreted to literally mean all users, including users who visit the login page, but do not have an account (and are not authorized to have one due to not belonging to the organization that runs the service).
Hard disagree. You're redistributing the software in a manner for people to easily use it.
If you rip a movie you own, there's no distinction that I'm aware of in copyright law between hosting the .ISO on an FTP server and hosting the .MKV as a stream. They're both redistributing, it's just that one is designed for ephemeral consumption.
That analogy does not work because in all the cases you describe a copy of the movie ends up with the viewer.
When you connect to a remote server over a computer and upload data and receive back results produced by the server software you do not receive a copy of the program. You receive a copy of the output that the program produced.
> They're both redistributing
Well, yes. While perhaps some metadata is lost, the content that is worth fighting for is captured in both cases. Practically speaking, there is no difference between the original source, an ISO rip, and an MKV rip. At least to the untrained eye, they are in every way equivalent. They both are redistribution, indeed.
That is not the case for SaaS in question. What you download during use can in no way be reconstructed into its original form. You can't use the software for a while and then, from what you've collected, start running the software on your local machine. The artifacts of use are very different from the software itself. To stick with your analogy, watching a movie on Netflix does not give you a copy of their server software. Distribution has not occurred.
That's broadcasting. The recipient of a stream can capture the film to create their own .MKV they can further stream or pass on.
Equating the running of a program with broadcasting is the kind of sophistry we might expect from Apple or Adobe or Oracle or their ilk.
Certain portions of a service program may be broadcast, like for instance certain string literals carrying text that appears at the remote end point. The bulk of the software is not transmitted. It transmits and receives messages, which are mostly not that program. The remote end cannot recover a copy of the program from these messages. Some bits of literal data, but none of the code. (There are obvious exceptions, like programs transmitted to web browsers for local execution.)
It's not. It's about making sure users can fix the bugs in the software they want or need to use, and share those fixes with others. Rules about redistribution are a means to that end.
The GPL was originally written in an era of mainframes and terminals, the idea of running a program via some intermediate system is not novel. But no-one in that era would have dared try to argue that a program hadn't been distributed to you because it was running on a machine in a different building rather than one under your desk.
If you make your equivalences broad enough then anything is equivalent to anything else. "This license is written in text, making it no different from that license that is written in text".
You're confusing ends and means. The free software movement was actively opposed to copyright law and wanted software to be uncopyrightable. But that was no reason not to use a copyright license that served their goals.
The GPL is not simply about fixing bugs. It's about preventing the existence of versions of the program in which you cannot easily find or fix bugs, and the underlying ideology that they should be no such programs. And not only bugs but deliberate undesirable or malicious behavior. The problem with closed source proprietary software is that you don't know what's hiding in the binaries.
If software were uncopyrightable, they would still be binaries without source code, which you would have to reverse engineer to find out what harm they perpetrate actively or possibly through their security flaws.
Moreover, if you wrote a piece of free source code, anyone could do anything with it they wish, including removing your name, and not attributing you in any way in the documentation accompanying the compiled code.
Stallman was a control freak who insisted that people modifying his code give back the contributions to the project. In the world without copyrighted programs he would have had no leg to stand on, and he knew that. A world in which programs are not copyrighted would need laws which ban the distribution of binaries without buildable source code, and all the tools needed to build it and their source code.
A program is not distributed to you if someone else installed it on a machine you don't own and you're just borrowing that machine. It doesn't matter if you're physically at the console, we're at a remote dumb terminal or smart client. The program was distributed to your school, company or friend or whoever.
I don't think that even the people who drafted the AGPL believe the nonsense doctrine that the visitors to a server have been distributed the software. That's just something invented by the downstream AGPL apologists. (And of course vendors of proprietary software like the doctrine also. If you buy a program and let 10 people use it via remote access to your machine, they would like the legal system to believe that those people were distributed the program and that you should buy ten more licenses). The doctrine is not required for the AGPL to work. The software distributed to the individual or organization installing it and running it for visitors. The license is concerned with the behavior of that individual or organization, and uses the power of copyright to make their permission to have a copy of the program conditional on their usage behavior. The visitors to the running application are not parties to the license.
The GNU AGPL contains these definitions:
True. But reverse engineering could happen openly, and tooling for it would improve. The benefits would outweigh the costs.
Depends where you are. Many jurisdictions recognise attribution as a "moral right" separate from copyright.
Up to a point. If you pressed the "buy" button, paid the money, and are using it from your machine like a program, then it shouldn't matter where it's metaphysically located. Plenty of software will "phone home" to company servers or even falsely claim to be running computation on the company's machines (SimCity), but that doesn't mean the software hasn't been distributed to you. Just as the courts don't allow you to stream TV from an OTA capture card in a remote datacenter and consider that to be OTA viewing, having a program that you use from your local machine do some of its execution in some remote datacenter (whether through VNC-style remote access, a web UI, or something else) shouldn't make it any less your program that's been distributed to you and that you're using.
The AGPL does not restrict running the program. Only if you run modified versions, things get complicated.
That being said, I think the AGPL is only appropriate for programs that come with a built-in source redistribution mechanism that ensures that modified versions automatically comply with the source code redistribution requirement.
You realize that would create a problem for some organization whose idiot employee combined proprietary code with the AGPLed program and the thing automatically redistributed the whole infringing mess to the world.
Even if there were safeguards against such a situation, someone would blow past them.
It does not. You can absolutely host AGPL software as a service, you just have to share any modifications you made with those that use the service.
Sure, and you can absolutely use Photoshop, if you paid for it, and promise not to reverse engineer anything.
Or, what do you think usage restrictions are or look like?
If you don't share those modifications then you must not host that software such that it communicates with visitors; that's a restriction.
The modifications that you are required to share cannot be any arbitrary modifications; anything you add has to be AGPL compatible.
If the modifications combine the software with GPL-incompatible pieces, then you cannot share those modifications, which means there is no legal way to host that software for visitors.
Copyright covers four rights. The right to copy, the right to modify, the right to distribute, and the right to perform publicly.
The GPL places restrictions on a combination of the modification and distribution aspect, which says that if you modify the software and distribute it, then you must also include source code.
AGPL is more strict and says even if you just want to modify it and use it, you must supply the source code to the people who are using it. The important point here is that this is not triggering on use of the software (as EULA implies). It is only triggered after modification. And modification is something that is covered by copyright.
It's triggered on use of the modified software. Not just any use but use in such a way that network visitors interact with the software. If you don't use the software that way, the requirement doesn't apply even if you modified it.
If you've not modified the software, interested visitors can just get the source code from the same upstream, so why would it be required of you to host it.
However the following situation could arise and I don't see how the license addresses it. You visited a site running some AGPL service which was modified by those site operators. You decide to clone your own instance using their modified code. Since you're not modifying anything yourself you're not required to host that code. Now suppose that original site shuts down and disappears. The upstream for that modified code is no longer available. Are you on the hook for hosting it now? You've not modified anything yourself.
Nope. Section 10:
Right, but suppose you disappear. The third parties are using code with your modification. Do they have to host anything? They did not modify anything themselves, but there is no upstream any more for the exact code they are using.
Agreed. In other words, the terms restrict what you can do when you modify not when you run. It is also not directed at end users (the "EU" of "EULA") but at the developer or sysadmin.
This is a common misconception about Free software. It's not about freedom of its users or authors, it's freedom of the actual code to be available for others.
For example, MIT license allows users to take the code and modify it without releasing modifications. This traps the new version of the software, possibly forever, inside a single organization.
Firstly, GPLed programs with proprietary modifications can easily be trapped inside single organizations.
The original MIT-licensed program continues to exist and be available regardless of the proprietary versions and embeddings.
A copyleft license just asserts, using copyright power, that such things should not exist.
MIT and BSD licenses just allow certain works to legally exist that copyleft advocates think should not exist. The copyleft is concerned with squelching the existence of things, whereas the MIT and BSD licenses mostly promote existence.
(They are concerned with squelching the existence of plagiarism: an author's name and copyright notice removed from the source code work, and possibly replaced with another. Also, squelching the situation where the compiled work is accompanied by documentation which neglect to give attribution to the presence of that BSD-licensed code.)
Well, a copyleft license asserts that proprietary versions and embeddings of the licensed software should not exist. GPL software doesn't assert anything about the existence of BSD-licensed software. Or at least, not unless you link them together into one thing.
It is true that rms would prefer that such works not exist. (Or that's how he felt originally, at least.) But the GPL is silent on the issue, as it has to be. There's no clause saying "the author promises not to release any software with a non-copyleft license, nor to name a child Dorothy, nor to eat the flesh of an aquatic mammal."
It's my understanding that the MIT license has no such restriction on publishing modifications. The only restriction is that existing code must stay MIT licensed.
Code lacks agency. It's not a person.
That‘s wrong. Free software is all about freedom for users. Stallman wrote whole essays explaining that.
Of course, back in his time, pretty much every user was also a programmer. But he is still very clear about that point, never writing about programmers when he means users.
It‘s also why people still fight their silly argument whether BSD or GPL is "freer". The BSD camp optimizes for developer freedom, the GPL for user freedom. Both camps think everybody sees the world their way (philosophically), so the other camp must be wrong and stupid.
I think you're wrong.
The GPL, at least, puts restrictions on use: you can't use the software in certain ways (e.g. use in a binary firmware blob) unless you distribute it in source form to the end users.
The AGPL does exactly the same thing as the GPL, just with a stronger distribution requirement: if you distribute access to end users, you must distribute it in source form to the end users.
The GPL was designed for the binary distribution age of software, the AGPL is the GPL for the SaaS distribution age. The GPL alone cannot satisfy Free Software goals in the new age.
Yes, you can. You can combine a GPLed program with whatever you want; you just can't redistribute the result if the combination runs afoul of the GPL.
redistribution is not use. Use is running the program, reading the program, trying changes and such.
You can combine GNU Bash with proprietary code and let users remotely log in to your box to try it.
There is no such thing. Copyright law does not recognize "distributing access". The program is not being redistributed when it executes and exchanges messages with remote stations.
"Distributing access" also reminds me of the idea of someone hearing the sound of your coins jingling, or smelling your cooking: as in from the famous case of Ōoka_Tadasuke that circulates as a popular parable:
https://en.wikipedia.org/wiki/Ōoka_Tadasuke#Famous_cases
Honestly, I'm getting the impression you're too being too rigid with definitions: anchoring too strongly in the incidental specifics of GPL as being "free software" while ignoring its goals.
The GPL promotes the four essential freedoms posted on the GNU/FSF website. They are not incidental.
There is a lengthy article by RMS "Why programs must not limit the freedom to run them".
https://www.gnu.org/philosophy/programs-must-not-limit-freed...
Nowhere does RMS say that, oh, if the user modified the program, it's okay to limit their freedom to run it in some ways, as long as it's via a license blessed by the GNU project and the FSF, the ultimate arbiters of what is free who can change their minds at any time.
However, in this article, RMS is cheerfully recommending Affero:
https://www.gnu.org/philosophy/who-does-that-server-really-s...
AGPL doesn't restrict use:
"You are not required to accept this License in order to receive or run a copy of the Program."
I would say that's an unhelpfully misleading statement in the license.
There exist obvious circumstances of the program's use with which the license doesn't concern itself, and does not speak to, and so in those circumstances the user is not required to enter into the license.
A redistributor must enter into the license because it's a derivative of the GPL, and so it has requirements related to distribution.
A user who runs the program in such a way that visitors communicate with it from remote stations obviously is required to enter into the license also and comply with its requirements.
The license is applied to programs for which this would be a typical use.
Only if the user modifies the program.
The remote network interaction provision of the AGPL is conditional.
Clause 13 could as well require the provider to offer the code to the network visitors even if the code is not modified.
That makes hardly any difference.
I looked at the context of this.
It's in a section whose purpose it is to make it clear that you don't have to accept the license just have a copy of the program, but that if you convey the program your implicitly accepting with the license, that license being the only basis for your permission to redistribute.
I think you're 90% right in what you say here and in following comments, but I think you're skewing things in a way where I end up disagreeing with your conclusions.
Why are you using the term "free software" here, when it has a well-defined meaning that is very much what you get with copyleft and the GPL and not what you get with BSD/MIT? I think you mean "open source", specifically open source as opposed to free software. Your terminology makes a lot of the conversation here unnecessarily hard to follow.
I don't see the AGPL as the antithesis of OSS at all, even though I agree that it is activated by a condition that pertains to use, not just redistribution. But that's the mechanism, not the goal. Just like the GPL relies on copyright law to have its effect, AGPL relies on what you're calling a EULA. (I don't disagree, and to me a EULA is a contract, but whether it's exactly the right term doesn't seem important.) GPL isn't alone in depending on copyright; the BSD license does just as much.
Agreed, but "redistribution" vs "use" is a mechanism argument. The intended purpose of the GPL was to allow a developer to write software whose future evolution is freely shared. The redistribution mechanism doesn't even accomplish this 100%: in particular it allows branchless twigs off of the evolutionary tree as long as they are indeed branchless (i.e., not distributed to anyone else who makes further modifications). That goes counter to the goal of free software, but is an acceptable loss because those twigs are irrelevant to the rest of the evolutionary tree.
But there's a loophole here when the GPL is applied to server software: if the software only runs server-side, then the redistribution mechanism no longer works. You could modify your copy, and give that modified copy to someone else who also modifies it. You would have to share your modifications with that person, but not to anyone else. Your twig can grow branches. Neither of you are redistributing the software to anyone else, so you aren't bound by the GPL to make your changes available to anyone else, and certainly not to the original authors.
The AGPL attempts to plug that hole using an extra mechanism: adding a restriction saying that you have to make your changes available not only if you're redistributing the software, but also if users are talking to the running code[1].
Sure. Those same companies depend on copyright law as well. But the purpose of the AGPL has nothing to do with people using the software in ways that the license chooser doesn't like; its purpose is wholly concerned with the evolution of the software and therefore the changes being made to it. That purpose is achieved via the mechanism of adding conditions based on usage.
That is correct. AGPL does not solve this problem. If you're locked into a service, then having the full version of the AGPLed code does you very little good. That is described as "Service as a Software Substitute (SaaSS)" in the AGPL explainer at https://www.gnu.org/licenses/why-affero-gpl.html
The free software folks had to punt on that problem. They "solve" it by saying: don't use those services. Which is hardly a satisfying answer, but nothing else is currently possible. Any solution would require regulation and legislation (eg data portability laws).
Incorrect (see above). Though I think some AGPL supporters did (and probably still do) think that the AGPL helps with that. I guess it does, in trivial cases.
This is all correct. Well, except the first sentence, because the AGPL does solve one thing: it ensures that the evolution of a piece of software is freely accessible.
Or maybe two things, though the second was not part of the original intention afaik: the ElasticSearch/OpenSearch situation. The original author develops something that their business depends on and does not want to end up competing with their own code. AGPL ensures that nobody can take their code, add some features to it, and then win their customers with the enhanced proprietary version. The original author will at least have access to all of the modifications that anybody makes, so competition will need to be on a different basis.
[1] It seems like it would have been more straightforward to keep the AGPL conditions based on redistribution, and say that you have to release your changes to everyone if you distribute your version to anyone. Would that even work? You'd have a transaction from A->B that induces a requirement on A->the world. But it would have avoided making conditions based on use rather than just redistribution. I dunno, IANAL. It would still allow someone to change the version that they're running without releasing the changes, unlike the current AGPL, but that's no worse than the situation with GPL'd client-side software and doesn't seem like a problem worth solving.
When I'm using the term "free software", I mean this:
https://www.gnu.org/philosophy/free-sw.html#four-freedoms
Straight from the gnu's mouth!
"The freedom to run the program as you wish, for any purpose (freedom 0)."
Yes it is. If you wrote a network program, and you specifically don't like the idea that someone can modify it and then host that modified version for users without letting them have the source code, then the AGPL is a tool that nicely expresses your intent.
Licenses don't care about their intent. People analyze what they do and use them accordingly.
For instance, the GPL has turned out to very nicely suit corporate interests. The copyright holder of a GPLed software component has a competitive edge over the licensees. They have to abide by the license and release all their changes, which you can help yourself to; meanwhile, you can have a proprietary version in parallel.
That gnu's mouth spoke 3 other clauses, and finished up with:
Ok, let's stick with "The freedom to run the program as you wish, for any purpose". We're talking about running the software here, not modifying it or hosting it. You can run the program as you wish. For any purpose -- what purpose are you claiming is disallowed? "For the purpose of running it on my server without giving out my changes" is not about running it, that's about something incurred as a result of running it. Which is unfortunate, I agree; it would be nicer if all obligations were only incurred when distributing it. But that still doesn't restrict the running part.
But never mind, this is too much of a semantic argument at this point. I was trying to understand why the AGPL bothers you more than the GPL. I get the argument that it triggers a condition based on usage rather than distribution, but given that the condition does not restrict the usage, I'm not sure why you care. Is it a principle? I agree that it feels a little messy, but given my understanding of the core goal of copyleft licenses, it actually feels to me to be pretty close to a minimal encroachment beyond the GPL that still satisfies the original goal of the GPL for server-side software.
Yeah, and my previous message didn't adequately cover this part. AGPL+CLA has a purpose and expresses an intent beyond the intent behind GPL. I'm personally more concerned with the evolution of the software I and others release, even if I find this corporate usage of the AGPL somewhat fascinating. If I understand correctly, your philosophical objections to the AGPL aren't based on this corporate scenario either, though?
You care about restrictions on usage and want as few restrictions as possible, so a corporation building upon BSD code internally without releasing changes doesn't bother you. But AGPL does bother you, because that corporation (or any other user) would need to consider the requirements of running that code. Do I have that right? (Or strictly speaking, running and modifying the code, since there are no requirements placed upon just running it if you haven't changed anything.)
The main problem is the hypocrisy: the FSF promulgating a non-free license as a free license.
On their website, they have a list of nonfree licenses, for which they give reasons.
Several are identified as nonfree because redistributors may not sell the code. Guess what: GNU Affero says you must make the modified code available free of charge. Thus, it should be listed in the nonfree license section for that reasons.
Several are identified as nonfree because they restrict use, such as that the software may not be used for human rights abuses. Oops, GNU Affero has use restrictions.
"My changes" could mean making minor changes to integrate it with 500,000 lines of my company's existing proprietary code, as well as third party proprietary code. Oops, that all has to be AGPLed if the combined program has network users. Which is a nonstarter, so such an integration shall not be made.
A GPLed program can be so combined and run for network users; nothing needs to be put under the GPL unless it is redistributed. How on earth can that be wrong, if the GPL allows it?
This is in accordance with Freedom 0.
I have no problem with the GNU Affero license existing, and people deciding that it's the best choice for their project. The problem is it being promoted and encouraged as a free license. People believe it. How could it not be free? Everyone says so, and it's from GNU/FSF.
Those who oppose the GPL are precisely the people it was designed to protect against.
I think we found a good example of your wishes here. You are against the GPL if you have an ulterior motive to make something proprietary and avoid contributing back!
My comment was about the AGPL, not about the GPL.
Though I don't favor the GPL for my own code, I would not call it "antithesis of free software". The GPL does not impose any use restrictions, and meets a reasonable definition of a free license in other ways also.
It also seems to violate criteria #10 of the OSI's Open Source Definition:
It has provisions that only apply to people who are interacting with the software remotely over a computer network. If they are interacting using some other technology those provisions do not apply.
Thank you for pointing this out.
It is logically obvious that the AGPL is a nonfree license. I have been saying this for some time.
It is a very unpopular thing to say.