GPL, copyleft use declining faster than ever
itworld.com
itworld.com
GPL makes a lot of sense for the former. If you write the Linux kernel, a ton of companies would take it, enhance it, and not contribute back without GPL. That's a big part of what killed BSD. On the other hand, almost no one is going to reimplement Linux just to get around the GPL -- it's cheaper and easier to just give back.
For the little libraries, permissive makes more sense. If your JavaScript control has a license that isn't permitted in my project, I'll just write my own in a day or two. If I enhance it, that's not a core advantage to my business, so I'll likely contribute it back.
As a case example: Apple has modifications to their version of WebCore (lower-level than WebKit, for context), a project shipped under LGPL (unlike WebKit, which is distributed under a modified BSD license).
However, they don't want to have to give out those changes, so they provide the source code to a WebKit with some minimal changes to call into new code that they then don't provide: it will compile, but you will get link errors.
Understand: this new code may be critical to the functionality of the library, and may be modifying the behavior of or even outright replacing key APIs and mechanisms of the LGPL library, in this case WebKit.
They then provide binary object files for the new functionality that they added, and the result is compiled together to form the unified WebCore dynamic library. Even though the result is a single linked-together library, this is totally legal under the LGPL, as I can still modify the original WebKit code if I wish and still manage to build Apple's modified WebKit binary.
In essence, the boundary around the LGPL code can be made very tight indeed, such that even code that is semantically required for the library to function does not fall under the redistribution requirements of the GPL part of the LGPL code.
That is always touted by GPL advocates, but where is the proof? Where are all the companies enhancing non-GPL-licensed software and not giving anything back? Where are the companies making money selling private forks of enhanced FreeBSD, NetBSD, OpenBSD, Ruby, Python, Ruby on Rails, X11, Apache, etc.?
It doesn't make sense. Maintaining your own changes in a big software project is a pain in the ass. It's worth contributing changes upstream if only so you don't have to maintain your own patches and re-merge them every release.
Building xnu from public sources is quite an undertaking. It does still seem to be possible (although it got a lot harder with the x86 transition due to more proprietary drivers). The PureDarwin distribution still seems to be based on the Snow Leopard kernel, I'm not sure why. http://www.puredarwin.org/
They're doing it to GPL software. Take a look at pretty much any embedded Linux project and you will find a GPL violation. For example, most ARM devices are unusable without binary drivers that rely on specific builds of specific Linux kernel versions (example - you can't get sound or accelerated video on the Raspberry Pi!). I've had one plug computer maker tell me they have a custom version of Linux and they won't provide the source. Whenever I come across anything like that I report it at http://gpl-violations.org/
Sun Microsystems?
I think part of it has to do with a tipping point: if you can hire up a good chunk of the key contributors and run with it, then it's easy to make a proprietary fork, and at the same time weaken the open source project. The GPL prevents this. The other thing that prevents it is if it's impossible/difficult to hire up enough people for a proprietary fork to outstrip development of an open fork. So with permissive licensed projects, you want a big core team comprising people with diverse interests and incentives.
Also, I think things have changed over time - perhaps, 'back in the day', there was more the idea of not contributing back by default, whereas I think far more companies have made their peace with open source these days, and understanding that being involved and contributing are good things. This tilts things in favor of permissive licenses.
+ Apple
They contribute back only whatever they see fit, and that's in perfect accordance with the licence.
Apple has also contributed a lot that they weren't required to contribute. Sure they are an example, but they are not nearly as cut throat as people like to make them out to be. Look for Apple.com on commits to the FreeBSD source tree...
No, it doesn't. Those key contributors are still the copyright holders of the code they contributed, and they are free to redistribute those contributions under different terms. If they all work for one company, they can just license copies of their code to that new company under non-GPL terms. The GPL fork still exists, but now a new, closed-source version of the code can be made with all of that (now-)employee-written code. If there are enough of those components, that company can just rewrite the code contributed by others that were only licensed under GPL, and now they have a mostly duplicate version of the same program, able to be extended and resold without source code.
Digium does this for the Asterisk project. They have a GPL version that everyone is free to use, but nobody else is allowed to redistribute it without the source code. However, they make all contributors to the GPL project license their code to Digium so that Digium more-or-less owns the code, which Digium then turns around and sells under a closed-source license to companies that don't want to give their changes back to Asterisk.
[1] https://www.microsoft.com/download/en/details.aspx?id=274
The lawsuit was the big problem.
Meanwhile components like libraries, frameworks, have since long leaned towards permissive or atleast LGPL style licencing due to them constituting only a small part of whatever program they are used in.
Like the edited article states, the author was wrong in saying GPL is declining or that projects are in any way switching, the thing is that these days we see lots of new open source developments in web technology frameworks and these frameworks are predominantly permissively licenced as they are basically components on which full web solutions are built.
And given the sheer number of web oriented open source tech popping up these days it's no wonder we are seeing new permissively licenced code dwarfing new GPL licenced code these days. For example when I viewed the 'Popular Watched Repositories' list on github, the only ones I know are GPL licenced were Linux and Git, and the list was heavily dominated by web targeted projects.
Now there seems to be a strong anti-GPL sentiment in web dev, which is likely due to people working there relying heavily on open source components for their proprietary solutions and as such they simply can't use GPL, hence complaints.
Bottom line is that there is no 'one type fits all' licence, which is why we have licence proliferation. I've always held the belief that whatever the author chooses is the right option, be it permissive, GPL or even keeping it proprietary.
However, if the result of my work will be made available under a more permissive license i (most likely) demand less money since it ensures that i can reuse whatever i wrote.
The USL lawsuit is what hampered the BSDs early on, and allowed Linux to get so much traction in mindshare, not the license.
Another interesting thing about that world is the level of quality and participation in an open source ecosystem that doesn't legally mandate participation. It leads me to think of the GPL as an exclusionary license.
I think the reason that happens for ruby and python is so many of the people using those platforms are startups where the technologists are the guys calling the shots, and it probably doesn't work universally, but I am glad I work in a part of the industry where we let people participate on their own terms, it just seems more meaningful.
I totally get that it isn't like that everywhere though, and the only way to get good cooperation is to hold a gun to the head of large corporations.
Then they should have absolutely no problem with the GPL.
but releasing something as GPL makes that impossible
Please explain how requiring distributors to include access to source code makes it impossible to contribute source code.
how is that out of context?
I view the rise of EULAs and "terms and conditions" pages and all that junk to be one of the biggest retrograde steps in technological history, because most of the things in these documents are legal weasel words that don't have much to do with technology at all, or even with regular users who just want to use the software in a normal way for that matter. By playing the legal game, unfortunately the FSF has essential stolen the old embrace/extend/extinguish model from big business and applied it to hobbyist software development, legalificationalising it so that lots of people who just want to hack on code and share their results with anyone interested are now divided among fragmented communities and might not even know what they can and can't do any more. Way more time and effort gets spent worrying about licence agreements and how stuff can be used than anyone used to care about, and are we really any better off for it? I don't think we are.
It never seems to occur to anyone today that the reason things used to work well wasn't that hackers shared code because someone forced them to. It was that they shared code because they enjoyed it and other people often shared their own code in return for the same reason, without any formal obligation or having legalese bullshit plastered all over the top of every source file. I suspect if the only two licence agreements supported by law were "no copying without payment/permission" and "copy freely but give fair credit" no great harm would be done and a lot of people would waste a lot less time worrying about things other than building cool stuff with code. (Edit: Of course this is a simplification, but you get the idea.)
This was fine in the demo scene, but if you want to expand FOSS to businesses and paid applications, you need licenses. It wasn't the FSF who introduced that - it's how copyright works.
Maybe using permissive licenses would've been better than introducing the GPL, but you'd still need some license.
EULAs and TOS are completely different issues.
The world is not a better place because ordinary people with no legal training and better things to do with their time are subject to multi-page formal agreements, which most of them have never actually read, never mind understood. I don't care whether it's a software licence agreement or the terms for a network service, it's still the same basic problem.
Yes, but who's "we"? Did that include the thousands of business that nowadays use and contribute to OSS and also have lawyers to worry about those things?
The world is not a better place because ordinary people with no legal training and better things to do with their time are subject to multi-page formal agreements, which most of them have never actually read, never mind understood.
But it was copyright that created that, by prohibiting any redistribution and derivation by default. FOSS licenses are a way to counter-act that and give you rights.
And while the GPL is not as short as we would like, the reality is that it created a standard; you just have to read it once to know the license of more than 50% of the FOSS projects out there. That seems a time saver, not killer.
You know it didn't. But I don't really see how that's relevant to my point. If it takes several pages of legalese to define what "freedom" you are giving someone, you might want to consider whether you're using the right word for what you're doing.
But it was copyright that created that, by prohibiting any redistribution and derivation by default.
No, it wasn't. It was bad lawyers who can't write plain English, and picky people at the FSF who tried to fine-tune everything instead of stating a clear guiding principle.
There are plenty of other licences that are very much shorter.
And while the GPL is not as short as we would like, the reality is that it created a standard; you just have to read it once to know the license of more than 50% of the FOSS projects out there. That seems a time saver, not killer.
Sorry, but that's just wishful thinking.
Firstly, I suspect that a lot of people use the GPL not because they like or understand it but because it was the peer pressure "what you do" option for a while. Those kids used to just give their code away as freeware and no-one was any worse off for it.
Secondly, it's not really a standard when there are at least three styles of GPL licence that come up reasonably often in discussions (GPL, LGPL, AGPL) and then there's the whole v2/v3 mess as well. In fact, this kind of fragmentation is probably a large part of why we're having this whole discussion on HN today.
Finally, while I respect the goal of trying to have some standardised licensing, the only standard I've observed in practice is that, unless you're working in an organsation where everyone values GPL-style licensing and uses it as an integral part of your business model, the lawyers and managers are likely to blanket ban any use of GPL'd code because the risk of the viral contamination effect is too high to justify any benefit from using it.
On the other hand, it's easy and feels safe to reuse code that comes with a no-nonsense BSD/MIT style licence that says in plain English that you can use the code without understanding several pages of legalese with subtle implications. That saves time.
There are plenty of other licences that are very much shorter.
Well, unlike permissive licenses, the GPL is an hack on the copyright system; they probably wanted to make sure it would hold up in court.
But the GPL isn't really that long; the 2.0 is only 340 lines of 80 characters. Yeah, it's long compared to MIT, but it's still a fraction of most legal documents.
Firstly, I suspect that a lot of people use the GPL not because they like or understand it but because it was the peer pressure "what you do" option for a while. Those kids used to just give their code away as freeware and no-one was any worse off for it.
"Freeware" doesn't include the right to modify and re-distribute. Yes, we were certainly worse off for it. If you mean Freeware as a different concept, well, then it's easy to see why licenses are useful - they clearly define that stuff, so you can sleep at night knowing your business or webapp or whatever won't get sued to the ground tomorrow.
Secondly, it's not really a standard when there are at least three styles of GPL licence that come up reasonably often in discussions (GPL, LGPL, AGPL) and then there's the whole v2/v3 mess as well.
The differences between the three versions are minimal - a clause or two more, nothing else.
The v2 vs v3 issue is problematic, I agree. On the other hand, protection against software patents is important. MIT, for example, provides none.
It seems irrelevant 'till you get hit by a patent troll, like startups are already getting hit.
Finally, while I respect the goal of trying to have some standardised licensing, the only standard I've observed in practice is that, unless you're working in an organsation where everyone values GPL-style licensing and uses it as an integral part of your business model, the lawyers and managers are likely to blanket ban any use of GPL'd code because the risk of the viral contamination effect is too high to justify any benefit from using it.
True. But unlicensed or implied licensing is dangerous too - you need some kind of legalese.
On the other hand, it's easy and feels safe to reuse code that comes with a no-nonsense BSD/MIT style licence that says in plain English that you can use the code without understanding several pages of legalese with subtle implications. That saves time.
Wait till you base your company on someone else's MIT licensed code and then get hit by a patent lawsuit from them or a troll with their patents. Safe? I don't think so.
Is that all?!
Out of curiosity, what proportion of people who choose to licence their own code under the GPL do you think have actually read all of that and consulted a lawyer to make sure they understood the terms they were themselves proposing? I'm not even considering the equivalent question for the wider population of users and downstream developers affected by the licence terms yet.
"Freeware" doesn't include the right to modify and re-distribute. Yes, we were certainly worse off for it.
In what way? We didn't worry about offering others formal rights in those days. People shared source code if they thought they had something worth sharing, without making a big deal about it. Such code frequenty came with comments to the effect that you could use it however you liked but please give credit, or words to that general effect, which would have just as much validity in court as a modern MIT or BSD licence for example.
The differences between the three versions [GPL, LGPL, AGPL] are minimal - a clause or two more, nothing else.
Wow. That's a mighty bold claim, and one I don't think a lot of software developers would agree with. The changes in wording may only be a small part of a vast document, but the implications are profound.
It seems irrelevant 'till you get hit by a patent troll, like startups are already getting hit.
The correct solution to patent trolls is not to allow things like software patents in the first place. It's a controversial subject and there is far from consensus internationally or even within some national governments on whether software should be patentable at all.
In any case, I think you are imagining a legal shield that is not there. Patent trolls typically don't contribute to a FOSS project and then go after other people who use it. In fact, patent trolls typically don't contribute much of anything to any project, which is one of the reasons they are... not well thought of. If you're using someone else's code and you don't have some solid legal agreement that they indemnify you fully against all the related IP threats, you're not safe, and no FOSS licence provides such indemnification; many explicitly state precisely the opposite.
For that matter, you don't have any real protection in a troll-friendly legal system even if you never use anyone else's code at all and you write every line yourself. I don't think there's much argument in favour of GPL-esque legalese to be found here. My personal view is that some of the GPLv3 stuff is basically the FSF trying to conflate two unrelated IP issues and leverage the viral nature of the GPL to advance other parts of their agenda. Which is a pretty scummy thing to do, actually.
Not many, but I'd guess they didn't read MIT nor BSD either.
By the way, the original BSD licenses forced you to acknowledge the upstream project in any advertising materials for yours. How many people read that? Not many, I would guess.
In what way? We didn't worry about offering others formal rights in those days. People shared source code if they thought they had something worth sharing, without making a big deal about it.
As I said, that's fine in a community of hobbyists, not if we want businesses contributing. But that's a different issue.
which would have just as much validity in court as a modern MIT or BSD licence for example.
Do you have any example of a lawsuit where such freeform license was valid?
Besides, even if it was, I doubt people had enough trust in that to release commercial stuff based on it.
Wow. That's a mighty bold claim, and one I don't think a lot of software developers would agree with. The changes in wording may only be a small part of a vast document, but the implications are profound.
I was talking about the license text, not the implications.
The correct solution to patent trolls is not to allow things like software patents in the first place. It's a controversial subject and there is far from consensus internationally or even within some national governments on whether software should be patentable at all.
I'm sure the FSF would've ended software patents if they could, but it's hardly fair to criticize them for not doing so. They did what they could: route around them.
I would think the patent grant protects in the case the upstream developer sells those patents to a troll after you're already using the code, but I'm certainly not sure.
My personal view is that some of the GPLv3 stuff is basically the FSF trying to conflate two unrelated IP issues and leverage the viral nature of the GPL to advance other parts of their agenda. Which is a pretty scummy thing to do, actually.
This talk about the GPL being "viral" is just FUD. If the GPL "infected" your project if because you made the voluntary decision of including GPL-licensed code in it.
And why is it scummy? They provide a tool (the GPL) to whoever wants to use it. Advancing the Free Software Movement is obviously one of the goals of the tool, like mostly anything the FSF does.
Yes, precisely! And one of the ideals that Free software is designed around is that there are no end users - everyone can be a developer (or farm it out to anyone willing to work the job - ultimate free market capitalism). Unfortunately, there are still bills to be paid, and people are raised in the mindset of "I've got mine; who cares about anyone else?" and always grasping for more. So they think they can't make any money with GPL software, or it will expose them to legal worries, or they'll be forced to open source all their code. In the case of the first, this is categorically not true. In the latter two cases, no one has been able to bring up a credible example of when this has ever happened in the 20+ years the GPL has been in existence.
One last thing: the data used in the article is from a very well known Microsoft front company: http://techrights.org/wiki/index.php/Black_Duck
"That was the conclusion of Matthew Aslett's analysis of recent data from Black Duck Software"
I'll just leave this here:
I think you could argue that it took radical people with radical opinions to make open source what it is today, but GPL is overkill for modern development and (in my opinion) completely unnecessary.
Attempting to control what people do with the software they create is, in my opinion, not only wildly inappropriate but also very self-defeating, as it limits the number of people who can do anything with your license. Likewise, there's this:
"Take a look at pretty much any embedded Linux project and you will find a GPL violation. For example, most ARM devices are unusable without binary drivers that rely on specific builds of specific Linux kernel versions (example - you can't get sound or accelerated video on the Raspberry Pi!). I've had one plug computer maker tell me they have a custom version of Linux and they won't provide the source."
(from @sedachv's comment)
The sheer number of GPL violations out there in real life point to the fact that the license is unenforceable in practical terms, because of the legal budget a project would need in order to prosecute what is essentially an epidemic of victimless crime. If your project uses GPL, you're more likely to see an increase in corporations shrugging off open source licenses (or laughing at them) than an increase in corporations contributing code back. GPL violations are not a criminal matter. You can only enforce them with civil lawsuits. Who's going to pay for that?
Imagine if Linux aggressively asserted its rights under the GPL against every violator out there. it'd be a full-time job for a whole team of lawyers -- an astronomical expense which absolutely nobody would benefit from, except for the lawyers themselves.
There's absolutely no reason to expect companies to comply with the GPL, other than good manners and good ethics, both of which are rarer than they ought to be. The GPL just encourages those qualities to become even rarer. It's self-defeating and it's bad for open source in general.
Nonsense, they are legally bound by the licence to provide source code when distributing binaries should the recipient request it. Obviously there are violators counting on not being taken to court but they are still violators and are running the risk of being being sued.
Let's say that Oracle would stop releasing the source code to the enhancements they make on Linux for their distribution, do you think Red Hat, IBM and other large contributors would just let Oracle use their enhancements while violating the GPL by not releasing their own? Hardly, they would take them to court.
GPL works well for this kind of cooperative project where lots of different players pool their resources as everyone is legally bound to release their enhancements. This obviously doesn't mean that every licence violation will be brought to justice, but the important thing is that they are in their right to so should they find it necessary.
However the fully open source development of Linux doesn't fit all projects, looking at FreeBSD it seems it's mainly being used by companies who wants to incorporate it into proprietary solutions where they make changes to the kernel/system which are used as a competitive edge and thus don't want to open source those.
Again, there is no 'one size fits all' solution and as such it's a good thing there's choice.
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.
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 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.
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?
Also, the GPL is incompatible with the iOS store, which is a serious problem for many people.
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'.
TFA and TFC are however some of many anti-GPL FUD, which is quite different from simply "being interested by other licenses".
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.
The GPL has a lot of FUD about it, but there's very little actually offensive about it.
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.
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.
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 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.
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]
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.
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."
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."
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.
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.
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.
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.
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.
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.
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?
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.
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.
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.
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.
Bonus question - what exactly will you be gaining by spending your time on enforcing the GPL compliance rather than on something else (like coding)?
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.
>nor does it "infect" anything.
I understand the visceral reaction to the word, but it's generally accepted that the GPL has a viral nature.
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 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
But now we're getting into semantics..
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.
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.
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.
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.
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.
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).
A free license may also permit other ways of releasing them;
in other words, it does not have to be a copyleft license.