[jan_g]

I don't know about ParadeDB, but this was very off-putting for me in case of Minio when they switched to AGPL. If you check their answers to various license questions, they are essentially this: if you use Minio in your stack/product (for profit), then we recommend our commercial license or consult with a lawyer if your use case is covered by AGPL or not.

What me and I guess many others wanted was a simple yes/no to the following: if I use Minio in my stack without modifications (as a file server that my other services interact with via an API), do I have to AGPL all the stuff the touches Minio or not? And they do not want to answer this question. I do not understand why is it so hard to answer clearly. I understand that the majority of opinions is that it's fine to use without modifications, but I wanted a clear statement from authors of Minio. Failing that, I then decided to keep the pre-AGPL version for a while and have transitioned away from Minio since then.

[brightball]

This feels like dealing with government agencies where you go out of your way to get clarification to make sure you are doing everything correctly, but they refuse to give a clear answer to they can bother you about it later.

[belorn]

Copyright does not have clear answers. Teachers has always wanted a clear answer to "how many pages can I copy from a book", and they usually get the same answer. There is no cleanly defined number of pages, but fair use do exist so they have to apply they own judgement in each case.

The same questions has been asked about how many seconds of TV/radio is fair to copy, for example as stock footage or in reviews. Many people will say something like "3-5 seconds generally accepted", but each creator has to apply their own judgement per case.

What is a derivative work is one of the most debated aspect of copyright law, likely only second to fair use debates. Only a court of law has any real ability to give a clear answer and then only to a specific case.

[hitekker]

A hilarious sentiment. If it's true, then these companies marketing their OSS creds are merely disguising their desire to be the next Oracle.

[ashkankiani]

Copying reply to a child comment:

"This License explicitly affirms your unlimited permission to run the unmodified Program."

In the Basic permissions of the actual content of the license https://github.com/minio/minio/blob/master/LICENSE

It's not that difficult to parse if you actually read it top to bottom instead of skimming.

[jan_g]

But you forgot to cite the next sentence:

   The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work.

So, what is 'covered work'? The license says this:

    A "covered work" means either the unmodified Program or a work based on the Program.

Do you still think it's clearly written license? To me it's dubious enough that I wanted an explicit answer from the authors of Minio. Failing to get it, I decided to move away from Minio.

[jasode]

>Do you still think it's clearly written license?

Fyi... a few Google employees talked about similar ambiguous interpretations of AGPL's terms and clauses by Google's legal team review in a past thread: https://news.ycombinator.com/item?id=23966778

[hitekker]

Nice link. One of the key quotes:

> Perhaps if random engineers stopped calling legal opinion FUD and falsehoods and took a moment to listen to the feedback from lawyers who didn’t write the license, we’d get somewhere with finding a palatable license for all parties. Instead, we get a holy war.

My corollary: an argument is not a document. When I need a strong resolution on an issue, I want in writing and in a single organized voice, not spread across a bunch of comments and commenters, whose goal is often to shout down doubts or to keep the peace between participants.

Besides the internet, I've seen "the-argument-is-the-document" occasionally inside companies and very strongly in a hype-driven programming language.

[kragen]

this is basically talking about compilers and things like dumping a memory image from gforth or emacs

if someone said 'no, the output from my gpl-licensed compiler is never covered by the gpl', then would-be infringers would have an easy escape from the gpl: just compile the compiler with itself, and its author guarantees that the compiled output isn't covered by the gpl! so that's why the fsf carefully says 'only if the output, given its content, constitutes a covered work'

similarly, emacs or gforth has the ability to dump a memory image after loading up a bunch of source code and compiling it to bytecode; that way it can instantly load the image without taking the time to recompile all that code. this memory image includes all the code that's loaded, including not just your code, but also all the standard library code that comes with the system. but that shouldn't give would-be infringers an easy escape from the gpl for the standard library code

[ashkankiani]

