Hacker News Reader

Comment by jsavimbi | Hacker News Reader

This happens because people don't understand the GPL and its unique ability to empower developers to write software or something really interdesting like that.

View on HN

I'd have to second this; there is a lot of FUD being put out about how the GPL "takes away" "freedoms" from the developer, when the truth is that if someone is writing something from scratch, they have de facto copyright and can relicense the code any way they want, at any time. Only versions released under GPL are out in the wild as "lost sales", and are more likely to garner good will than cause a loss of profits. As for BSD, well you wouldn't want your competition locking up your code and selling it back to you, now would you? And all the other licenses, while more finely nuanced to different needs, are also not as straightforward. I don't understand why GPL isn't more widespread.

>I don't understand why GPL isn't more widespread.

Honestly, for me? Viral nature. I don't want to put off a company using my code (well, for most things I do) because they don't want to be bound by the requirement to give away the source.

That's kind of why I'm a fan of Creative Commons, attribution share-alike, with possibly noncommercial depending on what it is and my mood at the time.

The GPL is just a pain in the ass for all involved. At least that's how I see it.

What distinction do you see between CC-SSA and GPL? They say essentially the same thing. CC-SS has the same viral nature as the GPL/LGPL (it's about halfway in between the two).

The GPL has a lot of FUD about it, but there's very little actually offensive about it.

I should have been more clear. The neat thing about the entire CC class of licenses is that it's easy to pick from what you want to do based on what you're doing. A license framework if you will.

The GPL doesn't have that - and as you said, CC-BY-SA is probably the closest - but I don't have to use CC-BY-SA if I don't want to. Maybe I don't care as long as my name's on it. Then I can just use CC-BY.

The FUD you speak of is another reason I tend to shy away from GPL - both in terms of enforcement (shown to be tricky, thought the SA CC license would have the same issue), and it's association with RMS and the culture and FUD surrounding it.

Another thing is that CC lends itself better to things that aren't computer code.

GPL is like donating a loaf of bread, but saying you can't make a ham sandwich with it (because you just hate them pigs).

You either want gift the code to the world or you want to do it conditionally. Do tell me which one comes across as a more genuine gesture.

Ah, the inevitable "bad GPL analogies" portion of any GPL discussion thread.

I personally don't feel I'm under any ethical obligation to give away my source code. Sometimes I don't release it at all, at least not unless you're paying for it. Other times I license it under a permissive license, usually when it's something smallish.

And other times I choose to GPL or AGPL it. I see the latter case as a quid pro quo: you can use my code as long as you let me use yours. Unlike in the ham sandwich example, it's not some arbitrary restriction imposed out of taste or spite, but a proposal of what seems to me to be a fair exchange. In return for using my code, you let me use your code, pretty simple and symmetric.

If you don't like the idea of a reciprocal code exchange, we could agree on a different exchange, like you paying me money for a license, or we could fail to reach an agreement and no exchange happens. But I don't feel particularly obligated to give you unrestricted free use of my code with no reciprocation. I could choose to do that out of charity or idealism, but I don't think I'm obligated to.

The trouble is that even in that simple post, where I think your real point is perfectly reasonable, you have completely mischaracterised the GPL and AGPL.

The GPL doesn't actually say "you can use my code as long as you let me use yours", or anything very similar really. I expect you knew that and didn't mean any deception by what you wrote, but we're talking about a legal document and lawyers are not known for their folksy interpretation and sense of humour.

And the AGPL is a particularly dangerous document that shouldn't be directly associated with any of the other GPL-related licences IMHO. Its scope is broader, because it can have profound implications for anyone even using software distributed under that licence, not just those developing the software.

True, they're not specifically licensing me to use their code in exchange, but I still think conceptually it's within my rights to offer that sort of exchange. I make a blanket offer to let you use my code, if in return you offer your own code under the same blanket offer. It's even more limited than that in that I'm not demanding you offer all your code that way, only the stuff that directly derives from and/or links with mine.

I don't see what's particularly dangerous about the AGPL, though. It's not that hard to comply with: if you build a webapp on some AGPL'd software, you need to AGPL the whole webapp. If you don't want to AGPL the whole webapp, you can just not build it on top of AGPL'd software. Pretty easy to avoid! And in any case the usual alternative to the AGPL is not releasing code at all, or releasing it under a "no commercial use" clause, which certainly doesn't give you more freedom. Compare Gitorious's code (AGPL) to GitHub's code (not released) for example. In both cases they're worried that if they MIT/BSD'd or even GPL'd their code, a rival SaaS could leapfrog them starting from their own code.

[edited the 2nd paragraph above for brevity]

The example that really got to me with the AGPL was when the Opa programming language was being discussed on sites like HN a while back. IIRC, both the language and its standard library/runtime were AGPL'd. That would potentially mean that not just the compiler itself but any program you wrote in the language would automatically be AGPL'd as well.

As with all of these GPL-style licences, there's a lot more risk if you're not an all-GPL house, and quite modest risk if you're intending to GPL your code anyway. But the AGPL is different because it can affect not just developers building on the code for redistribution but also those who are just using it internally.

I can understand why they did that, in the context of network-enabled services, but nothing in the AGPL seems to restrict the implications to only that context. As the example above demonstrates, people do use it for other things with potentially profound implications that aren't obvious to anyone who knows about the much more common GPL and LGPL but doesn't realise why AGPL is fundamentally different. For that reason alone, I don't think the AGPL should have used a similar name.

I agree on the name, yeah, and I was also surprised by Opa. My assumption in infrastructure-code cases like that (not sure if actually true with Opa) is that they want to leave the door open to a dual-licensing solution, so if Opa ends up being a killer technology, the AGPL poison-pills it enough for commercial customers that they'll be able to sell paid licenses.

Not sure what a cleaner alternative would be in that case. Perhaps just state that explicitly? "You can use the free version of Opa to build open-source webapps [define appropriately], but need a commercial license if your app is not open-source."

What is "bad" exactly about this analogy? GPL is a strongly conditional permissive licensing that carries an agenda. Compared to an unconditional license, it clearly has a lesser appeal to those not caring or not aligned with an agenda.

>You either want gift the code to the world or you want to do it conditionally. Do tell me which one comes across as a more genuine gesture.

Making a moral judgement as to the license I release my creations under? This kind of idiocy is why I don't want anything I do to be associated with Stallman and his ilk.

"What's that? I'm evil because I sell software and don't give away the source code? Go fuck yourself."

And yet I've no doubt you'd be happy to call somebody who knowingly sold you a car you could not service "evil" (or something to that effect). Or what about companies that sell you content with DRM, preventing you from even doing legal things with it?

Now, perhaps you are fine with both of these things. And that's not an entirely unreasonable position to have. But not being fine with DRM or unmodifiable products is also fine, and disliking companies that sell these is completely valid. Disliking proprietary software is just taking the same idea and extending it, which is also entirely reasonable.

>Id yet I've no doubt you'd be happy to call somebody who knowingly sold you a car you could not service "evil" (or something to that effect).

Actually, I'd not buy such a car in the first place. But you're really not resorting to car analogies right?

>Or what about companies that sell you content with DRM, preventing you from even doing legal things with it?

Same thing - I don't buy it for the most part.

However, being anti DRM and being a FOSS zealot are two different things.

You'd be surprised how much "unmodifiable" software indeed ends up modifiable when enough people get interested.

In any case, I take great offense at the notion that I am somehow a bad person for not letting everybody in the world use my product for free, hence the notion at the end of my previous post. Which still stands, downvotes be damned.

That's a poor GPL analogy. I think most of us know what the GPL says, and it does not restrict what you as a developer can make with the code (or regenerating bread in your analogy).

You can make all the regenerating ham sandwiches you want from the regenerating loaf of bread. The GPL only restricts what rights you have to pass along to anyone you give ham sandwiches to, basically ensuring that you do not have a monopoly on regenerating ham sandwiches.

You might consider that restriction to be just as onerous as restrictions on what you can make with the bread, but I think there is a categorical difference. The GPL only affects transactions with other people. You can use the loaf of bread for making ham sandwiches or biological weapons and the GPL has nothing to say about that.

Not only can you make the ham sandwich, but when you give ME the ham sandwich I can put mustard on it, and when I give it to some one else THEY can put cheese on it.

Because that's what the GPL does . It ensures that the right to modify the (sandwich)program never gets taken away from the next user in the chain.

It's more like donating a loaf of bread but stipulating that the person you donated to cannot sell it for profit.

So really, using the GPL is like donating to a non-profit where using a BST/MIT license is like donating willy nilly to any person or corporation regardless of their aims or practices.

But really, the whole analogy is deeply flawed.

The GPL is just a pain in the ass for all involved. At least that's how I see it.

You are not alone.

I find the GPL, but more so variants like the Affero GPL, to be ticking time bombs. And I have followed the development of FOSS over the years and occasionally helped out a project, so I probably have more interest than most people who aren't in the FOSS community.

The lawyers and managers at companies where I've worked were far more pragmatic: it's not worth the time and risk to analyse the licensing implications of every bit of GPL'd code we might consider using as part of our own project, so just blanket ban any development use of such code across the entire organisation and avoid any potential legal risks. In short, using GPL'd code is fine, but doing any kind of development with it is a firing offence, end of discussion.

I think this is a very sad state of affairs, but knowing how complex the legal issues can become, how militant certain FOSS groups can be, and how much damage such a group could cause in PR terms even if they had no legal case at all, I can't say I blame the lawyers and managers for their "not touching it with a 10' pole" policy.

What do you mean by ticking time bombs? For all the shenanigans surrounding the GPL, its terms are pretty easy to comply with.

I think it's mainly the burden of tracking everything.

If all your code is either written in house or source you've explicitly licenced on some commercial basis then chances are there's no problem borrowing a bit from somewhere and reusing it somewhere else.

But suppose you've got GPL'd code floating around, and then someone builds something based on it that's used perfectly legally in-house, and then someone later borrows some excerpts from the GPL'd code and reuses them in another part of the system, and then someone else later decides the GPL'd library/whatever isn't needed any more and cuts it out. Now you've got code floating around that you think your organisation owns, but really it doesn't.

Of course it's possible to comply with the rules by diligently noting any reuse of GPL'd code, and of course there are somewhat related issues with giving due credit even with permissive licences or code you've licenced commercially. But in reality, things go wrong, particularly on long-lived projects where developers come and go. Having GPL'd stuff integrated into your dev process if you're not an all-GPL house just seems like a lawsuit/PR nightmare waiting to happen if you run into one of the more militant groups, and short of imposing expensive and time-consuming audit processes there's not really much that management can do to mitigate that risk.

"Chances are" isn't much of a legal defense. If you're concerned about the costs of auditing and compliance for copyleft software, why not more so for software under less permissive licenses?

I think there are two points here.

Firstly, if you're paying actual money for something, someone in authority has necessarily approved its use and any necessary review by lawyers should already have taken place (and this does actually happen IME).

Secondly, if you're paying actual money for the source code to a library and it wasn't very obviously provided for another reason, it is extremely likely that what you were getting for your money was the right to reuse that code as part of your own project. That's just how the industry works. It's not a 100% guarantee, of course, and standard disclaimers about consulting a lawyer apply, but even if you didn't do that the practical risk here is very low, while numerous places have got caught out when a developer "borrowed" some GPL'd code and didn't tell anyone.

Erm, isn't "share-alike" closer to the GPL than MIT/BSD licenses? That is, the whole point of the GPL is that anybody who uses your code has to release the product under the same license; this is exactly what the "share-alike" licenses do as well.

My cynical view is that at some point in the past few years, the perfect storm of outsourcing, funny money bonanzas aka IPOs, and the standing mindset of corporations to focus on their self interest (and not but) got us to this point. The winners have been the corporations (surprise) and a few (very few) rock star OSS developers. Everyone else is being taken for a ride, in my opinion.

I release OSS software myself. So far, Apache 2 only, but decided to switch for everything new to (L)GPL a couple of months ago. GPL makes sense economically, socially, and politically.

People understand GPL just fine. The described trend is caused by consciously rejecting GPLs ideals, not because of ignorance.

In academia my impression is that the decline of the GPL is due to business models more than ideals. There was a period of popularity in the 1990s and 2000s where dual-licensing GPL/commercial was used as an attempt to both open-source the code while still making money from commercial users who would pay for a non-GPL license. The copyleftness in that strategy wasn't really about agreeing with RMS, but about making sure you'd get paid if the next version of Matlab shipped with your code in it. But only a handful of projects that've tried that have been successful at making any money from it (the Stanford Parser is one example that has been).

My anecdotal impression is that the trend is therefore towards picking either openness or money as the goal, instead of trying the dual strategy. If openness is the goal, you pick MIT/BSD, because they're simpler and you hope lots of people will pick up your code, and maybe you'll get paid in citations and PR. If money is the goal, go for a full commercial licensing strategy, and either don't release the code publicly at all, or release it with a research-use-only/no-commercial-use clause.

What I've found is that open sourcing components that are not central to your business, but that your business depends upon, provides you with free stress testing, bug fixes, and enhancements. That's a huge win, and leaves you with more resources to concentrate on things that ARE central to your business.

In order to maximize uptake on your open sourced component, it makes sense to have an uncomplicated license. Take a look at the following licenses:

http://www.opensource.org/licenses/MIT

http://www.apache.org/licenses/LICENSE-2.0.html

http://www.gnu.org/licenses/gpl-2.0.html

http://www.gnu.org/licenses/gpl.html

When I'm looking to use some component I found on the internet, part of my decision is based on the potential for legal pitfalls. I suspect that others feel the same way.

I don't think that most people understand the GPL. Everybody understands the basic spirit of it, but there are lots of details spread throughout that huge document. The preamble is longer than many permissive licenses. .That there is a preamble at all speaks to the complexity. It's too much for a small group or individual without access to a lawyer, and I don't think people in these cases are going to use a license that they don't fully understand.

I just took the time to read the GPL both versions 2 and 3. It is pretty cut and dry as far as licenses go. Do you have any actual evidence that small groups or individuals are having trouble understanding it to the extent that it would have a statistically significant impact on its uptake?

"The described trend is caused by consciously rejecting GPLs ideals,"

I very highly doubt that.

There are 3 cases I can think of:

1 - Business related models: "we're scared of GPL, we don't know what it is, but force devs to use smth else or code it from scratch"

2 - We're devs and due to 1, and possibly startups, we'll want non-GPL code. We'll also start to spam the community how GPL is bad in any possible way.

3 - All the devs are telling me GPL sux. I'm a cool and hip new person I'll do what they say to fit in. (I don't even care about what the GPL is made for).

Now, one could wonder, why'd they want to even use BSD or similar licenses? They could just go with public domain. THat's "real" freedom to their ears isn't it? Anyone does anything they want with it. Perfect.

Not so. They use BSD for credits. BSD forces you to retain copyright in the code, and that means if your name is in the code, you're getting a job very, very easily.

So you see, all the above only tells me one thing: People who know are misleading others (like you just did) on purpose for financial reasons, not because GPL ideals are wrong.

It would be OK if they at least mentioned the reasons in these simple terms. But that wouldn't help them achieve their goals, if others keep on using the GPL.

Shame on them, shame on you.

..Not so. They use BSD for credits.

I don't quite understand....why is it shameful if a developer wants to retain ownership/claim authorship over the code that he spent time and effort in developing?

"Public domain" is an unclear concept, I am under the impression that in many countries there is no such thing as "public domain" from a strict legal perspective. BSD is (for me) the closest thing to a clear legal "public domain", and that is why I use it.

Also, the GPL is incompatible with the iOS store, which is a serious problem for many people.

This is correct. For example, German law is based on the concept of 'Urheberrecht', ie 'creator's rights', instead of 'copyright'.

This is the reason why copyright notices (which were mandatory in the US until 1989 according to Wikipedia) were never necessary in Germany and why there's no direct equivalent to public domain:

As soon as you create something worthwhile, you gain creator's rights, and as you remain the creator no matter what you do or what usage rights you grant to others, you can't give them away completely. There's a somewhat recent, rather embarrassing quote by German politician and lawyer Volker Kauder, who claimed to have acquired creator's rights to some images he used on his homepage without having the appropriate usage rights.

Anyway, you need an explicit license like http://pdclib.rootdirectory.de/wiki/License or http://creativecommons.org/publicdomain/zero/1.0/ if you're German and want to add code to the 'public domain'.

If there was a GPLed project for every paranoid rant on how anyone interested in any other license is trying to mislead people and destroy the GPL, TFA would never have been written.

I'm not sure to understand your comment, but as it sounds like.. there's nothing wrong with being interested in another license.

TFA and TFC are however some of many anti-GPL FUD, which is quite different from simply "being interested by other licenses".

No, shame on you for actually trying to turn that around and accuse the poster.

The religious war of "free" versus "open" is what turns a lot of people off.

Previously, when posting code I wrote, I'd pick MIT license which would allow users to do what they wanted. Picking GPL would mean that many potential users would be prohibited by company policy from using it.

Exactly. I'm one of those who honestly doesn't mind if anyone comes along, forks, closes the source, and makes a million off my code. I think it's a lot about money. There's also this rejection of the FOSS ideals. The GPL puts a lot of people off because it can be perceived as being more about ego and anti-profit rather than true freedom. For me personally, I prefer open source to free because I'm against restricting anyone's usage of my code and don't mind if they don't contribute back.

I think people's intentions have changed too. It was once all about paying things forward and now the importance seems to be placed on simply sharing with no regard to how the code is used or by whom.

I prefer open source to free

The approaches are different, but in terms of licenses and rights, Open Source and Free Software are mostly the same. MIT and BSD are Free Software too.

Really? I mean, I know they're very close but correct me if I'm wrong here:

First, let me be clear that I'm talking about Free in terms of how the GPL codifies it.

So Free software a la the GPL always begets more free software. Open source on the other hand is free but you can close that source up and make a nice profit without contributing back. I'm for the latter and that's the distinction I was getting at. I know all the licenses have their nuances but generally speaking free GPL style licenses forbid not contributing back whereas open source generally let's people do as they please as far as contributing your changes go.

Free Software, as defined by the FSF, includes both copyleft like the GPL and permissive licenses like BSD. Open Source, as defined by the OSI, does the same.

Essentially, it's Free Software any license that provides the following four freedoms:

    The freedom to run the program, for any purpose (freedom 0).
    The freedom to study how the program works, and change it so
                             it does your computing as you wish (freedom 1).
    The freedom to redistribute copies so you can help your neighbor (freedom 2).
    The freedom to distribute copies of your modified versions to others (freedom 3).

Copyleft (like the GPL has) is a way to ensure that the four freedoms are transfered to any derivative work, but:

    A free license may also permit other ways of releasing them;
    in other words, it does not have to be a copyleft license.

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

Empowering with something that can't be enforced in practice is not exactly empowering, it's a make believe.

Why do you say it can't be enforced?

I'll answer that - because only the developer can enforce it. Let's say you're an end user and you know for a fact that a library in a proprietary app is GPLed and the seller is not complying with the terms of the license by not coughing up the code.

You don't have the legal standing to take the the seller to court and demand they comply with the terms of a license between them and the original developer of the GPL'ed code, even though you're technically a party to it as the release of the code benefits you.

Law is a funny thing.

I agree in the literal sense, but couldn't you look at the GPL as an agreement between the original developer and all downstream users that the developer will enforce terms when violations are brought to light?

One would think - but the obligation is not there (nor should it be really, this would only hamper its further adoption even more than it already is)

Agreed it's the right thing to do, but if I write a GPL module which is later used in say, a Microsoft product, I don't have the desire, the time, or even the money to take them to court.

How exactly are you going to enforce GPL compliance when a Chinese company uses your library in their proprietary product?

Bonus question - what exactly will you be gaining by spending your time on enforcing the GPL compliance rather than on something else (like coding)?

Nothing. That's why the GPL can be easily seem as being all about ego and anti-profits rather than freedom. Even if the company in your scenario violates the GPL it doesn't do anything to hurt software freedom. The GPL seems to be a tool to force FOSS ideals down people's throats rather than the nice sounding ideals that are the official party line. A GPL violation doesn't stop free software advocates from paying it forward and sharing and the original source is still available to anyone who wants it. But few people really want freedom. The goal of the GPL can easily be mistaken to be to turn all software into GPL software. In fact the existence of the GPL itself can also be mistaken as a clever ploy to infect non-free software and make it free.

Sorry, but how don't see how the GPL forces anything nor does it "infect" anything. That kind of loaded terminology is just BS.

The GPL offers you a deal that you can accept or refuse, just like any other license. The terms are definitively more onerous than permissive OSS licenses, but that's it.

To be clear, I really wanted to point out that it can easily be perceived the way I described. I wasn't really trying to say that it's actually so. Honestly, I'm not a big fan of the GPL myself so it probably came out that way but the bigger point wasn't about my personal preferences but just how the GPL lends itself easily to that kind of thinking.

  >nor does it "infect" anything.

Yes it does, which is part of the damn point. If you incorporate GPL'ed code into your app, your app is now subject to the same terms by default.

I understand the visceral reaction to the word, but it's generally accepted that the GPL has a viral nature.

An infection implies invasion. Until GPL'ed code starts copying itself to your projects, it's not an infection.

As RMS himself said:

    The GPL's domain does not spread by proximity or contact, only by deliberate
    inclusion of GPL-covered code in your program. It spreads like a spider plant,
    not like a virus.

it's generally accepted that the GPL has a viral nature

It's generally accepted after the smear campaign by GPL haters, just like the "General Public Virus" expression and the "cancer" remarks by Ballmer. It's still a pejorative and, in my opinion, defamatory term.

  >An infection implies invasion

A willful infection is still an infection. Whereby an invsasion is always unwanted. You can't willfully invade your own code, but you can willfully infect it - whether that be with other code, or licenses.

But now we're getting into semantics..

> How exactly are you going to enforce GPL compliance when a Chinese company uses your library in their proprietary product?

Depends if it's hardware or software. If it's hardware, Customs gets involved. Software's harder, but the fact that there is a set of circumstances which make enforcement difficult do not make enforcement in general impossible, nor does it invalidate the concept behind the GPL.

> Bonus question - what exactly will you be gaining by spending your time on enforcing the GPL compliance rather than on something else (like coding)?

You'll be gaining GPL compliance. That's the point.

Reply on news.ycombinator.com