[apo]

To use Ghostscript for free, Hancom would have to adhere to its open-source license, the GNU General Public License (GPL). The GNU GPL requires that when you use GPL-licensed software to make some other software, the resulting software also has to be open-sourced with the same license if it’s released to the public. That means Hancom would have to open-source its entire suite of apps.

Alternatively, Hancom could pay Artifex a licensing fee. Artifex allows developers of commercial or otherwise closed-source software to forego the strict open-source terms of the GNU GPL if they’re willing to pay for it.

This obligation has been termed "reciprocity," and it lies at the heart of many open source business models.

http://www.rosenlaw.com/pdf-files/Rosen_Ch06.pdf

The more important issue here is reciprocity, not whether an open source license should be considered to be a contract.

AFAIK, the reciprocity provision of any version of the GPL hasn't been tested in any meaningful way within the US. In particular, the specific use cases that trigger reciprocity remain cloudy at best in my mind.

Some companies claim that merely linking to a GPLed library is sufficient to trigger reciprocity. FSF published the LGPL specifically to address this point.

So I believe a ruling on reciprocity would be ground breaking.

[10165]

Question: Is that what Stallman intended to accomplish with the GPL? Pay a fee for GPL source code and bypass the GPL? (I apologize for my ignorance here.)

It seems like "reciprocity" has an even worse outcome than BSD source code. The origin of the source code can be completely hidden from the user.

Do users deserve to know at least that the original source code was freely available? What happens when users discovers that they are paying for something that others are getting for free? Do they care?

Is this a case of taking something that was free (but valuable), i.e., the original GPL source code, and concealing it as a closed source work in order to generate revenue/profit for some specific person or entity?

Stupid question: If someone fixes or adds something valuable to GPL source code and wants to charge for it, then why not just charge for the patch or the additional code?

(Assume that patches or additional source code files are distributed by themselves without the original GPL source code and that they do not contain any functional portion of the original GPL source code. Assume further that they do not use "interfaces" designed by the GPL source code author. Finally, assume that the end user can compile their own software and no binaries are distributed.)

[saidajigumi]

You are misinterpreting "reciprocity"; it has nothing to do with Artifex's dual-licensing arrangement. If you read the linked PDF, you'll find this:

Reciprocity means a mutual or cooperative interchange of favors or privileges. Something is reciprocal when it is performed, experienced, or felt by both sides. (The American Heritage Dictionary of the English Language, 4th edition.)

The GPL license is reciprocal, because it is “performed, experienced, or felt” by both sides—the licensor and the licensees both use the GPL.

In non-legal terms, I'd put this as "the GPL allows you to redistribute in kind: by extending the offer the original licensor made to others." The "price" of redistribution is agreeing to public participation in the co-evolution of the software.

This is not to be confused with Artifex's offer to dual-license: you may either accept the terms of the GPL or purchase a commercial license. These two worlds do not interact other than Artifex, the copyright holder, uses its rights under copyright law to offer these two alternatives.

[10165]

Yes, the "outcome" to which I was referring was in fact the effect of dual-licensing.

With respect to the book chapter, as I interpret it, reciprocity includes asking for the licensee to open source their work. But I leave this to the experts to interpret definitively.

Assuming I am not misunderstanding, if the licensee "reciprocates", then there is no closed source and the "problem" I am alluding to goes away. Because users can now see the source code and theoretically they can determine where it came from.

(The problem being that GPL source code and the value thereof is sometimes "concealed" in closed source products. This is just my personal view. I may care about things that others do not. Opinions may differ.)

[lolc]

You cannot have GPL-licensed code in closed-source code. It's a violation of the license so the code ceases to be GPL-licensed and becomes unlicensed. If you distribute that code, in source or binary form, you can get sued by the copyright holders which is what this case is about.

[eru]

You can totally have GPL-licensed code in closed-source code as long as you don't publish it. So you can totally run your SaaS business like that.

The Affero GPL tries to close that loophole.

[lolc]

Indeed the code only becomes unlicensed as soon as you violate the GPL terms. So I guess the correct way of framing this would be that internal copies, including changes, are still under the GPL.

[fourthark]

You can if it is dual-licensed.

[lolc]