If the output of your program is an copy of minio then it is also covered by AGPL is what that means. I think it's just covering the case where you are redistributing minio in a way such as decompressing and producing the output.

I still don't think it's that confusing. Unlimited running of it is already covered without exception. The next line only refers to the output of the covered work.

If the output of your web server is redistributing minio then you are under AGPL

[camgunz]

No, the whole idea of the AGPL is to make you release modifications even if you're not distributing (i.e. a web app). No modifications, no release.

[dspillett]

The question isn't about modifications to the library/service itself, but whether with other code linking to it in any way is what you have considered a derivative work that should also be covered by the AGPL.

For a library I'd say that was a definite yes. For a service it is someone's less clear, some provide connective tissue (language bindings or other access modules) under less strict licenses which creates an obvious break in the chain, without that or very definite answers to the question on the post you replied to it is unclear how tightly coupled you need to be to need to use AGPL for your own work and I would err on the side of assuming (because it is GPL based) any coupling would have that effect.

Not that this would put me off using LGPL, but it is just as disconcerting, if not more so, to commercial interests, as the GPL is.

[franga2000]

The "any coupling" logic would also make anything running on Linux GPL, which is definitely not the case. Using background service such as Minio as an unmodified black box for data storage as part of your app is unambiguously not derivative work. If you were to write something like a management UI for Minio and offer it with your hosted Minio service, then I can at least see the argument, although it still doesn't count under my reading of the AGPL.

[actionfromafar]

The Linux GPL license has an explicit excemption for binaries running under Linux. So it's not a great example.

https://github.com/torvalds/linux/blob/master/LICENSES/excep...

[dspillett]

The "or very definite answers to the question" is important there. Linus has explicitly answered the question, and if you use any of the Linux headers then yes you should release that software under the GPL. Under this circumstance your "which is definitely not the case" is incorrect.

