[circular_logic]

I think these collectives would end up behaving much like the music industry in terms of chasing licence fees, suing orgs for infringement, and having too much power on what cut was handed down to developers.

Personally I would rather software be Free than have a unavoidable middle man taking a % cut.

[rndhouse]

I'm working on developing a solution along the lines outlined in the article. But I think there's a way to decentralize the "FOSS collective".

I've been working on OpenFare where payment plans are defined in code. Check it out here:

https://github.com/openfare/openfare

[commoner]

While I appreciate that you've released a new source-available license to the public, the OpenFare License as described in the README is not free or open source.

FOSS software can be sold, but if the software license requires the user to pay to continue using it, the software is not free because it does not unconditionally grant the user the freedom to run it:

> The freedom to run the program as you wish means that you are not forbidden or stopped from making it run.

https://www.gnu.org/philosophy/free-sw.en.html#run-the-progr...

That restriction also means the software is no longer open source, since it discriminates against commercial users who do not pay:

> The license must not discriminate against any person or group of persons.

> The license must not restrict anyone from making use of the program in a specific field of endeavor. For example, it may not restrict the program from being used in a business, or from being used for genetic research.

https://opensource.org/osd

Source-available licenses are a middle ground between proprietary and FOSS licenses, and they certainly serve a purpose. But, they're not FOSS licenses unless they allow the user to use, modify, and redistribute the software without exception.

[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

[rndhouse]

I don't claim that this is a free or open source license. The OpenFare license is about monetizing software in the most convenient way possible. I agree with the open source definition as given here:

https://opensource.org/osd

[josephcsible]

But if your license isn't open source, then what good is it for monetizing open source programs?

[rndhouse]

I think the entire point of the article is dual license FOSS and some other commercial license.

[josephcsible]

Of the root article, yes. But it doesn't sound like that's the intent of your license.

[eeZah7Ux]

No thanks. This approach violates the spirit of FLOSS by encouraging developers to focus on popularity rather than quality in order to make bank.

It takes away the collective aspect and replaces it with extreme individualism. There's already a software model for that: closed source.

Also, you posted the same URL many times. Please do not spam HN.

[rndhouse]

Sponsorship and donations are the popularity driven funding mechanisms. I want to fund the unpopular long tail of software maintainers (like the log4j guys who were not well known before the incident).

I want to fund maintainers based on whether the software is *used* commercially or not. Not on whether it's popular or not.

OpenFare doesn't lead to extreme individualism. It aims to fund collaborative software development. The OpenFare scheme is flexible enough to reflect how the collective wants to manage funding.

The OpenFare is *equivalent* to the MIT License in non-commercial settings. It isn't even close to a closed source license.

[tpoacher]

> The OpenFare License is a lot like the MIT License. The code can be modified, forked, reproduced, executed, and compiled without restriction by anyone. With two exceptions: > > Commercial users are subject to payment plans defined in code. > The license and payment plans can only be modified by the license copyright holder.

I like this idea in principle! Of course, enforcing it is another question altogether, but ... a step in the right direction, nonetheless.

Question, why does the payment plan appearing in the code rather than in the license make a difference? Assuming you're not allowed to distribute/modify etc without also including the license, does it matter where the payment plan is coded? Or am I missing the point here?

[rndhouse]

There are many advantages to defining the payment plan in code. Whether it's defined in the OPENFARE.lock file or the LICENSE file only matters for the sake of simplicity. The LICENSE needs to be the same across many packages so that it can be approved by lawyers once.

The idea is to put (very narrow) customizations of the terms in the OPENFARE.lock file.

[cycomanic]

What evidence do you have that these collectives would behave like the music industry? Generally the music industry does not go after the large companies, but instead after small individuals.

In contrast the collectives would go after large corporations which profit in the billions from volunteer work without giving significantly back. In fact the argument that situation is that currently you're paying the middle man (those corporations) without the actual creators getting anything.

[anaganisk]

Thats what Trademark, Copyright, DRM, WhatsApp ToS and all claim. “We want to protect creators/snail businesses ”, but they end up as tools to go after little guys.

[tpoacher]

One one hand, given human nature and evidence thus far, I would agree with your worry.

On the other hand, the music thing is a mess partly because of ambiguity of what constitutes use (e.g. is a coffee shop video infringing because a piece of music was heard in the background?)

I would hope that things are not as ambiguous with code libraries. They are either used or they are not.

Having said that I can see shit hitting the fan with arguing over what constitutes a fork vs derivative work etc.