Then it's licensed under some other license and the GPL does not apply. If I rent a building and the building is for sale I still don't own it until I close that contract.

If I copy GPL-licensed code without following the license terms, the GPL no longer applies and the code becomes unlicensed. The GPL is explicit about that.

If I acquire code under another license than the GPL my copy is not GPL-licensed even if it's available under the GPL license. Ultimately, the GPL requires that all people who pass on code under the GPL adhere to its terms. If one person in the chain didn't (for example by not making available the source) all subsequent copies become unlicensed.

[belorn]

My intuition from listening on several of Stallmans talk would be that paying for exceptions are an acceptable strategy in some cases, through not ideal.

So while writing this comment I remembered the old case of QT and found this article (https://www.fsf.org/blogs/rms/selling-exceptions). To quote it similar to a "inferior choice, but it's not wrong".

[bluGill]

> If someone fixes or adds something valuable to GPL source code and wants to charge for it, then why not just charge for the patch or the additional code?

You can legally do this, but it will not be easy. You cannot distribute a binary in this way, if you do your patch becomes GPL so the first person who buys your patch can legally give it to everyone else. That means you have to sell the source code to your patch and your customers have to build the binary themselves. You need to ensure that your customers understand that they cannot distribute any binaries they make. (they probably can distribute it within their company but they need to have some process to ensure that their employees know they cannot distribute this)

If anyone is thinking about this, make sure all sales include your lawyer: you will need to ensure that your customer understands all the subtleties otherwise the courts might decide your patch is GPL.

[Nursie]

As a patch or addition, your source code is likely to be considered a derivative work, regardless of whether you actually build it into a binary.

[bighi]

As other people already said, intellectual property laws restrict not only the work itself, but also derivative works.

A patch is a derivative work, no matter how you try to dodge that part of the law. So it would still be violation of copyright.

[10165]

To be clear, the silly question I posed was not directed at avoiding copyright violations. What I ask is whether anyone is ever curious about the value of the derivative work versus the original work.

For example, the original work might be very valuable, a significant work. It could be the collective work of many authors. But it has been made available for free. The derivative work, maybe patches or some additional source code by a single author, is also valuable but on its own much less so.

Then the large original work is packaged together with the patches and additonal source code as a "derivative work". It is commercially licensed to an end user who sees the value as a whole, most of it coming from the original work, which of course was available for free.

Depending on whether attribution is given, the user may have no idea that the core of the product was open source and available for free.

More importantly, there appears to be no assessment of the relative "value" of the free portion versus the closed-source commercial portion of the product.

[mark-r]

I'm not entirely sure that's correct. If you try to sell something that relies on GPL software, it's considered a derivative work even if you don't distribute the GPL software with yours.

[fmihaila]

It is a derivative work, but selling derivatives of GPL-ed software is entirely legal and not forbidden by the GPL. Distributing binaries (regardless if for free or not) of GPL-derived software without distributing the source from which the binaries were derived (or without offering a reasonable way of getting the source on demand) is forbidden by the GPL. Moreover, the source of the derivative work must be offered under the GPL.

(Edited to add the last statement above, for clarity.)

[Nursie]

While that is true, as part of a derivative work, your users would have your source under GPL terms.

Absolutely you can sell, but your can't restrict user rights

[singlow]

This is correct - you not only must include the source code for your binary, you also must include it under the same terms as the original source code.

[fmihaila]

Agreed, I didn't mean to imply otherwise.

[crdoconnor]

"Question: Is that what Stallman intended to accomplish with the GPL? Pay a fee for GPL source code and bypass the GPL? (I apologize for my ignorance here.)"

I've often thought that this was a pretty ideal way of licensing OSS.

It provides a revenue stream for improving upon open source from those with the deepest pockets and the greatest ability to pay which clearly works (QT, for instance, probably wouldn't exist without this model).

Moreover, it doesn't remove others' freedom to be able to develop free software from it.

It's telling that the biggest whinges about the GPL often come from large (often abusive) corporations with deep pockets, an inflated sense of entitlement, paranoia about "their" intellectual property and a desire to get freebies from ordinary developers.

[johncolanduoni]

The specific person or entity has to have the copyright for the work in the first place (or the permission of that entity). In which case they're "taking" from themselves.

As for Stallman's intentions, he's talked about this exact model: https://www.fsf.org/blogs/rms/selling-exceptions

[err4nt]

Forgive my ignorance too - but I don't think the intended goal of the GPL is to allow you to dual-license, I think Stallman would (I'm guessing) not want people to license code as anything other than GPL, so I imagine he'd discourage paying for non-GPLed code.

[johannes1234321]

Not necessarily.

"I've considered selling exceptions acceptable since the 1990s, and on occasion I've suggested it to companies. Sometimes this approach has made it possible for important programs to become free software."

Read his full text for some boundaries he sees.

https://www.fsf.org/blogs/rms/selling-exceptions

[djsumdog]

Hm. I did not know he held that view.

It does make sense. It sounds like he's against things like Magento/Gitlab/Alfresco which have totally open source versions and commercial/enterprise versions with closed extensions. (I realize those aren't the best examples as they're not GPL).

With the dual licensed product, you simply have two licenses for the exact same code base. If you want to reuse it, you can, but you need to release your derivative works back to the community. But the people/organisation behind the tools still have to live in this capitalist world that's far from the free software paradise of the FSF. Developing under a dual license can provide a revenue stream back to the writers to help keep that work going.

[johannes1234321]

Just as a remark: He doesn't see Free Software as anti-capitalistic. He i.e. also supports the possibility of selling GPL software. (just as in the 90ies, where downloading large files from the internet was hard and it was common to buy a box with S.u.S.E. Linux)

"Many people believe that the spirit of the GNU Project is that you should not charge money for distributing copies of software, or that you should charge as little as possible—just enough to cover the cost. This is a misunderstanding. Actually, we encourage people who redistribute free software to charge as much as they wish or can. If a license does not permit users to make copies and sell them, it is a nonfree license." https://www.gnu.org/philosophy/selling.html

What he cares about is that the software is free as in freedom and contains no lock-in: You can look at it, you can edit it, you can distribute it.

[dllthomas]

The intended goal of the copyleft provisions of the GPL is to make it differentially easier for people to develop free software compared to proprietary software. Requiring that they pay in order to do the latter (while being able to do the former gratis) does that.

[Nursie]

I don't think your "Assume" clause buys you much. If it is a source patch it is a derivative work.

You can sell it, but it's still subject to GPL.

Distribution of binaries is a bit of a diversion here, and not a key issue - it dorsn't really matter if we're talking about C or python.

[geofft]

> It seems like "reciprocity" has an even worse outcome than BSD source code. The origin of the source code can be completely hidden from the user.

Nothing is stopping someone from paying the rights owner of a BSD-licensed work for the right to use it without preserving the copyright notice. The analysis is the same as for a GPL-licensed work.

If the argument is that it's better to have BSD-licensed works without paid exceptions than GPL-licensed works with paid exceptions, well... first off, nothing stops the paid exceptions from being "You can use this under the BSD license". Second, this seems like a strategic thing; if most users comply with the GPL, and you raise some money, that seems like a net win compared to everyone complying with the BSD and not providing source despite not paying.

> Assume further that they do not use "interfaces" designed by the GPL source code author.

I'm having a lot of trouble imagining a patch that works this way. If you're patching the program, aren't you interfacing with the program somehow?

I can think of two possible ways. One is that you're actually patching other interfaces (e.g., providing an LD_PRELOAD) provided by more-liberally-licensed software. I don't think that an LD_PRELOAD of POSIX interfaces intended for use with specific GPL software is a derivative work, but I also don't super look forward to convincing my lawyer of what's going on, let alone a judge.

The second is that you're running the program in such a way that you're really wrapping standard I/O and not touching the program itself, but I wouldn't call that a patch. JuiceSSH for Android does this with mosh, for instance; it uses an upstream mosh-client binary (and provides source) in a subprocess of its proprietary UI. On a system like iOS where you can't fork, I could imagine some scheme for running the process in the same address space with some serious emulation. I very much wouldn't look forward to litigating this; it sounds sorta like the VMware lawsuit, which is a huge mess.

If you're providing a plugin through a defined plugin interface, and the software author has said "Use of this plugin interface doesn't subject you to my program's license" (or the plugin interface is an external standard like VST), then you're in the clear. It's worth noting that Linux has an explicit statement that the syscall interface does not subject userspace programs to the GPL. I don't know if such a statement is necessary, but it's nice that it's there. But these sorts of things are definitely not what I think anyone would call a "patch".

[10165]

Patching might operate by locating patterns in source files and editing the source files. Either deleting, changing existing text and/or adding new text. The patch files themselves might be considered nothing more than instructions on how to make edits.

It is true the patterns could be excerpts from the GPL work. But they need not be functional or even intelligible as anything other than as part of instructions, e.g., short strings of octal values representing characters, with wildcard characters interspersed.

Patching might even operate by only using line and column numbers. The patch itself in that case need not contain any text from the GPL work. It might be just an index into some file, a list of line numbers and columns and any new text to be inserted.

The point is that the process of patching need not necessarily reveal anything about the original GPL work. The editing could theroretically be done in such a way to make this separation.

Anyway, we have drifted from the original question which was , essentially, why do programmers not distribute instructions on how to modify GPL source code or additional source code that can be linked with GPL source separately from the GPL source code.

The reason I asked is because what I see is that original GPL source code is sometimes "hidden" in commercial products by virtue of being bundled with some "derivative work". To me this obscures the value of the original GPL source code in favor of the closed source derivative work, which may or may not be as valuable. NB The usage of the words value and valuable is purely subjective. Opinions may differ.

I am not sure I understand the comment about BSD licensing. Assume for example that the goal of the license is to require attribution, how does one avoid that requirement without changing the license? The licensor can opt not to enforce the license and may accept payment. But the license still requires what it says.

[geofft]

> But they need not be functional or even intelligible as anything other than as part of instructions, e.g., short strings of octal values representing characters, with wildcard characters interspersed.

I think you're misunderstanding how copyright law views works. A "work" in the sense of copyright law isn't a pattern of bits: it's a creative expression of an idea (a binding between a pattern of bits and some concept in a human brain) that has a context for how it came to exist.

The classic article "What Colour are your bits" is a good overview of this: http://ansuz.sooke.bc.ca/entry/23

It's worth reading, to understand exactly what copyright law covers / how it works. But suffice it to say that the ability to create a set of bits that does not include any inherent reference to the GPL'd work does not make the bits no longer a derivative work, any more than Monolith (the example from that article) causes bits to stop being copyrighted.

Which answers your question of why programmers do not distribute instructions on how to modify GPL source code without distributing the source itself: there's no point. The legal requirements on them are exactly the same.

My comment about BSD licensing is that if people who own GPL'd works sometimes accept payment to give you the work without the requirements of the GPL, nothing is stopping people who own BSD-licensed works to accept payment to give you the work without the requirements of the BSD license. If it's a bad thing that you can in theory pay money to avoid the GPL, it's equally a bad thing that you can in theory pay money to avoid the BSD license.

[Nursie]

Your patch would be meaningless without the GPL code underneath, so is a derivative work and would therefore likely fall under the GPL.

[Dylan16807]

Requiring another work for meaning, without actually including any of that work, is not enough to make copyright kick in as far as I know.

[Nursie]

Then any source patch would fall outside of licensing.

It's clearly a derivative work, as described.

[Nursie]

Answer to stupid question: Nothing is stopping you doing that. As it would be a derivative work, your users/customers would be entitled to your source and have distribution rights.

[qb45]

Your customers are only entitled to the source if you accepted the terms of the GPL and technically you can claim that you didn't accept them and that you simply distributed the derived work illegally.

If your customers wanted the source, they would have to ask the original authors to sue you and have the court force you to accept the GPL post-factum. It's not clear how this would turn out because afaik such line of "defense" has never been tried by violators so far. A few such lawsuits settled out of court, usually with source code being part of the deal.

A ruling in this kind of case, where the violator stubbornly refused to comply and maybe tried to escape with just paying damages or some other trickery, that would be interesting.

[bdowling]

A court won't force people to comply with the terms of a license. If they don't comply, they just don't have a license and can be liable for copyright infringement. A court can then enjoin them from continuing to distribute the product, which may be incentive for them to reach an agreement on a commercial license or it might induce them to modify the product to not use the infringed code. And a court can force them to pay damages, which will be the cost of what a commercial license would have been. However a court won't force them to release their code under the terms of the GPL. Even if the GPL were a contract, which it's not, courts just don't order specific performance for breach of contract.

As you mention, though, some potential defendants will determine it's just cheaper to just disclose the modified code and walk away.

[Nursie]

I agree, a real, thorough test of this in court would be a great precedent.

And yes, if you refuse source to your customers that's where you are - software copyright violation. Just the same as if you did this with proprietary stuff. Someone with standing would have to start the ball rolling.

[BaronSamedi]

I view the GPL as a form of DRM. It may be DRM for a good cause but it is still DRM. DRM is about control and I don't think that imposing controls is ultimately compatible with the notion of "free software". I get the arguments in favor it but am not convinced.

[cyphar]

I mean, that's just patently false, but the most prominent way in which that statement falls apart is that DRM is designed to restrict users and the GPL has no restrictions on users.

The GPL does place nontechnical restrictions on developers, but those restrictions exist to ensure that bad actors can't add new restrictions to users.

But seriously, "GPL is DRM" makes no sense. Aside from the fact that DRM and the GPL are completely different classes of things, they also have completely contradictory philosophies and are applied and act in completely contradictory ways. That's just FUD.

[boomlinde]

> Stupid question: If someone fixes or adds something valuable to GPL source code and wants to charge for it, then why not just charge for the patch or the additional code?

Nothing stops anyone from charging for the GPL code in the first place.

[10165]

True.

But the idea I had in mind with this question was that there is often an initial free source of high value code and then someone may add an addtional amount of their own code that is by comparison far less valuable.

The end user of the commercial product if it is closed source may not be able to see the extent of the contribution of that free portion to the value of the product as a whole.

For lack of a better hypothetical, imagine a product that is a combination of 1. GPL licensed command line executable that anyone can download and compile for no charge and 2. a GUI "skin" written by someone who has no copyright in the command line executable.

The author of the skin, let's call him "the entrepreneur", wants to charge end users.

The entrepreneur packages his skin together with the GPL licensed command line executable as a closed source commercial "product".

As you state, "Nothing stops anyone from charging for the GPL code in the first place."

But in this case, as is common among GPL-licensed programs, the author who wrote the command line executable never charged for it.

The problem I see with this situation is that because the product is closed source, the end user may not be able to determine the extent of "the entrepreneur's" work.

For example, his contribution to the "product" may be quite small in comparison to the work of the original author. That is, the core of the product, the most important bits, may comprise the freely available GPL source code, available to anyone for no charge.

This is not a situation that I expect anyone else to care about. But as an end user, if I were faced with paying for a commercial software product, I would want to know about the entrepreneur's use GPL source code that I could obtain elsewhere for free and the extent of the entrepreneur's "contribution" in relation to the original author.

Returning to my original stupid question, why does the entrepreneur not sell his skin separately from the command line executable. It is a rhetorical question. (Commenters tried to answer it anyway.)

Assuming the command line executable is a well-written, highly valuable program and an end user does not know about its existance, the entrepreneur's product may look quite valuable. The entrepreneur may be piggybacking on the value of the GPL source code but concealing this by keeping the source code secret.

[mark-r]

I'm guessing Stallman is completely disgusted by the possibility of dual licensing. But the legal copyright holder has the right to establish whatever licenses they wish, whether Stallman approves or not.

As to your question, you've already agreed not to charge for your patch by the fact that you've utilized the GPL to access the code in the first place. That's one of the points of the GPL after all.

[merijnv]

> I'm guessing Stallman is completely disgusted by the possibility of dual licensing.

You'd be wrong, though. He considers it a legitimate alternative to "not releasing source at all":

> I consider selling exceptions an acceptable thing for a company to do, and I will suggest it where appropriate as a way to get programs freed.

https://www.fsf.org/blogs/rms/selling-exceptions

[mark-r]

That's interesting, thanks for the citation. I was basing my opinion on his well-known hate of proprietary software, and his desire to make all software free. Dual licensing works counter to that, because it allows someone to use GPL software without making their own derivative software available too.

[icebraining]

Well, it's not "GPL software", it's software that's also distributed under the GPL. That's being freely distributed at all is a win compared to most commercial software.

And in fact, it could be argued that it's better (for rms' goals) than MIT/BSD/etc, since the proprietary license will impose some restrictions on its usage by other proprietary vendors.