[EDIT: after reading the information in the link provided by actionfromafar, I'm pull that back a bit: headers marked appropriately can be used and provided a shield similar to scales via glibc & similar (see below) - but check any headers you do use to make sure that they are in fact thusly marked (and note that this goes back to my "… or very definitely answers the question")]

It has also explicitly been said that making calls to the kernel indirectly by other means does not carry the same requirement, so if you use glibc (to give what is perhaps the most common example) and it causes the kernel to be called, you do not inherit GPL requirements from the kernel. What requirements you inherit depend on the license of the library, in this example LGPL which is glibc's license and that doesn't confer any such requirement from linking or other such coupling.

Whether this indirect call via another library that isn't itself GPL licensed acting as a shield holds generally, or just where explicitly stated as with Linux, I'm not sure off the top of my head. I'd have to reread the licence to refresh myself on the exact details and that isn't something I have the time to do right now, but in the case of Linux it doesn't matter if that is a general property or not because of specific things that have been officially stated.

There is a further exception that allows the making of binary blobs to act as drivers and such writing the kernel. I'm not sure if that is just a refinement of the same shield, or something more specific. Again I'd had to reread to be more sure (I've not gone over the "fine print" here in detail for some years).

> Using background service such as Minio as an unmodified black box for data storage as part of your app is unambiguously not derivative work.

That is certainly the case for LGPL, but by my understanding it isn't for GPL nor by extension AGPL. Minio's maintainers themselves shrug on the matter and suggest you either lawyer up or pay for commercial licensing if your work is not also AGPL and therefore directly compatible (see https://github.com/minio/minio/blob/master/COMPLIANCE.md).

[camgunz]

> That is certainly the case for LGPL, but by my understanding it isn't for GPL nor by extension AGPL.

If you don't modify, you have no obligations. Easy.

[dspillett]

Nope. That is LGPL. Under (A)GPL if you make a derivative work you have obligations even if you do not modify. Easy.

[Well, not so easy, as this discussion and the likes of Minio saying “get your own lawyer to tell you what our licence says” illustrate – what constitutes a derived work is apparently not objectively well-defined]

Don't believe me? Ask Google and their vast legal team: https://opensource.google/documentation/reference/using/agpl...

[camgunz]

Well that's not Op's question. They're asking "if I use Minio in my stack without modifications (as a file server that my other services interact with via an API), do I have to AGPL all the stuff the touches Minio or not?" (Minio is basically a FOSS S3) [0]. You're asking about linking, which is covered in the FAQ [1]:

"You have a GPLed program that I'd like to link with my code to build a proprietary program. Does the fact that I link with your program mean I have to GPL my program?"

"Not exactly. It means you must release your program under a license compatible with the GPL (more precisely, compatible with one or more GPL versions accepted by all the rest of the code in the combination that you link). The combination itself is then available under those GPL versions."

[0]: https://min.io/

[1]: https://www.gnu.org/licenses/gpl-faq.html#LinkingWithGPL

[dspillett]

I'm not sure that interpretation is correct. I don't read the intention that way (but I'd have to reread the licenses on detail to refresh myself before speaking more definitively).

Having said that, the fact that minio's documentation answers the question with a shrug and says "lawyer up" (see https://github.com/minio/minio/blob/master/COMPLIANCE.md) seems quite telling.

[camgunz]

I mean, they have a strong incentive to get you to buy a commercial license. I'm not surprised they're uninterested in giving you free legal advice in service of not paying them.

[dspillett]

That isn't what they say though. Their statement reads as “we don't actually fully know how the licence we have chosen works”.

The answer to “can I do X with your product?” shouldn't, in a reasonable world, constitute expensive legal advice. It feels rather shifty to me.

[richardwhiuk]

That's GPL, not AGPL. The AGPL license implies that communicating with it over the network is sufficiently to count as a violation.

[camgunz]

If you diff them, you'll see the AGPLv3 is essentially the GPLv3 with this extra clause added:

"13. Remote Network Interaction; Use with the GNU General Public License.

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. This Corresponding Source shall include the Corresponding Source for any work covered by version 3 of the GNU General Public License that is incorporated pursuant to the following paragraph."

Therefore, what I said about linking applies to both.

To be clear, you only have to offer source code if you've modified an AGPLv3 program and you're distributing it publicly or "interacting with it remotely through a computer network (if your version supports such interaction)". Op's scenario neither modifies Minio nor distributes it, so they're under no obligation to offer source.

[dspillett]

If connecting over the network doesn't constitute linking in a way that imposes AGPL obligations, then Google's position, or the reason they state for it, (https://opensource.google/documentation/reference/using/agpl...) is simply wrong. No offence, but I'm going to believe their expensive legal team not being able to find a way around this means that your interpretation is not correct.

[knorker]

IANAL, but I'd also be worried that even if the project answers your question, maybe any one individual contributor to the project could sue you if they disagree.

Only if the project doesn't have copyright reassignment, of course.

[goodpoint]

> if I use Minio in my stack without modifications (as a file server that my other services interact with via an API), do I have to AGPL all the stuff the touches Minio or not

No and it's spelled out very clearly in the license.

[mrbluecoat]

I think the length of this HN discussion is evidence enough that AGPL isn't clear.

In my experience, organizations that use AGPL do so to 1) ward off an active non-paying community with its associated support cost, 2) claim open source to help convince you to buy their software/service, 3) hire skill-vetted programmers, 4) allow third-party security audits, and/or 5) avoid being jaded by someone that can market or host their solution better than they can.

[camgunz]

It can also be evidence that HN posters have a poor understanding of GPL licenses. Pretty much all these questions are answered in the FAQ [0]. Your guess is as good as mine as to why people continually post random, uninformed, needlessly conservative takes on them instead of just doing a small amount of reading.

[0]: https://www.gnu.org/licenses/gpl-faq.html

[SpicyLemonZest]

The FAQ is not at all clear about this question. #GPLInProprietarySystem says that you unconditionally cannot "incorporate GPL-covered software in a proprietary system", although it might be OK to ship a proprietary system that integrates with and depends on GPL software so long as "the two programs remain well separated". How do I know whether a particular API usage qualifies as well separated or not? The only standard described is "like the compiler and the kernel, or like an editor and a shell".

