[tzs]

How do you fit AGPL in with the freedom to run the program as you wish, which is explained in the gnu.org link you gave as:

> The freedom to run the program means the freedom for any kind of person or organization to use it on any kind of computer system, for any kind of overall job and purpose, without being required to communicate about it with the developer or any other specific entity. In this freedom, it is the user's purpose that matters, not the developer's purpose; you as a user are free to run the program for your purposes, and if you distribute it to someone else, she is then free to run it for her purposes, but you are not entitled to impose your purposes on her.

Suppose I find an AGPL program that takes a photo on standard input and does interesting transforms (like the effects Apple Booth and many chat programs support), I tweak the code a bit, and I hook it up to a camera and write some glue scripts that take a photo with the camera, apply a transform selected by pressing a button, and print the results which I put in a nice frame. I build this all into a booth and put it an a mall and use it to sell fancy framed goofy transforms of people.

All fine under AGPL. I don't have to tell the people who come to my booth that I'm using AGPL software or tell them where to download it.

But then I make it so if your mobile device is using the mall WiFi hotspot, you can upload a photo from your device to have my system make your goofy framed transform photo. Now AGPL requires me to tell them I'm using AGPL code and make the download available.

So...the requirements change depending on how the inputs are supplied?

If the inputs come from the camera hooked directly to the computer, I can use the tweaked AGPL program for my purpose (making goofy framed photos) "without being required to communicate about it with the developer or any other specific entity", but if the inputs come through the mall WiFi I do now have to communicate about it with a specific entity (whoever supplied the inputs)?

[commoner]

Section 13 of AGPLv3 lays this out:

> Notwithstanding any other provision of this License, if you modify the Program, your 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.

https://www.gnu.org/licenses/agpl-3.0.html#section13

In the mall example, this requirement can be fulfilled by having a link to or an attachment of the source code on the interface that facilitates the photo upload. The developer does not have to communicate with the user, since the requirement applies to the software ("your modified version") and not to the developer.

When a software license requires the source code of the licensed software to be released, that does not make the software unfree. This is because allowing users to access source code is one of the goals of the free software movement, as well as a prerequisite for freedoms 1 and 3:

> The freedom to study how the program works, and change it so it does your computing as you wish (freedom 1). Access to the source code is a precondition for this.

> The freedom to distribute copies of your modified versions to others (freedom 3). By doing this you can give the whole community a chance to benefit from your changes. Access to the source code is a precondition for this.

https://www.gnu.org/philosophy/free-sw.en.html#four-freedoms

[tzs]

Note though that if I don't provide the WiFi access option the person using my goofy photo service does not have to be given access to the code.

The document you cite on the four freedoms says "A program is free software if it gives users adequately all of these freedoms. Otherwise, it is nonfree". Does that mean GPLv2 is not a free software license, because it only gives users all of those freedoms when someone is distributing the program?

The issue is how to define "user". GPL (and pretty much everything else before AGPL) keyed everything off of distribution. The user was someone who had a copy of the program. Mere interaction with a running copy of a program did not make the interacting person a user.

With user defined thusly, GPLv2 is a free software license. If I do something to make you a user (i.e., I distribute the code to you) GPLv2 ensures that you get all four freedoms.

If we expand user to include people who are interacting with someone else's running copy, which it seems we have to do to make AGPL fall under freedom 0, then (1) it becomes hard to argue that licenses that trigger only on distribution can satisfy the four freedoms, and (2) it doesn't even do a good job with AGPL because AGPL only ensures the four freedoms to those who are users by interaction when that interaction is remote and through a computer network. It completely drops the ball for users by interaction who aren't interacting in that specific way.

[commoner]

AGPLv3 refers to "all users interacting with it remotely through a computer network", not "people who are interacting with someone else's running copy". If someone adapted AGPLv3 into a new license that requires all "people who are interacting with someone else's running copy" to be able to access a copy of the source code regardless of whether the interaction takes place over a computer network, that new license would still be free and open source. The FSF has not bothered to write such a license yet, but anyone can do it.

This part of the FSF's page on free software endorses this type of rule:

> Rules that “if you make your version available in this way, you must make it available in that way also” can be acceptable too, on the same condition. An example of such an acceptable rule is one saying that if you have distributed a modified version and a previous developer asks for a copy of it, you must send one. (Note that such a rule still leaves you the choice of whether to distribute your version at all.) Rules that require release of source code to the users for versions that you put into public use are also acceptable.

https://www.gnu.org/philosophy/free-sw.en.html#packaging