[pessimizer]

Definitely better, because it allows for GPLed forks, but not commercial ones (unless the copyright holder wants to compete with themselves.).

[Arizhel]

I'm going to disagree about Stallman. I suspect he would prefer all-GPL-everywhere, but I think he's pragmatic enough to think that dual-licensing (with GPL being one of them) is better than nothing, because it still means the software is out in the open, for anyone to download and use who wants to adhere to the GPL, so it's still a win for Free software. Some companies might choose to purchase a proprietary license so they can use it in closed-source software, but for others they're able to download and use it for free under the GPL.

Remember also, Stallman and co. did come up with the LGPL, which itself is a pragmatic compromise to allow GPLed libraries that can be used in non-GPL applications: under LGPL, you have to share any changes you make to the library itself, but the rest of your application can use a different and/or proprietary license.

It's better to have some GPL rather than no GPL.

[smhenderson]

As to your question, you've already agreed not to charge for your patch by the fact that you've utilized the GPL to access the code in the first place.

Nothing about the GPL stats that you can't _charge_ for your software, in fact RMS explicitly encourages people to make money from free software. You just can't restrict the buyer from redistributing it once you sell it to them.

[mark-r]

True, charging not explicitly prohibited. But since everybody you distribute to is free to redistribute it again without charge under the terms of the license, it does put a practical limit in place.