[camgunz]

> How do I know whether a particular API usage qualifies as well separated or not?

The two paragraphs above what you quoted are:

"However, in many cases you can distribute the GPL-covered software alongside your proprietary system. To do this validly, you must make sure that the free and nonfree programs communicate at arms length, that they are not combined in a way that would make them effectively a single program."

"The difference between this and 'incorporating' the GPL-covered software is partly a matter of substance and partly form. The substantive part is this: if the two programs are combined so that they become effectively two parts of one program, then you can't treat them as two separate programs. So the GPL has to cover the whole thing."

Two programs communicating over a socket aren't incorporated. They're two programs.

[SpicyLemonZest]

Again, the FAQ says otherwise. #MereAggregation says that this is "normally" the case, but "if the semantics of the communication are intimate enough" two binaries communicating over a socket may still be one program. Whether they are one program is explicitly left as a question for judges to decide.

[g15jv2dp]

Sorry but what does "arms length" mean? My software doesn't have arms. Using metaphors full of imagery is cute but essentially meaningless.

> Two programs communicating over a socket aren't incorporated. They're two programs.

Aren't they? So, if I want to use a GPL library, all I need to do is write a little wrapper program that does RPC over a socket, and boom, I can use a GPL library in my closed source program? Obviously not.

[awesomeMilou]

That's the GNU project's interpretation of the license. I don't see how a court couldn't reach a different agreement on what the often discussed "derivative works" section means.

The FAQ also has interesting takes, where depending on the jurisdiction you're in, I'm sure such views would differ:

    Q: In an object-oriented language such as Java, if I use a class that is GPLed without modifying, and subclass it, in what way does the GPL affect the larger program? (#OOPLang)

    A: Subclassing is creating a derivative work. Therefore, the terms of the GPL affect the whole program where you create a subclass of a GPLed class. 

Thats... a really weird and technically inept take on an issue that is not broadly applicable to all object oriented languges, but going with this argument, I'd argue that "subclassing" essentially constitutes just using an interface (in the general sense, not in the Java sense) to some existing software, so in Minio's case, using their API would constitute a similar usage pattern -> my "derivative" work must now be GPL licensed.

[camgunz]

I know a lot of this stuff is legally pretty new (though AGPLv3 is almost 17 years old now) and there's not a huge body of case law around it. But--and I'm earnestly asking here--is there case law where courts reach in and modify licenses separate from the authors' explicit intent? It's hard for me to imagine a court doing that, especially with all the reliance interests involved (I use AGPLv3 with the understanding that subclassing requires release, court says no, now my business model is toast).

> I'd argue that "subclassing" essentially constitutes just using an interface (in the general sense, not in the Java sense) to some existing software, so in Minio's case, using their API would constitute a similar usage pattern -> my "derivative" work must now be GPL licensed.

No, again the difference is incorporation. In order to subclass something you have to incorporate it into your code.

[awesomeMilou]

> is there case law where courts reach in and modify licenses separate from the authors' explicit intent

What are you on about? The explicit purpose of a license is that it's users do not have to worry about anyone else's "explicit intent". A license needs to be unambigious about it's terms, else it's just not a good license, hence see the discussion in this thread about the meaning of derivative works.

It may very well be that the FSF/RMS/GNU Project had some intent on it's use when creating the GPL/AGPL v3, but a court in another jurisdiction will not care. I have no idea how to get a hold of the FSF when I'm being sued for license violations in europe and even if so, I doubt a court would care about the FSF's interpretation, given that they're likely not a party to the proceedings.

I'm surprised that people on an US centric site believe that intent in US jurisprudence matters, because in a legal system largely based on precedence, it really does not.

> No, again the difference is incorporation. In order to subclass something you have to incorporate it into your code.

You have to do the same thing in order to use API's. I'm sorry, unless I don't understand something here, this doesn't make sense.

[richardwhiuk]

That FAQ covers the GPL, not the AGPL.

[camgunz]

If you ctrl-f for AGPL you'll see it's for all of it.

[yencabulator]

Only after people badgered them to remove their claim that anything communicating with Minio gets infected by AGPL immediately. Their compliance page used to claim:

> Combining MinIO software as part of a larger software stack triggers your GNU AGPL v3 obligations. The method of combining does not matter. When MinIO is linked to a larger software stack in any form, including statically, dynamically, pipes, or containerized and invoked remotely, the AGPL v3 applies to your use. What triggers the AGPL v3 obligations is the exchanging data between the larger stack and MinIO.

That version has, unfortunately, not been archived at web.archive.org or such.

Some remnants of the old compliance text are still mentioned: https://github.com/minio/operator/issues/2030

[haytamoptika]

https://www.gnu.org/licenses/gpl-faq.en.html "However, in many cases you can distribute the GPL-covered software alongside your proprietary system. To do this validly, you must make sure that the free and nonfree programs communicate at arms length, that they are not combined in a way that would make them effectively a single program."

I think you can interact with GPL/AGPL and retain your code propietary by:

- Don't modify the AGPL program.

- Run separatly, using docker container, vm etc

- Interact with CLI, REST API, filesystem, database etc

- Keep the AGPL interaction only to your program, non public consumption, minimum the surface of distirbution the code.

- Keep your code non directly interact, such as avoid use node npm dependencies directly, avoid library linking, use api gateway, use thirdparty module.

[afro88]

Github may have it wrong then? Their summary says:

> Permissions of this strongest copyleft license are conditioned on making available complete source code of licensed works and modifications, which include larger works using a licensed work, under the same license.

Note the last part: "which include licensed works using a licensed work"

[xyzzy_plugh]

No, GitHub has it exactly right. Ultimately this sort of thing has to be settled in court.

[camgunz]

At least in the EU there's some precedent where AGPLv3+ won out, though it was through settlement and not judgement (and it's not super clear how contentious the parties were anyway) [0]

[0]: https://archive.fosdem.org/2021/schedule/event/agplcomplianc...

[camgunz]

Yeah I wouldn't rely on their editorializing. It's best to just refer to the FAQ [0], which covers these questions.

[0]: https://www.gnu.org/licenses/gpl-faq.html

[ashkankiani]

"This License explicitly affirms your unlimited permission to run the unmodified Program."

In the Basic permissions of the actual content of the license https://github.com/minio/minio/blob/master/LICENSE

It's not that difficult to parse if you actually read it top to bottom instead of skimming.

[demurgos]

You linked a more general FAQ for the GPL. Would you have a more specific quote or link for interactions with AGPL code?

[camgunz]

"In AGPLv3, what counts as 'interacting with [the software] remotely through a computer network?'"

"If the program is expressly designed to accept user requests and send responses over a network, then it meets these criteria. Common examples of programs that would fall into this category include web and mail servers, interactive web-based applications, and servers for games that are played online."

"If a program is not expressly designed to interact with a user through a network, but is being run in an environment where it happens to do so, then it does not fall into this category. For example, an application is not required to provide source merely because the user is running it over SSH, or a remote X session."

[0]: https://www.gnu.org/licenses/gpl-faq.html#AGPLv3InteractingR...

[demurgos]

Thank you!

[misterio7]

AFAIK, the difference between AGPL is GPL is on what constitutes "distribution"; what constitutes a "derivative" is still the same.

https://drewdevault.com/2020/07/27/Anti-AGPL-propaganda.html

[demurgos]

Thank you!

[zadokshi]

No it is not clearly spelled out. So I am wondering why you think it is clear. Perhaps you are misunderstanding the problem that is being raised? I’m not sure.

[afro88]

Is it? Doesn't it depend on whether your stack depends on it to function, or if it is standalone that your stack can connect to but doesn't rely on?