[s73ver]

"Question: Is that what Stallman intended to accomplish with the GPL? Pay a fee for GPL source code and bypass the GPL? (I apologize for my ignorance here.)"

Probably not. Although from what I've seen, he was rather short on explaining how devs would make money to support themselves under GPL.

[dhimes]

That is the most important issue, but not the most important issue here. This ruling hasn't gotten that far. This merely throws out Hancom's argument that because the contract wasn't signed it wasn't a contract.

Contract terms should be up next (but I smell a settlement, frankly).

[anigbrowl]

The more important issue here is reciprocity, not whether an open source license should be considered to be a contract.

From your ethical perspective, yes. From a court's perspective, reciprocity can't be enforced without the existence of a valid contract because there is no legal obligation for people to be nice to each other. Contracts are the mechanism we use to establish obligations between private parties.

[apo]

Maybe I'm mistaken then but I seem to remember having seen numerous cases in which GPL was involved, but only in the sense that the software was being redistributed as an unmodified unit or with modifications. But those cases may have been settled - I'm not sure.

Reciprocity and the conditions that trigger it (I link to your GPL library and so must release my application source code) has never been ruled on from what I've seen.

[anigbrowl]

Reciprocity is an ethical concept. I told you, there is no law that mandates people have to be nice to each other. Courts do consider matters of pure equity from time to time, but such disputes are heavily fact-based and don't generalize well. That's why contracts exist; they're a mechanism for establishing predictability between people who may have very different moral assumptions, but (ideally) negotiate agreements of limited scope to which they are both willing to adhere while still maintaining their different interests/ moral beliefs/ tribal membership etc.

Courts don't want to be moral arbiters if they can possibly avoid it because questions of morality are inherently political. Contractual relations are a mechanism for dealing with that problematic social reality.

Edit: if it helps, think of contract law as a language specification. The compiler cannot and does not evaluate the worthiness or value of a program, only its semantic consistency. An individual contract is like a program, the law as a whole is like the operating system, institutions are the firmware, physical assets are the hardware. It's an imperfect analogy but it might make the scope issues easier to understand.

[matt4077]

It appears that Rosen's "reciprocity" is simply another term for the "infectious", or "copyleft" nature of GPL. In that case I fail to see the significance. There isn't really any remaining doubt about the enforceability of GPL, which may actually be the reason for the relative dearth of case law.

[apo]

I'd be interested in knowing which cases you're thinking about.

[sova]

Groundbreaking yes, but also just really good.