Stallman had a printer which had proprietary drivers, and he wanted to fix an issue with the driver. He couldn't. He created the GPL so that, in future, people wouldn't have this problem.
Stallman created the GPL because he cared about user freedom.
> Stallman created the GPL because he cared about user freedom.
> Stallman created the GPL because he cared about user freedom.
As GPL has evolved, the focus on user freedom has gotten clearer. It is not that GPL is against freedom for developers or software vendors. However, the way I understand it the consequences in this area are more side effects than guiding principles.
It is not like the focus suddenly changed at some point. It has alwasy been this way. Let us look at how FSF defines free software:
> A program is free software if the program's users have the four essential freedoms:
> The freedom to run the program as you wish, 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). Access to the source code is a precondition for this.
> 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). By doing this you can give the whole community a chance to benefit from your changes. Access to the source code is a precondition for this.
Without even reading the four points, we already see that what defines a software as free software is whether or not the "program's users" have certain freedoms.
https://www.gnu.org/philosophy/free-sw.en.html
(I am not a lawyer. This is just my personal interpretation.)
>Stallman had a printer which had proprietary drivers, and he wanted to fix an issue with the driver.
>Stallman had a printer which had proprietary drivers, and he wanted to fix an issue with the driver.
In the fixing mode, Stallman was not operating as a user, he was operating as a developer. This is a "freedom 1" activity, which is a freedom that is only useful for developers.
The user and the developer can not be fully separated when it comes to freedom here. Modification of software, and redistribution of that modification is fundamentally a developer activity. Non-developer users can hire developers to do what they want, but ultimately there's a developer involved in this, otherwise what's the point of source code?
Let's say I'm a user of that vehicle. I read this article. I want my Jeep audited and fixed, and I want the code modified to indicate any time the vehicle is accepting remote commands.
You cannot separate developers and users, because users can hire developers to perform actions on their behalf. I can't fix my own car, but I have problems with it, and I want to be able to hire someone of my choosing to fix it.
In that situation, as a consumer, I'm actually pretty jazzed about living inside Apple's walled garden on my iPhone. The phone refusing to run unsigned code gives me a little bit more security.
It also largely defeats the scenario where I can hire someone to modify my phone's software. But I'm OK with that tradeoff, because I think it puts me on the side of greatest benefit to myself. I suspect most non-programmer users would fall in the same camp.
If you think about it, package repositories are just like app stores. They're curated, centralized places to obtain software where you can have high confidence it's free of malware.
...And it's free software with no arbitrary usage restrictions. Meaning you can actually audit it if you so desire, and in fact you'll be doing a great service to users and developers in the process.
Exactly linux distributions have had app stores for ages which have a lot of freedom. And then there are things like the arch user repository which is even less controlled and also great.
It's a rational choice given the complexity, but makes you totally vulnerable to your feu lord. And their feu lord.
By the way, there is no necessary conflict between signing and software freedom if the system allows you to replace the master keys. Matthew Garrett is doing a collection of work to enable Linux users to use UEFI and TPM hardware to secure themselves against malware.
You should think what malware is. Maybe apple software is malware as well. Anyways if you could review the source code of the "malware" you (or people who can read it)could know what it does in advance and avoid it. And code could be signed and verified and still be free software. Linux distros verify software signatures and have almost no malware problems and at the same time use a lot of free software. So free software makes users more secure if anything.
What you're describing is security by obscurity, and it has been shown countless times that it never, ever works.
It does not prevent flaws from being discovered. It slows down the discovery of some flaws, but this also means that the people who discover them can exploit them for years if they're malicious, because flaws are equally hard to discover as part of a well-intentioned an audit as they are as part of an evil plan.
It also allows flaws that have been intentionally introduced to be hidden from sight for a long time -- and allows companies who do so to escape untarnished; since the commit logs are not available (and the source code is often only available in disassembled form), they can always claim it's a bug, not a feature.
It does not provide additional safety, it provides only an illusion of safety -- while making actual safety a lot harder to implement, for everyone.
Locking a computer into running signed code is just like programming Firefox to refuse to access https sites without properly signed certificates. There's nothing about it that's incompatible with a fully free, GPL software stack. In the case of Firefox, you're trusting the Certificate Authorities. In the case of the iPhone, you're trusting Apple.
You could argue that Firefox leaves open vulnerabilities to things like Superfish (that Windows root CA didn't actually affect Firefox in most cases since Firefox keeps its own list), but you can take the signing concept as low-level as you like, including requiring a signed OS with a hard-coded, single software delivery mechanism which could still be fully GPL.
You get a little bit of security by trusting Apple. But Apple does not give you the option to also trust someone else.
You trade your freedom against short-term convenience. On the long-term it means that you have to accept all decisions Apple takes, even if you dislike them.
You seen to be implying that the user is empowered only if he is also a developer, or has access to a developer. The respondent is trying to show how this is still empowerment.
Would you rather be in a position where you can't hire a developer to improve your software, or more likely download the patch that was donated to the community?
I say he's trying to tell you that like I know; I should have said I presume that's what he was getting at. On a first reading, that was my interpretation. A very common argument criticising free software is that, since most users can't code, they cannot benefit from the 4 freedoms. This probably prejudiced my interpretation of your comment. Reading it back now I can see what you meant.
Your intentions were unclear. When I read your post it sounded like you were arguing that the GPL was to protect developers, not users. The edge case where user = developer isn't an immediately obvious one so it bears clarification.
> In the fixing mode, Stallman was not operating as a user, he was operating as a developer. This is a "freedom 1" activity, which is a freedom that is only useful for developers.
If a "pure user" has an issue, and that issue is with free software, that user can go to the open market and hire a developer to solve the issue.
You don't have to be a programmer to benefit from the freedom; that is a fallacy. All users benefit, programmers or not.
Any user can become a developer if he or she chooses. The user may decide it requires too much work to learn to code in order to implement a given change, but the option is there nonetheless.
Sure, that's freedom 1. But there's also the freedom to redistribute unfettered with no restrictions (sharing with your neighbor), no usage restrictions (freedom 0) and then even non-developer users can know how to make custom builds of a program.
Besides, every developer is also a user. Reciprocal guarantees like copyleft ensure user freedom is preserved because all changes are shared across the community, meaning that technical and non-technical users alike benefit from using modified and enhanced copies.
That seems a rather odd distinction to make. Developers are also users, and users can more easily cross the line into tinkerers and developers if they have source access.
No, but that's not relevant because what quickly happened is that communities of programmers grew around free software projects on which they collaborated, and they made their work widely and easily available at cost of distribution only, which quickly became zero. This means that users of free software don't have to be programmers to benefit from it, and indeed most of them aren't.
In RMS's ideal version of the world, there is no distinction: every "user" is also a "developer". The freedom guaranteed by the GPL enables society to reach a state in which every individual is not merely a consumer of solutions, but a producer. In this vision, we all cooperate to solve problems together because solving problems in the world makes the world better for everyone.
In reality, problem-solving ability (the intersection of the cognitive ability, skill set, drive, and opportunity to solve problems) is a limited resource. There are problem solvers and there are sheep, a configuration that results in a natural kind of economy. "Corporate" with all its lawyers and sales hucksters, i.e. persons not directly engaged in the work of solving problems, are a necessary demon. They connect problem solvers with users that have problems to solve. Users, for their part, exist to give us their money as a reward for the work of solving their problems.
Whether to support the GPL is really a moral decision about which world you believe in. Do you solve problems to make the world a better place, or to make more money for yourself? I personally wish RMS' vision would come true even though I don't believe it's possible. There are natural limitations to problem-solving ability other than the psychological effects of the capitalist environment on those who grow up in it. Still. When you really dig to the bottom of opposition to the GPL, you always find one thing, and one thing only. Money. "ME".
I remember a big argument in the early years of Android. Google kept promoting it (to the users) as a liberating "open source" OS - except it only worked that way until it reached the manufacturers and carriers. After that, completely locked down, and often with many pre-installed annoying things on it.
So next time another company promotes "freedom" and "open source" let's make sure it actually directly benefits the user.
And that's a great thing to care about, and a great reason to create a license. The secondary question is: which license is best at perpetuating user freedom? This is a separate question than that of whether users should have freedom to mess with code. IMHO, the GPL is not the best license for perpetuating the most user freedom. Many people disagree with me on this, but their disagreement usually comes down to "the GPL is best for user freedom because it was created for user freedom and RMS is talking about user freedom." I'm not yet convinced that MIT-like, BSD-like, and Apache-like are any worse at perpetuating user freedom, and may in fact be far better at perpetuating user freedom due to their greater acceptance.
> I'm not yet convinced that MIT-like, BSD-like, and Apache-like are any worse at perpetuating user freedom, and may in fact be far better at perpetuating user freedom due to their greater acceptance.
Well, the GPL mandates the right to use the application, and that a redistributor cannot restrict it (section 0, preambule and section 6, IIRC); that right is not guaranteed by MIT, BSD, MPL or Apache.
>Well, the GPL mandates the right to use the application, and that a redistributor cannot restrict it (section 0, preambule and section 6, IIRC); that right is not guaranteed by MIT, BSD, MPL or Apache.
Yeah, and because of the additional restrictions of GPL, big companies are simply avoiding it or writing software to replace it.
See: CLANG/LLVM. GCC used to be the king of the compiler heap; now it's well on its way to becoming an historical footnote.
It's far better to convince people to help you by being trusting and generous than by coercion. The GPL uses coercion.
Yes, some companies use BSD/MIT software and lock it up, never to send improvements back upstream. But they ultimately are harming themselves, as they can't trivially update to new versions of the the software, because they're now maintaining a fork, and the longer their code diverges, the harder it will be to maintain. So they are motivated to send improvements upstream. And many (most?) big companies do.
When there's another game in town, people will play the one where they're more welcome. Open source software benefits by many eyes and many hands; the GPL (especially GPLv3) cuts off access to just about everyone in big companies, which means the size of the potential user base is a fraction of what it can be.
Linux is a notable exception, obviously. But with Linux there's a clear way to use it that doesn't risk your proprietary code. Most other software, not so much.
I'd go further and say it's not just big companies. I've worked for big companies and small, and they have all avoided GPL as much as possible.
It is worse, though, in larger companies. There is generally several layers more of bureaucracy to get through to be able to use GPL licensed software.
To be clear, I'm speaking of my role as a developer and using GPL software in developing proprietary software.
I've worked for a small company and we had similar problems. It's not that you have to convince six layers of bureaucrats who have no idea what GPL is but they read in eWeek that it's scary -- it's simply that, when you're that small, long-winded consulting services from IP lawyers is not the kind of stuff you want to spend money on.
> Yes, some companies use BSD/MIT software and lock it up, never to send improvements back upstream. But they ultimately are harming themselves, as they can't trivially update to new versions of the the software, because they're now maintaining a fork, and the longer their code diverges, the harder it will be to maintain. So they are motivated to send improvements upstream. And many (most?) big companies do.
Could you provide some supporting arguments / evidence for this statement - "GCC used to be the king of the compiler heap; now it's well on its way to becoming an historical footnote." ?
* As pointed out by another commenter, Apple switched away from GCC as the default to CLANG.
* Microsoft is supporting CLANG.
* Android switched from GCC default to CLANG default.
* The CLANG development community, combined with the LLVM development community, are both extremely robust.
* GCC used to have full time commercial developer contributors working for Google and Apple and other large companies; most such companies have migrated almost entirely to CLANG/LLVM support.
* Because of better management and the army of full time commercial developers contributing to it, CLANG is better in practically every conceivable way at this point than GCC. If GCC weren't GPL, CLANG would likely be (at most) a fork of GCC, and may have been merged back into trunk by now (this happened to GCC once before).
CLANG is also an excellent example of how a completely permissive license can be sufficient to encourage big companies to contribute their changes back to the commons. All of the GPL fearmongering would have you believe that CLANG couldn't exist, and yet it thrives.
And printer drivers are still almost all proprietary [1]. So GPL didn't even achieve the objective that inspired it.
GPL did prove that open source CAN work, and it jumpstarted the open source movement. But its time has past; enough people understand the benefits of contributing to open source that the coercion is no longer necessary, and in fact is harmful.
[1] Some printer drivers have been reverse-engineered for Linux, certainly. But modern printers frequently leave so much processing for the host that their drivers are nontrivial, and even when there exists "free" drivers for Linux, they pale in comparison feature-wise to the proprietary drivers. I'm sure there are exceptions.
LLVM was not created as reaction against the licensing model of GCC. It was created as a research project exploring: "transparent, lifelong program analysis and transformation for arbitrary programs."[1] GCC and other compilers were not setup to do this. They needed to build an intermediate representation of a kind that was highly unusual for the time. That is where it originated, as pure research. Trying to build a better mouse trap. Not to become a GCC competitor. It did become one because it turned out they had some rather good ideas!
The GPL is not harmful and I encourage you to utilize it when appropriate for it protects you (the original author) and your target users far more than BSD or other similar licenses.
> It was created as a research project exploring: "transparent, lifelong program analysis and transformation for arbitrary programs."[1] GCC and other compilers were not setup to do this.
gcc was in fact set up to explicitly not be able to do this.
The developers of gcc made understanding the intermediate forms as well as creating plugins as hard as possible specifically so that you couldn't get around the GPL.
clang a direct result of attempting to coerce people with real money with the GPL.
> > It was created as a research project exploring: "transparent, lifelong program analysis and transformation for arbitrary programs."[1] GCC and other compilers were not setup to do this.
> gcc was in fact set up to explicitly not be able to do this.
GCC was originally very difficult to integrate with so that non-free programs could not be built on top of it. However, the creation of LLVM does not reduce to: "GCC was difficult to work with so we made this." There had been many attempts to make "Universal Compiler IRs". These attempts had not gone well. LLVM instead chose to do something at a unique level of abstraction that wasn't good for everything but was very good for its particular niche. Once again, read the paper, LLVM really wasn't created as a reaction against GCC.
I feel like the GPL-ness of gcc was less material than the fact that it's developers were afraid of closed source frontends benefiting from their work, and obfuscating the front end so that it was hard to use without pulling in the rest of the codebase.
And the reason I switched was because Clang had better error messages.
Like other commenters, I think GPL had little to do with switch to Clang/LLVM. I liked it for its better, versatile design with a community turning it into the program analysis/transformation baseline to beat them all (minus Semantic Design stuff maybe). However, I think your overall point is supported by the fact that many virtualization solutions in embedded space are marketing GPL isolation as a benefit worth buying them. They probably wouldn't be saying it unless they had lots of customers talking about that problem.
Interesting point about the virtualization. MANY companies are scared of GPL, for certain.
Thinking about Clang, its better design didn't evolve in a vacuum. Clang was primarily developed by Apple [1] so that they would have (with LLVM) a full compiler toolchain that didn't include GPL code (and as others have mentioned, Clang is designed to integrate with editors for parsing, while GCC is explicitly designed to be HARD to integrate that way so that it can't be snuck into a proprietary project).
YOUR choice to change to Clang may not have been about licensing, but licensing and design choices in support of that license philosophy are what caused Clang to exist.
This gives the worrying possibiltiy that Apple can benefit from an open source Clang and LLVM now, and in future can make thecomponents required to compile code to their platforms (mainly thinking iOS) proprietary.
They're already moving to encourage / require iOS devs to ship them LLVM IR code - the most logical reason for this is so that they can keep the last part of compilation entirely proprietary in future, taking further freedoms from users and developers.
They design and fab their own ARM chips already, so this is plausible.
Exactly. They did that sort of thing with Mac OS and iOS on Darwin. They're doing it with Clang. They always do it. It's how they make billions of dollars. Not sure why you worry whether a particular company might scheme: simply don't buy their stuff.
See how that works? And despite Google's BS, I have plenty of ways to keep Android devices largely under my control. On that side of the fence, people stopped worrying and started modding en masse. :)
Further, mobile security vendors such as OK Labs w/ OKL4 let us isolate that mess while programming directly on the kernel or a custom runtime (think MirageOS for mobile). So, we have plenty of options because we aligned with a company doing open-source mobile with little lock-in. Align with closed-source and lock-in loving companies then you get what you had coming. ;)
My choice was about licensing and design but 90+% design given GCC was a pain to work with. Your link shows two paragraphs of text talking about design issues with one sentence on licensing. So, it seems Apple's justifications were more similar to my own than different.
The best part is that so many have jumped on the LLVM bandwagon. There's even a formal semantics to get formal verification work going. Mainstream coders, tool developers, and high assurance people all under the same roof contributing a bit to the same tool. Lots of potential there.
Thanks for writing this up, you make some excellent points. Could you comment on why the BSD's (FreeBSD / OpenBSD / NetBSD) has so far not made inroads against Linux which happens to be GPL2 licensed?
First of all, BSD, in the form of OS X and iOS, is more than holding its own.
On the desktop, I believe that BSD was (a) hamstrung by the AT&T / BSDI lawsuit at a critical time and (b) suffered from fragmentation brought about more by incompatible forceful personalities than by technical issues.
Still shares some userland, but this is irrelevant.
I would say that for most people, the API matters far more than the kernel implementing it.
not open sourced
http://www.opensource.apple.com has the kernel sources under "xnu". I don't think that substantially less is open sourced than e.g. for Android.
look at how well their open sourced Darwin OS project is doing in terms of update and support
The updates are fairly current (10.10.1 corresponds to the version of OS X shipped last fall), though there doesn't seem to be a very large community building on it.
> First of all, BSD, in the form of OS X and iOS, is more than holding its own.
Those are proprietary forms. I think we were talking about whether the decision to be BSD-licensed has been good for the health and contribution of the *BSD projects that OS X and iOS originated from. Then we can draw a conclusion (but hopefully after gathering more data) on whether releasing your codebase GPL or BSD is more likely to lead to long-term health for that open source codebase.
A more accurate statement would be that gcc ceded an entire market to Clang. Clang made a big deal about static analysis and tooling for C++ programs, in effect bringing advances in software engineering and tooling made for Java/C# to C/C++. The hostility to making gcc's parsers be more usable by other applications (GCC plugins only very barely made it into the tree) makes Clang the de facto solution; given differences between ASTs, there's also a strong network effect--if you start using Clang, you'll find it hard to switch to gcc and vice versa.
I dont know if licensing was the only reason why GCC missed out on this market. Using parts of the compiler as a library to aid tool building, refactoring and analysis is one of those great ideas that seems obvious in retrospect. To the credit of LLVM's early authors they had a larger vision of what a compiler ought to be than other compilers at the time. I dont recall gcc or any of the other commercial compilers having this expansionary vision of a compiler stack back in the 2000s. Once LLVM was able to move the goalposts on what users expect from a compiler stack, I can see that the license could have eased the decision for the likes of Google and Apple to come on board. It would be interesting if someone from Google / Apple / Microsoft commented on what the thought process was regarding moving to LLVM / Clang and if licensing played a role.
Evidence, not so much, but I've got anecdata, if that's any help:
I used to work for a company which produced a game-playing virtual machine. We had a toolchain that allowed building C and C++ programs for it. The toolchain was based on LLVM and gcc (because clang wasn't around at the time).
Integrating gcc into our toolchain was appallingly hard, solely due to GPL restrictions. The extra work in dividing everything into GPL and non-GPL parts, interfacing between the two, producing split packaging and distribution etc was basically half a full time job.
If the company had survived long enough for clang to have become stable --- which, sigh, it didn't --- we would have switched to it like a shot.
Clang is not a good example... It was adopted by Apple for its technical merits over gcc rather than its license. And, in fact, Apple tried to license clang/llvm under the GPL as a contribution to gcc but was rejected:
No, his point was exactly why I don't believe that permissive licenses are any worse at perpetuating user freedom than coercive licenses like the GPL: when one feels coerced by a license, the option is to just not take it at all. Whereas with a permissive license, one is far more likely to take it initially, and then perhaps share alike afterwards.
Those who wouldn't share under a permissive license wouldn't accept the GPL to start with, so what additional user freedom can the GPL possibly create in the world that's not already there with permissive licenses?
You are speaking of feelings, I speak about facts and what's actually written in the license: the GPL forbids restricting the freedom to use, even when redistributing; the other licenses don't. This is a clear user freedom that is guaranteed by the GPL.
>This is a clear user freedom that is guaranteed by the GPL.
Yes, and that freedom is being guaranteed to fewer and fewer end users of GPLed software because of those feelings you're dismissing.
Linux is probably the success story for GPL, and even in that case Google has bundled it with proprietary software (Android now outnumbers all other operating system installs, IIRC). Yes people can make their own distributions, but they're for the most part irrelevant to 99% of users of Android devices. Probably 99.99% if you include people who never install Google proprietary apps (the Play Store; Google Maps; etc.) on their devices.
The point of GPL wasn't to serve the 1%, but to expand software freedoms to everyone. To start a revolution in software, and to supplant closed source and restrictive licenses. Look around, though; most people are ignoring what freedoms they are offered and basking in proprietary software options.
Open source is beautiful when it works. But freedom to redistribute something without value is about as relevant as debating whether a tree falling alone in a forest makes a noise.
> but is totally besides what I was saying, or the parent.
No, it's not.
GPL is only relevant if it can grant freedom to modify software that's relevant. Freedom to modify something you don't really want to use has no value.
The parents speaks about USER freedom, not about developers or redistributors. You argue that freedom of developers is more important, and that's fine. But don't say that the GPL does not guarantee more user freedom.
I think you're talking past each other. The GPL only guarantees user freedoms if you're a user of software licensed under the GPL. If you're using non-GPL software, then the GPL's protections don't matter. If GPL software isn't as good as non-GPL software (for many different, sometimes conflicting definitions of good), it will have fewer users and thus the GPL will provide freedoms to fewer users.
OpenStack is one of the biggest permissively-licensed free software projects out there:
"""
Everyone I know who is deploying OpenStack has forked. Not publicly, but they have. No one can run the mainline code, it’s a disaster, and OpenStack politics of the “Big Tent” are going to make that problem a lot worse. Because everyone has their own fork, very little code is making it back upstream.
"""
>Well, the GPL mandates the right to use the application, and that a redistributor cannot restrict it (section 0, preambule and section 6, IIRC); that right is not guaranteed by MIT, BSD, MPL or Apache.
I've yet to see a person who hasn't been able to get the free version of Lua/zlib/libjpeg/libpng/etc. just because some of its rights were restricted by a commercial product (ex. a game).
I'm not saying that the GPL is a bad license, but I personally believe that people who defend it by saying it gives you "more freedom" than MIT/BSD/Apache-like licenses should do a reality check first. More freedom in legalese doesn't equal more freedom in practice.
There are two different situations where this matters:
1. When lua/zlib/libjpeg is compiled into a closed system (perhaps even with DRM), you can't modify that copy of the library. For example you don't have freedom to replace your iPhone's JPEG encoder with MozJPEG.
2. GPL code only helps projects that respect users' freedom, so only Free projects can benefit from it. OTOH do-whatever-you-want code helps both Free and closed projects alike. It allows user-hostile projects to take gratis code, add one (mis)feature, and with little effort compete with the open-source version (see: majority of Android market share belongs to derivatives with unremovable crapware and locked bootloaders).
It's hard to argue about overall effect in practice — it expands problem from legalese to politics. Maybe carriers would never let Android to take off if it was GPL-licensed, but OTOH a GPL3-licensed Android now would be great: it would still allow vendors to customize and extend it, but wouldn't force users to put up with unremovable crapware.
1. Actually you can, it's not pretty because it involves code injection, but you can.
But anyway, the question is "which kind of end user would want to switch a JPEG encoder and doesn't know about code injection"? Certainly not many.
Quoting a comment from above:
GPL is only relevant if it can grant freedom to modify software that's relevant. Freedom to modify something you don't really want to use has no value.
2. I hardly see the issue with the Android example, even if Android were GPL-ed, the carriers would include unremovable crapware, because the GPL license doesn't apply to external files.
1. I've meant "can" more as allowed by proprietary licenses and laws like DMCA (by which you can't), than in the hacker sense that you can break all DRM you want and declare copyright is bullshit anyway.
> the question is "which kind of end user would want to …
No, that's completely missing the point. It's like "We don't need freedom of speech, because most people have nothing interesting to say".
2. GPL3 has anti-tivoization clause, so if they modified Android to prevent removal of any program (closed or not) you would have right to reverse that change and get rid of the crapware.
What's the difference? If you want to use zlib in a project you are making, you proceed to get the free version of zlib first, you are not going to take the version of zlib from a commercial product.
I understand your argument, but there's another side of that coin. An MIT licensed piece of software can be taken by a company, improved in-house and distributed as proprietary, thereby depleting the community of improvements to the work they have made freely available under good faith. GPL also demands that all distributions contain source code so the user has freedom of tinkering with and inspecting the piece of software as they see fit; the core philosophy, as I understand it, is that since software is to be run on users' computers, they have a right to see how it works, what it does, and change its behavior if there is a need for that. I'm not advocating for blindly using GPL wherever one gets a chance (even RMS and the FSF use the more permissive LGPL for some of their work, most notably GNU Readline), but there are some compelling reasons for releasing your code under GPL, which are of course dependent on your particular case (there seems to be no one-size-fits-all solution for open-source/free software licensing).
An MIT licensed piece of software can be taken by a company, improved in-house and distributed as proprietary, thereby depleting the community of improvements to the work they have made freely available under good faith.
However, this hypothetical ignores the reality that companies will often simply not touch GPL code rather than deal with compliance. It's not a choice between the MIT licensed code and the GPL licensed code, it's a choice between the MIT licensed code or anything else. Including reinventing that particular wheel in house.
(opinion follows)
In other words, the GPL reduces the amount of quality (software) in the world and ties developers' hands for the purposes of an ill-thought-out political goal. More annoyingly, it does so in the guise of user freedom, when in reality, the GPL does almost nothing for people who don't hack on code.
If your software is good enough, has enough grass-roots support from developers, and has a good/large community around it then companies will bit the bullet and use it despite it being GPL.
An example of a GPL project that most companies do touch is a counterpoint to the argument that the GPL prevents companies from using software.
That lots of companies refuse to touch GPL code is not an argument for the proposition that "the GPL reduces the amount of quality (software) in the world."
Only for hardware. Typically for wireless and video drivers. If you use an Intel video card and Intel wireless (the former of which you can only do if you don't care for intensive 3D apps) then you can get away with no OS level proprietary software.
Pretty easy to do if your only use of the machine is development work. Once you get into gaming you have to pile a ton of proprietary software (OS and otherwise) if you want to play anything recent.
> In other words, the GPL reduces the amount of quality (software) in the world and ties developers' hands for the purposes of an ill-thought-out political goal.
I believe this is a plus point of GPLv3 (although more of a side-effect than a goal). I cheer for companies like Artifex which develops Ghostscript. It makes sense to me that if you're not willing to pay forward, you must pay back towards the cost of developing software.
But then, I've never had to make these hard choices so my naivety shows here.
> However, this hypothetical ignores the reality that companies will often simply not touch GPL code rather than deal with compliances
Some companies do they get a proprietary license from the authors in return for payment. I've seen companies pay for that. So answer doesn't necessarily have to be "we have to release all our code" it could also be the common business answer of -- pay and get a license.
Except for the loss in innovation due to companies that will not touch GPL for fear of being forced to divulge the trade secrets in their code.
If a company could be sure that nothing in their code could jeopardize their competitive advantage, there'd be no problem with exposing it to the world. But the real world often doesn't work that way. And to make matters even worse, people often get it wrong when deciding what needs to be protected, and what doesn't.
> Except for the loss in innovation due to companies that will not touch GPL for fear of being forced to divulge the trade secrets in their code.
That's exactly the point of the GPL. Look, we as human beings would be all better off without trade secrets, without closed source, and with the explicit permission to tinker, modify, and improve the products we use every day.
You as a user should want all of the rights afforded to you by the GPL. You should want to know how all of your devices work. You should want to be able to do what you please with them and not just what the company you bought it from wants you to do with it.
Yes, we get it, companies don't want to tell people their secrets, but that's not the fault of the GPL. It's the fault of every user like you who is apathetic toward proprietary software, who thinks it's okay to exploit and profit off of others ignorance while perpetuating a legal framework that mandates that ignorance.
"we as human beings would be all better off without trade secrets, without closed source, and with the explicit permission to tinker, modify, and improve the products we use every day."
So, without Apple products? I don't think so. Far from it.
Are you joking? Apple products are the most locked down and functionally inept of them all. Remind me again how I can drag and drop music onto my iPod, or for that matter play an ogg or flac file on it, or switch to a different task on my Mac without its app and all of its windows taking over my entire desktop, or lock my screen without knowing some arcane keyboard shortcut, or find my home directory in the finder?
Not only is OS X by far the hardest to learn and use of any of the desktops, free or non-free, it is also the least customisable. I can't even buy software to make the window manager usable because Apple won't provide the API to make it possible.
Since MIT-style licensed code gets close sourced I don't see how your logic works at all.
Only few huge projects will share back, and generally only share back partially.
If companies are going to choose closed-source license over open sourcing their own code if not GPL or MIT or similar code is available, they weren't going to help open source code to being with.
>depleting the community of improvements to the work they have made freely available under good faith
What is this insane logic?
If someone modifies my code and doesn't give it to me, it doesn't deplete me of anything. For that to be true I would have to lose something I already possessed.
You maybe meant "deprive," but at no time did I ever have a right to anything that they created. It seems you're asserting that because they used my code I suddenly should have a right to use their modifications. I think that logic is flawed.
I do believe I should have a right to use anything I've created [1]. And if someone feels they've made changes that would be generally useful, and submits code to add to the code I've released, then I would be thankful.
But I wouldn't feel that I had the right to something created by someone else just because I gave them a gift that didn't even cost me anything to give them (aside from possible opportunity costs).
That's not to say that GPLv2 isn't useful for dual-licensing situations (like Qt), so as to convince companies to pay for full commercial use. But the latter situation does NOT guarantee user freedom (people will only pay if they AREN'T willing to release code, after all), and the pro-GPL arguments on this article seem to focus on user freedom, so you can't really have it both ways.
[1] I would love to see a programmer's bill-of-rights that guaranteed a developer the ability to reuse any code that they'd ever written that didn't include any actual business or trade secrets. I once wrote an awesome string class for one employer that was even actually open source, but that was licensed in such an annoying proprietary manner that, even though I can still legally have and use the source code, I can never redistribute the source code. The company made games, so there was nothing at all about the string class that anyone would ever have cared about in a business sense.
For that to be true I would have to lose something I already possessed.
It's important to recognize that software -- all software -- is subject to network effects. The more popular a piece of software is, the more work is likely to go into it, more features added etc. If your favourite MIT-licensed software gets forked by a proprietary company and the proprietary version eclipses the original in popularity, you are very likely to be deprived of future support. In a way, software is analogous to a river: it's important to preserve everybody's access not just to the part of the river they live near but also its entire length upstream and downstream.
The opposite has been the case, though, in practice: When using MIT-licensed software that's popular, proprietary software companies have been happy to contribute back upstream, because it reduces their maintenance requirements.
And since when does a for-pay piece of software eclipse the original free version in popularity? If it did happen, then I'd assert that the "proprietary company" must have done a lot of work to make that possible. In that unlikely case, they must have invested a nontrivial amount in the creation of a powerful tool, and they deserve the profits it generates.
A far more likely scenario is that a proprietary company forks an MIT-licensed project, does something creative with it, sells it to a few people, and then the open-source community would copy the cool features and add them to the MIT project. The actual code to a new feature is typically not as hard to create as the design of the feature, which has already been done by our hypothetical proprietary company. Then the company will need to innovate again to stay relevant, and the free project can copy those features as well.
A healthy ecosystem can include some companies that don't share. It's all part of the network effect. If you can cite any situation where a community surrounding a free software library or other product has been killed or even harmed by a piece of proprietary software that is based on the same code, then you might have a point, but I don't think it's happened.
It DOES happen that proprietary software runs circles around the equivalent free software (Adobe Photoshop, for instance), but that's not because the for-pay software is stealing free code. It's because when you have hundreds of full-time developers you can produce a lot more than the same number of people can do in their spare time. And when those full-time paid developers can contribute to open source (as is frequently the case with MIT/BSD licensed projects), those open source projects flourish as well. Again, see LLVM/Clang.
But all of the examples you cite (with the exception of Photoshop) are used by developers. The article was talking specifically about serving the interests of users of applications.
I actually think you chose a bad example with the Adobe suite. Not one of the creative apps runs on Linux, I need an internet connection to keep the DRM system happy, and I have no guarantee that I will be able to open a PSD/AI/etc that I created 10 years ago on an older version of the software - a major concern for a serious amateur.
>I actually think you chose a bad example with the Adobe suite.
It's actually a perfect example:
* Any DRM it has obviously is annoying and could prevent you from using a valid copy (though I've never seen it not work).
* It's crazy expensive.
* Its UI is annoying.
And yet it's by far the most used piece of software when it comes to editing photos (with the possible exception of Adobe Lightroom).
FWIW, PSD is a pretty well standardized file format, and files created in older versions of PhotoShop have always reliably worked in newer versions of the app. It's the other way around, especially if you're using transformations that don't exist in the older app, where you most frequently encounter problems. Which means that if you don't pay their ongoing extortion fees, you might end up getting a PSD that you can't open because of some new feature the older app doesn't support.
Yes it's annoying. But it's also hands down the best, and no professional graphic artist would be taken seriously without it. Gimp doesn't even come close in functionality -- but even worse, the various tutorials and scripts you can follow or acquire for PhotoShop don't work in Gimp.
>The article was talking specifically about serving the interests of users of applications.
Sure it was, but in my example I point out one of many apps that is vastly superior to its open source equivalents, and yet it is the one that serves users the best. Yes Adobe extorts money from those users. Yes it would be nice if it were just open and free. But the reason that Adobe can make software that is so much better is that it can extort that money from users.
So what good is the GPL in fighting apps like this? It accomplishes nothing with respect to large companies like Adobe, because they can just pay to reimplement what they need.
The argument is that the GPL will allow better software to be written with capital-f-Freedom than proprietary. That the GPLed libraries will grow in quantity and eventually outcompete proprietary tools. Other than developer tools (and precious few of those even qualify, honestly), name a GPL application that's better than its closed source rivals. Write a list of all of them that you can think of, in fact. If you hit a half dozen, I'd be surprised -- and there are dozens if not hundreds of solid proprietary packages that make the open source packages look embarrassingly bad by comparison.
Yes you can find GPL apps that are Good Enough for some purposes. I do know people who use and swear by Gimp, for example, or Inkscape. But except for people who use Free tools for philosophical (or financial) reasons, the vast majority of end users want the mainstream, proprietary software that for the most part works the way they expect.
Users are being better served by apps that work well and have the features they need. It happens those apps typically are proprietary. Some philosophies sound good on paper, but in reality fall apart. The GPL largely falls into that trap, IMO, except for the awesome developer tools that are available for free. And Firefox. I still like Firefox. :)
I'm sorry but PS is not vastly superior to Gimp; it's largely equivalent. PS has tools that Gimp doesn't have and Gimp has tool that PS doesn't have. Given the choice, I use Gimp over PS because of the reasons I mentioned in my previous post, and also because I find its UI to be much less obtrusive, and because I can't find equivalent tools in PS for the work I do.
I deliberately avoided comparing the 2 apps in terms of features in my last post to avoid the tit for tat that will inevitably follow.
PS is required by professionals because it is the de facto standard image editing tool and it's the one graphic designers learnt to use in school, and because once you've bought a copy you're locked in. Frankly, if XCF was the industry file format and Gimp was taught in school, Gimp would be the tool everyone uses.
I've used both, and Gimp falls flat in the implementation of the features that it does have. It's not about filling in boxes in a feature comparison table. It's about how well each key feature works. [1]
And that's where most open source software completely falls down, because getting UI and polish into an app takes tons of time and experimentation to get right. Open source apps typically get to 80% and leave it there. Problem is, the last 20% of UI and feature improvement typically requires 80% of the time.
But even that is irrelevant, as you point out, because PS is the de facto standard, and Gimp can't open a multi-layer PSD and be expected to render it perfectly if it uses any nontrivial effects.
[1] Gimp seems to still be missing "adjustment layers," which I swear are used in 95% of the nontrivial tutorials I've seen for PhotoShop. I'm sure you can work around that, but that is a key feature of PhotoShop. Just because you don't find a feature important doesn't mean it isn't used by 90% of graphic professionals who use PhotoShop.
I've used both, and Gimp falls flat in the implementation
of the features that it does have.
I've also used both, regularly and for many years, and my experience is the opposite. As I keep saying, Gimp's UI and portability is what makes me keep using Gimp despite also having Adobe CC installed on my workstation.
And that's where most open source software completely
falls down, because getting UI and polish into an app
takes tons of time and experimentation to get right.
I could just as easily say that this is where proprietary software falls down because software vendors sell their wares on features, not polish. As a professional software engineer, I know this first hand. PS continues to get feature after feature but its basic rectangle select tool is still a complete pain to use. Last time I checked, the Gimp team flat out refused to add support for 3D rendering. It took them along time to come round to the idea of adding vectors.
Actually, if you look at Gimp's development history, you will find that their approach for a long time now has been to work very hard on making the features they deliver as powerful and usable as possible.
This is partly why features are added so slowly. The other reason is because the development team are a handful of people who work on the tool in their spare time.
Yet despite this, they have built an excellent image manipulation tool in Gimp itself, they've developed the GTK+ UI toolkit that is the backbone of the excellent Gnome and XFCE desktop environments and countless applications. They've also developed the excellent GEGL library, the non-destructive rendering engine built precisely to enable adjustment layers (or their equivalent) in Gimp that you can't live without, which in the meantime has enabled the rapid development of Darktable, a very capable alternative to Lightroom.
In a futile attempt to keep this conversation on topic, I'll just point out that both GEGL and GTK are licensed under the LGPL, while Gimp and Darktable are both licensed under the GPL.
Just because you don't find a feature important...
That's got nothing to do with it. I started working with Gimp because it was the only tool that ran on Linux that was capable enough to do what I required.
A user of a tool like Gimp or Photoshop makes the application work for him. Before adjustment layers existed, Photoshop users duplicated layers and blended them with the original to get the flexibility they required. I do the same in Gimp. As Gimp introduces more powerful features, I will take advantage of them.
It's the same kind of logic that the RIAA would use to conclude that my downloading a terabyte of music is equivalent to my stealing x trillion dollars from the record labels, regardless of whether I ever would have spent money on the music (or whether I ever even listen to it). It is, simply put, the logic of intellectual property laws. It's why I don't like intellectual property laws or things that rely on them (like the GPL).
>depleting the community of improvements to the work they have made freely available under good faith.
You pretend those improvements would happen anyway. In RMS's world, proprietary software is not a business. The only way those improvements get created are
1) People individually fix their own problems and support their own use cases. Then boring, unsexy problems that no one is passionate about don't get solved. See: Linux desktop.
2) Businesses perform the least amount of development they can as a cost center; their actual business is consulting.
3) Some wealthy, benevolent patron lights money on fire so that the engineers making that software can keep warm.
Listing "Linux Desktop" as a problem unsolved because of a lack of sex appeal is bizarre. It has long seemed to be treated as "sexier" than it (to my mind) has deserved, and a tremendous amount of work has gone into a plethora of projects in this area.
Moreover, in my experience it has always been basically solved (handwringing articles notwithstanding). I wouldn't be surprised if a part of that has been my needs being unusual, though.
Oh, it was a slip of the tongue---I was thinking of this essay [1], and remembered it mentioning Readline and GNU libc, but for some reason thought that Readline was LGPL and libc was GPL (when the opposite is true and indeed makes way more sense).
>> I'm not yet convinced that MIT-like, BSD-like, and Apache-like are any worse at perpetuating user freedom, and may in fact be far better at perpetuating user freedom due to their greater acceptance.
Just try to get source code to any of the Apple or Microsoft OS parts that were BSD licensed so you can tweak them. Then come back and tell me how free you feel. I know you probably don't have a desire to change most of that, but my point is that you can't - for the parts that were changed from their BSD origins with no source released.
>Just try to get source code to any of the Apple or Microsoft OS parts that were BSD licensed so you can tweak them.
The bulk of projects available on opensource.apple.com are not GPL, including not least of all the kernel.
Anecdotally I have personally used the BSD-licensed file_cmds source package to fix some birthtime-related behaviors in cp, mv, and touch that I didn't like.
>Many people disagree with me on this, but their disagreement usually comes down to "the GPL is best for user freedom because it was created for user freedom and RMS is talking about user freedom."
I don't think there's a need to create weak straw arguments, when an obvious argument is that GPL forces companies creating new products based on GPL-licenced software to open-source these products, thus aggressively perpetuating "user freedom". This may or may not be efficient in the long term, but I don't think the answer is very clear cut with the current knowledge base.
I didn't mean to create a straw man, and I kind of intended exactly what you say there (if I'm understanding you): being "aggressive" means that it does the most for user freedom. I like your terminology better though and will use it in the future.
> I don't think there's a need to create weak straw arguments, when an obvious argument is that GPL forces companies creating new products based on GPL-licenced software to open-source these products.
The obvious argument is that several people disagree with you on this (see the comment about linux being GPL or using GPL software at a bank.), so the GPL is not serving its purpose because people don't understand its purpose.
As far as i know Apache License, Version 2.0 is considered a free software license. To quote from gnu.org "This is a free software license, compatible with version 3 of the GNU GPL."
source: http://www.gnu.org/licenses/license-list.en.html
Nobody is questioning that ASL2, MIT, BSD, Expat etc are free software licenses. The thesis is that they are not always as good as e.g. the GPLv3 at spreading lasting user freedom.
The problem that Stallman faced could be solved with a law that prohibits software from being distributed in compiled form only.
All executable images delivered to users should be accompanied by buildable source code corresponding to the image, if at all the image can be upgraded.
Moreover, it should be lawful for licensed users of a program to share source code modifications with each other.
This is not a copyright issue at all; the rule would apply equally to freeware as well as to programs which are not freely redistributable.
The whole problem is that software can be machine translated from an easily understandable and modifiable from to a cryptic form that is vastly more difficult to understand and modify. This source-to-image translation paradigm gives rise to abuses and problems which were not imagined by the people who invented copyright.
For instance, if you and I both buy copies of the same novel written in the English language, all of its sentences are plainly understandable. You and I can discuss, say, alternative endings for the novel, and even write them up in our mutual correspondence. We could do the analogous thing with software: all that stops us is that we received it in a gobbledygook compiled form. (Plus some idiotic EULA clauses about "reverse engineering").
In the meantime, to increase the amount of software that does come with source, he decided to replace critical proprietary software with free software that requires any derivative to come with source. Decades later, the law is still nonexistant, so the workaround has turned out to be quite important.
Copyright is just the tool that happened to be useful for implementing the workaround.
Freeware is irrelevant to the discussion, it is just proprietary software that happens to have a zero price.
Good point. I made a similar one referencing the fact that Burroughs mainframes used to come with source to let customers do exactly that. So, it's a proven model. Plus, there's all the dual-licensed code out there proving you can make it charging reasonable rates for commercial use, let free use be free, and give source to both.
Indeed. Higher level languages (and that includes symbolic assembly languages) were invented by some smart and kind people in order to make computers easier to program, allowing more kinds of people to be programmers. The idea that you can hold users hostage with compiled code came later; it is an accidental by-product of the model of compiling richly annotated, symbolic, high level code into a bit pattern for the machine.
There is a slight analogy in music. A symbolic musical score is "compiled" into a recording. If someone wants to change the music, they have to either obtain the score or "reverse engineer" it by ear. However, recordings do not have algorithmic behaviors; a "bug" in a recording has only an esthetic consequence. Nobody is the victim of a security bug or malware due to a flaw in a music recording. Performances are also art in their own right. They exhibit nuance and style.
Interesting points. I'll go further on the security aspect to say that having a high-level version can dramatically improve ability of customers to secure their operation. The reason is that they can apply countless improvements to static analysis, transformation of unsafe to safe, hardware, and so on. Hard to do this on platform-locked binaries. I've seen some impressive results but their impressiveness came from the uphill battle they fight. Better to make software maintenance and security a downhill battle using every trick we can.
Who is claiming this is a copyright issue? Software licensing and copyright are two different things. Are you saying this is also not a software licensing issue?
Why, Stallman and the FSF. Their license is even called "copyleft".
Software licensing is not separate from copyright. Licensing restrictions are made possible by copyright.
There are fantasy clauses in software agreements which don't have anything to do with copying; they are probably bogus. (Like that you can't look at the code to understand how it works, even though you paid for it, and are doing the looking on the machine which holds the licensed copy.)
Doesn't need a GPL: just an irrevocable license to paying customers to be able to obtain and modify the source for their own uses. GPL is clearly superior in freedom but open-source, flexible, and proprietary model solves that with ROI for company. There's been companies, going back to Burrough's MCP OS in 60's, that did that for paying customers. We could push for more companies to do this, especially putting it in writing, to eliminate a lot of our problems.
Device drivers and firmware will still be tricky due to trade secrets involved. I'd say encourage such companies to keep a team around for paid audits and extensions of their product. That's happened with embedded and fabless semiconductor companies for quite a while. We've recently seen AMD and Intel start doing something similar for purposes of customization.
Many potential solutions that don't require convincing a company to go all free and annihilate their existence outside support contracts' race-to-the-bottom profits.
HP's and Brother's printers have entirely-FOSS drivers, IIRC. At least the former's printers will work on my GNU/Linux systems without installing drivers (as opposed to other vendors - like Canon or Epson - that require separate driver installation in most cases).
MFPs can be a bit hard to deal with, but my Epson 7890 runs entirely from CUPS/GhostScript. Now, the printer itself, runs what's definitely a proprietary OS. Most of the printing problems in that line go into the printer itself. Blobs all the way down!
Last I checked, I still need a proprietary driver for the Epson WorkForce printer my grandparents use for color printing (alongside the HP Laserjet 1320n I gave them for greyscale). Then again, some vendors will be hit-and-miss when it comes to out-of-the-box driver support (my Konica-Minolta color laser is one such example), and I guess Epsons are in that category.
I've plugged in a few friends' Epson printers and it just worked. I don't think I have yet to run across a printer that didn't work in the last 5 years or so (maybe it's just because my printer usage is declining)
But it is also worth noting that any software released under a restrictive license (e.g. GPL) will eventually be replaced by software with a more liberal license (e.g. MIT).
>> But it is also worth considering that any software released under a restrictive license (e.g. GPL) will eventually be replaced by software with a more liberal license (e.g. MIT).
Which can then be relicensed under GPL ;-) Also consider the OpenOffice fork over to LibreOffice, where the GPL version won out after they relicensed it.
Most FreeSoftware is trying to replace commercial code, so the reverse of what you say is also true.
Also worth noting is that if you like commercial software, why not just use commercial software instead of rolling your own under a permissive license? It seems those developers are not as pro-commercial as they sometimes indicate.
Doesn't matter, it is a different project. All your blood, toil, tears and sweat have been put into that original GPL project that is now replaced by something forked off of an MIT licensed project.
Typical users aren't programmers. For them there isn't a difference. GPL or BSD usually mean for the user to get Software for free.
Where free licences really matter is for developers. The question is wether they have to give back their work that is based on other software.
A really important point in this discussion is the question if something is still the same thing when you change it.
In my opinion this isn't true for software. The orignal will still be preserved and still be free.
Did he anticipate user demand, market forces or that a corporation (Google, Microsoft, Hashcorp) could drive a permissive licensed open source project in the open?
It turns out the Firefox and Chromium, both liberally licensed projects, usurped Internet Explorer's monopoly on browsers. Both ultimately are backed financially by corporations with huge troths of patents and proprietary code.
Chromium certainly didn't usurp anything. Chrome, the proprietary browser, did.
As for Firefox, the Mozilla Public License is actually a (weak) copyleft license, since if you modify any file, you must distribute your changes - it's closer to the LGPL than to MIT/BSD. And the other licenses under which Firefox is distributed (it's tri-licensed) are GPL and LGPL.
You're nitpicking. Chrome has always been very close to Chromium. Even if some crap like the recent voice activation thing, DRM, and in the past the PDF reader (but that was open sourced) has remained proprietary, the vast majority of the code is permissively licensed and open to external contributions.
Chromium is permissively licensed, and Chrome integrates proprietary components. Strengthening the product with features and giving it marketing.
I see the point on MPL. As for bundling more restrictive licenses - as a developer - you have to judge by the most permissive to see how free it really is.
There's no need to anticipate something that already existed. Permissive licensed user-developed projects existed a few decades before Stallman's involvement. Quoting from the Wikipedia page on SHARE at https://en.wikipedia.org/wiki/SHARE_%28computing%29 :
> SHARE Inc. is a volunteer-run user group for IBM mainframe computers that was founded in 1955 by Los Angeles-area users of the IBM 701 computer system. ... A major resource of SHARE from the beginning was the SHARE library. Originally, IBM distributed its operating systems in source form[1][2][3] and systems programmers commonly made small local additions or modifications and exchanged them with other users. The SHARE library and the process of distributed development it fostered was one of the major origins of open source software.
But on the other hand, VLC was packaged for the iphone at one point to let users of that platform use it. Source was made available to everyone. It was decided that GPL version 3 wouldn't allow GPL software on the iphone so users were not free to use GPL software on their platform. It is available now for iphone so I'm not sure what changed. I thought it was very odd that GPL advocates wanted to limit user freedom in that case.
Seriously, most of your facts are wrong. Source: I'm the president of VideoLAN, I did the VLC relicensing[1], and spent a lot of time on GPL/stores compatibility [2].
VLC was GPLv2+ and so was libVLC (the engine library that was spawned from VLC). VLC was put on iOS store as a GPLv2 app, which was not compatible with Apple ToS, and was therefore removed by Apple.
At the same time, libVLC was relicensed over 2 years to LGPLv2.1+ for reasons that were non related to appstores.
As a side-effect, VLC for iOS was rewritten and licensed as MPLv2 to be on the AppStore, with a slight bit less features.
For your information, the main reason that the AppStore is not GPL compatible, is because the AppStore DOES NOT allow you to use an application as you want (even non-open-source ones). This is forbidden by the GPL. Which shows exactly that the GPL tries to enforce the users freedom.
For an entirely new project, would you rather require all contributors to assign copyright to a single entity which then manages licensing or would you have individuals retain copyright? (Off topic: is this even possible in France?)
> For an entirely new project, would you rather require all contributors to assign copyright to a single entity which then manages licensing or would you have individuals retain copyright? (Off topic: is this even possible in France?)
First, there are more than 2 options. I'd say there are 3.
Copyright assignment is ALWAYS the wrong answer. It's a bad idea, and I would even that this is unethical, and illegal in numerous countries.
If you want more control, notably for a potential future license change, do a Copyright agreement that is not an assignment. Explain clearly what is in the agreement and what is not.
Total individual copyright is a great idea, but if you care about an application that will go on an appstore, don't go this route. If you integrate a lot of library, same. But if you do a new cool software, just for fun, yes, keep it like this.
> GPL advocates wanted to limit user freedom in that case.
That's disingenuous. GPL advocates don't want to limit users' freedom. GPL's Freedom 0 is allowing users to run code for any purpose.
The problem is that users don't decide what they can run on iPhones. Apple does, and Apple chose to forbid GPL code in the App Store.
---
I've licensed my code under GPL (and sent takedown requests to App Store multiple times) specifically to avoid supporting Apple's user-hostile policies with my gratis work.
App Store users have to give up their software freedom for privilege of using Apple's locked-down system. When my code helps increase number of App Store users, it helps increasing number of users who don't have software freedom.
If I license my app under a DRM-friendly license, then it gives competitive advantage to those who don't want to give users' freedom. Instead I license my apps under a DRM-incompatible license, so they give competitive advantage to those who respect users' freedom.
But since you bring up the iphone. You know that the iphone is fundamentally based open permissive licensed software? I can't think of a more user freedom hostile platform than the iphone...
The problem there is not the GPL, it is the restrictive Terms of Service that Apple has created for their App Store. In order to publish on their closed platform, you must use DRM, which is in violation of the GPL. Apple has it within their power to change their ToS to be compliant with the GPL, and allow more Free Software in the App Store. For obvious reasons, they do not.
#fsf on freenode might want to know that and/or receive a patch. I'm sure you're busy, but it sounds like you're a subject matter expert on this topic!
>I thought it was very odd that GPL advocates wanted to limit user freedom in that case.
You have it backwards. Apple limits user freedom with their licensing restrictions on iOS. Copyleft isn't welcome on iOS, and we shouldn't blame free software advocates for that.
However, there is a distortion in your post that is very, very critical for this argument.
Like all software licenses, the GPL controls DISTRIBUTION of the software. This is a legal concept, not a technical one. Downloading software to your computer and copying it to your iPhone isn't distribution, because you own both devices.
The GPL, as a copyleft license, specifies that a distributor may not make any additional restrictions on future distributors (like users). This is so I can't redistribute Linux as proprietary software, for example.
However, Apple had, at the time of the VLC removal (and likely has similar wording today), this clause in the App store ToS:
>You acknowledge that Products contain security technology that limits your usage of Products to the following applicable Usage Rules, and, whether or not Products are limited by security technology, you agree to use Products in compliance with the applicable Usage Rules.
And, in the Usage Rules:
>The Usage Rules shall govern your rights with respect to the Products, IN ADDITION (emphasis added) to any other terms or rules that may have been established between you and another party.
TL/DR? Apple places ADDITIONAL restrictions on software distributed through the app store. This violates the GPL.
You have this backwards in your post. You say that the GPLv3 prohibits use on the iPhone, but in fact, the Apple ToS prohibits DISTRIBUTION of GPL'd software through the App Store.
End-users are perfectly free to install VLC on their devices. They aren't breaking any laws by doing so. The GPL expressly allows using the software for any purpose. They could install it on a DRM'd toaster if they wanted to. However, DRMOaster Inc. can't distribute GPL'd software.
Instead of modifying its ToS to be more user-friendly, Apple decided to pull VLC from the app store. It could have gone differently.
> What changed was that VLC relicensed to LGPL, I believe, for this very reason.
This is incorrect. We changed for other reasons, notably competition and corporate acceptance of the libVLC engine. That relicensing was started way before the port to the AppStore.
> TL/DR? Apple places ADDITIONAL restrictions on software distributed through the app store. This violates the GPL.
>
> [...] You say that the GPLv3 prohibits use on the iPhone,
Didn't you just basically say the same thing? The GPL forbids distribution under the App Store ToS, no?
"The GPL prohibits use on the iPhone" is not an equivalent statement to "The Apple ToS is incompatible with the GPL". Nominally, consumers own their devices, and in most regions it is legal to circumvent Apple's digital manacles to install software you choose on your hardware. If you want to do this to install GPL'd software, you are fully within your rights to do so.
I think it's rather backwards to say "the GPL forbids distribution under the App Store ToS", because the GPL has no concept of Apple's app store. The GPL predates the Apple App Store ToS by decades. Apple was actually forced to consider this policy when the VLC event happened, and chose to maintain it.
"Stallman created the GPL because he cared about user freedom."
vs.
"The GPL attempts to force people and businesses to release their source code. There is nothing wrong with that, except I don't think it qualifies as "free software". I want anybody to be able to do anything they want with my programs and/or its source code."[1]
Does true freedom include being bound to a duty to protect that freedom?
With GPL, it works within the existing legal system to ensure that you have full freedom with GPL software as long as you continue to give such freedom to those who use your own versions of GPL.
It reminds me of the issue with a democracy. Does a true democracy allow the voters to replace the democracy with another form of government (say a theocracy) or does a true democracy uphold that the one choice they cannot make is to remove democracy (individually they can stop voting, but they cannot take the vote away from anyone else).
Or take the question of a free market. Given a free market, no man is bound as a slave by default. But does a fully free market allow for a man to sell himself into slavery (and to what degree, as taking on debt might be considered a really light form of indentured servitude, college debt which cannot be discharged could be considered a stronger form, and child support where one can be sentenced to jail could be considered full indentured servitude)?
All of these seem to share a core underlying question, perhaps even an underlying paradox. I'm still not sure what it is, though it does remind me a bit of Russel's paradox in an absolutely rigorless way.
> The GPL attempts to force people and businesses to release their source code.
LOL No. The cost of using GPL code is that you have to release your source code. Just like the cost of using some proprietary software is $X. If you don't want to pay that price, don't use the software.
I think you mean the cost of distribution. A business can keep its modifications as secret as it likes so long as it doesn't distribute the modified binary.
I'm not really interested in dictionary-lawyering definitions. I'm most concerned about what I, the end user, can do with the software I obtain. To me, it's very important that I be able to modify the software I use. GPL guarantees I will be able to do that forever. BSD does not.
If you are not interested in the dictionary definition, than please provide your dictionary so we can have a discussion in your language. Until that happens I will use the definitions from the dictionary.
To be fair, with nearly every license you have to do something. GPL just has you do extra things.
Almost every license requires you to include the Copyright notice and copy of the license along with your code and usually in the running program as well.
Of course, that's a ton easier than being required to release your source code and not DRM the binaries.
free·dom
ˈfrēdəm/Submit
noun
the power or right to act, speak, or think as one wants without hindrance or restraint.
I don't think that restraining what the users can do or have to do while using your "free" software can hold up against the definition of freedom.
I think what you are talking about is the moral superiority here, you are thinking that you are in a better position to define freedom for users that is different from the definition in the dictionary. This is pretty common patter in the society nowadays. Anyways, I am sticking to the original definition. :)
I'm not sure their freedom is really worth caring about, after we've spent so long trying to help them. Our freedom, sure! The freedom of fellow hackers, sure!
The freedom of people who give my email address to linkedin? Who tag me in photos on Facebook? Who use Google Voice and Amazon Echo around me? Who tweet photos of me without asking and thus put my likeness along with EXIF data of my position?
The users you disparage are mostly good people who just aren't obsessed with technology, or its implications on privacy, as we are. They just don't know any better than to do what they do on LinkedIn and Facebook. I daresay you need to get out more; then you'll see these users as real people, and not one-dimensional subhuman things to be monetized.
At this point, they're willfully ignorant and incurious.
The only thing they're good for (in a software relationship) is being mined for revenue.
Do they pay enough for their no/low cost apps and software to be treated otherwise? No.
Do they vote for smarter politicians to have a better regulatory climate for our business and their privacy? No.
Do they do anything other than lap up the bullshit gawker and buzzfeed ads, the simple pandering of Apple ads extolling faux-quality, the lazy hero worhsip of Musk? No.
We've got numbers--hell, millions and billions of dollars of business built around the numbers--proving the users are saps whose only interest is getting sold to.
I don't think they're willfully ignorant. They just have lives outside of the narrow set of interests that are so important to us. And if they don't vote for smarter politicians, it's probably because they've been duped or distracted.
If you're talking generally about non-tech-savvy people who like Facebook and other popular apps and websites, then that would include most of my family and some of my friends. It's easy to paint a whole category of people with a broad brush and hold them all in contempt when you don't know any of them personally.
I don't think they're wilfully ignorant either, but they are woefully ignorant, and actually software is tightly woven into their lives so they need to be educated.
It's more serious than you might realise. People have found themselves charged with serious felons either because they or their prosecutors didn't understand what they were doing. And then there's the issue of state surveillance being used as a weapon against activists and campaigners who might embarrass those in positions of power.
Why would they do a silly thing like that? That data has got to be worth a lot--imagine, for example, doing accurate brand spread analysis by searching for brand logos in photos and looking at where they're being displayed via that data.
Christopher Allen Webber is a FLOSS hero and in my opinion deserves the utmost respect, although I suspect he is probably too humble to agree with that.
I concur with everything he has written in his post...
but one thing I'd add to the points he made is my annoyance with the implication made by many that proponents of permissive licensing care about freedom more than people who use copyleft licenses.
People who really care about freedom care about it for EVERYONE, and licensing that maximizes freedom for everyone trumps the "strings attached" in that regard, that is such a simple thing to see that it challenges credulity to think that someone who cares about freedom could say otherwise.
If you want everyone to use permissive licensing because you want to use free software inside of locked down programs you produce and are frustrated that great copyleft software doesn't let you do that, fine. I can respect that position because I've experienced the same problem. But please get over it and find some non-free solution to your problem, instead of trying to undermine the ideology of people who actually care about freedom just because you are jealous of the quality of software that has that ideology attached to it.
> If you want everyone to use permissive licensing because you want to use free software inside of locked down programs you produce and are frustrated that great copyleft software doesn't let you do that, fine. I can respect that position because I've experienced the same problem. But please get over it and find some non-free solution to your problem, instead of trying to undermine the ideology of people who actually care about freedom just because you are jealous of the quality of software that has that ideology attached to it.
Stop pigeonholing people who disagree with you. I'd like everyone to use permissive licensing because I believe copyright (and more generally, intellectual property) is unjust. Copyleft is only possible in a world with a strong IP system.
Fair enough. I respect agree with your viewpoint, and you're not the one I'm calling out if that's your position. I do however think that from practical standpoint, when compared to copyleft licensing, permissive licensing is a weak solution toward the end that you are seeking.
Saying "giving everyone the right to share it" is contrary to the goal of having it be shared widely (aka adopted), is at least a gross oversimplification and at most an absurd statement.
Getting more adoption as part of proprietary software may or may not lead to more overall adoption. Bsd kernel vs linux kernel is a case for gpl leading to more adoption than permissive. GPL says "allow EVERYONE to share it." And in some cases, more people share it this way! Who would have guessed? And it can lead to more people contributing, because they know everyone will have the right to share their work. The fact that permissive code means it could be shared LESS, because it can't be part of software which makes sharing illegal, is kind of across purposes. I mean, if you just care about adoption, a lot of times, you might get more by keeping it completely proprietary and selling the copyright to a big company. Or you might get more by embedding it into worms and phishing emails and running a botnet.
I'm not writing a kernel. The fact remains that if I use the GPL, people will tell me that they can't use it because their legal department forbids it. Alternatively, using it requires approval from their legal team and that requires enough effort not to use my code.
This isn't some theory that you can weasel your way out of using examples. It's based on real experiences I've had.
I personally would rather people steal GPL software than go an ideological rampage so they can safely subsume free software into proprietary products. Stealing would be a more morally honest action.
Because when they convince the world out of their own greed that authors shouldn't protect the users rights, and that the users (not creators) of MIT/BSD/Apache licensed software are free to subsume it without giving back, they hurt everyone.
If they steal the software and use it in a proprietary product, they only damage themselves.
Convincing everyone to not use the (L)GPL does more damage than just violating a license.
I work in industry. Anything GPL is a non-starter. I totally understand and appreciate the concerns, but at BigCorp GPL doesn't play.
edit: I'm well aware that some people don't want industry using their code. Great! But that's really limiting the scope of who's going to get involved, and it's probably going to make it harder to get a sufficient community involved to help your project achieve liftoff.
Is the role of FOSS developers merely to provide software that people in the "industry" can use to more rapidly develop their proprietary SaaS applications?
When I write software in my own free time, I purposely use the GPL, because I don't want BigCorp using my work without being a good neighbor and sharing their changes.
[I'm removing this comment and all children because "I'm submitting too fast" and can no longer reply to the discussion I started, and as a result am now being blanket downvoted because my point was miscast. I'm also penalized below a grayed-out comment again, and I suppose the message from Hacker News is that my contributions are not wanted. Message received.]
The GPL doesn't apply when you are using Free Software, because the GPL is not an EULA.
The only time the GPL becomes relevant is when you want a licence to redistribute that software (or your derivative version). There are several options: you can choose to face the consequences of a copyright violation, you negotiate a specific licence with the authors of the software, or you can use the automatic licence granted by the GPL (provided you abide by the restrictions it imposes).
For someone in operations, if you're just using the software and not making your own changes, there is nothing stopping you from using Free Software tools anywhere you want. If you want to incorporate Free source code into your own tool, the GPL only increases your options, as you can still negotiate with the authors, just like you would have to if you wanted to include other proprietary code.
The only way the GPL could be seen as "punishing" anybody are the people that want to redistribute GPL code in their own product or tool without paying for it. If they don't like the price - recursively granting others the same freedom - then they are free to choose another vendor (or write their own version).
> forbidden by legal
Of course, if your legal department makes bad decisions because they do not understand the GPL, you may want to educate them (or refer them to the FSF)... or perhaps find a new legal department... or job.
The semantics over what is considered a "distribution event" is not trivial, and it's largely seen as a "loophole" in the GPL that you can write a SaaS using GPL code and get away with it. (For instance, the AGPL closes this loophole.)
Legal departments understand that using GPL code in proprietary services violates the "spirit" of the GPL, which is why they want to shy away from it.
It's especially thorny because if say, a contractor logs into the server that's running your SaaS, and your SaaS is linked against a GPL library, technically that's a distribution event (because the contractor works for another company, and now you distributed it to him), and now your SaaS has to be licensed under the GPL too. Oops.
When you consider all this, there's no wonder large companies just make blanket policies of no GPL, ever. And the GPLed works out there suffer, because those same large companies are happy to use permissively-licensed libraries, make fixes, and push those fixes upstream. But they can't do that with the GPL, because they don't want to touch it to begin with. It's ironically preventing the exact thing the GPL was meant to encourage.
Thankfully, the AGPL is working exactly as designed, because too many people want to try to fence off the commons. Again, if you don't want to pay the price for Free Software, find another vendor.
The rest of us don't have any problem at all understanding what a "distribution event" is. The AGPL is only a problem if you base your business on limiting other people's freedom. Stop doing that.
I'm having a bit of trouble reading your response, it seems like you're driving at a few points simultaneously. (You only quoted one word out of my reply so I'm not sure exactly what you're trying to argue.)
Are you defending AGPL and saying that proprietary SaaS software shouldn't use GPL code? Then I think you and I are 100% in agreement.
My post was in response to the grandparent who seemed to be saying that the GPL is A-OK to use in proprietary web services because it's only relevant "when you want a licence to redistribute that software (or your derivative version)". I was explaining that that's more of a loophole in the GPL than it is "not relevant".
I'm not basing a business on limiting others' freedom, I just want to write a dumb rails app for adding users to LDAP, or any other myriad of dumb reasons you'd want to make a dumb internal service. And I basically can't touch the GPL unless I can also convince our legal department to let me GPL the dumb tool and distribute the source code. Since things we distribute have a bit of brand identity to them, it would make my company look bad if the tool sucks, or it's not general-purpose enough to be useful outside my company, etc. So it's just not worth the hassle to go through all that for some dumb internal LDAP tool.
So instead I stick with MIT/apache/etc permissively-licensed libraries in my dumb internal tools, find bugs in those libraries, and submit fixes upstream. Ironically this is the exact same thing that GPL proponents say would never happen if everyone used permissive licenses.
I don't want to GPL my code and distribute it because I don't want anybody to see how bad it is, not because it's some "secret sauce" for my company. It's just a bunch of glue on existing libraries anyway (basically a variety of ruby gems.) The GPL is far too difficult for me to use in this case, so as a result I just don't touch it.
I can sympathize with not wanting to do the same work over and over again, and I would never consider someone a bad person just because they're working on proprietary software. But I can't even begin to understand how the license "punishes" the engineer.
Your employer refuses to use an external tool. Their legal policy is simply incompatible with the licensing terms of the external product. Just as their purchasing policy would be incompatible with a $1B tool. So you're hired to make an internal version of an external tool.
Why not try to change your employer's policy? If they say they'd rather re-invent the wheel, aren't you just complaining about your job? Not external licensing choices?
I'm tired of doing the same shit over and over again.
Then why do you keep taking jobs to do exactly that?
Then it sounds like time for a career change. Or you could go into business building this for yourself and selling it to companies that refuse to touch anything open source.
Try operations at a company that isn't GPL-phobic. It's not like there's a shortage of them.
I mean, does your company run Linux knowing what license it's under?
I'm frankly boggling at the idea that a company will seriously try to stop operations from touching GPLed software. Unless you're a 100% Windows shop and the actual license for everything you use is "proprietary".
What are your thoughts about copyright assignment?
Is your current employer willing to contribute code to something like a foundation and assign copyright to them with the code licensed under AGPL?
If not, is your current employer willing to pay a certain amount to the aforementioned foundation get a proprietary perpetual, non-revocable, transferable blah blah license for a one time payment of... let's say $50k?
What I'm asking essentially is:
Is your company willing to help develop something like Ghostscript either by a. writing code for ghostscript to make it better or b. giving them money to make ghostscript better?
Even if both the answers are no, perhaps this module can act on its own and you can just never modify the source code. I believe as long as you don't modify the source code and just use binaries provided by upstream, all you'd have to do is to provide the binaries and the source files that you got from upstream.
It would probably be immensely helpful if the GPL software developers who were open to alternate licensing schemes explicitly said so on their web pages. Otherwise the only licensing option listed for their software is GPL.
It's a minor point, granted, but I think it would make a difference.
EDIT: e.g., a statement like, This software is licensed to the public under GPLv3. If you would like to use this software under different licensing terms, please email us / review our price sheet / etc.
But isn't that true of nearly every other license and vendor? Which developers are open to relicensing their proprietary software under the GPL, and if so, for how much? If the price is right, then perhaps enough people will contribute and free the software, which could also make a difference.
Sure, well, I wrote that in the context of, if any GPL software developers want their software to be used more in a non-copyleft setting and are willing to negotiate a difference license.
It very well could work both ways; some proprietary software developer would likely be willing to release their software as GPL if paid enough money, since, ostensibly, the proprietary license was chosen to help make money in the first place. I can imagine that some proprietary software developers choose proprietary licensing for some other reason, but I suspect it's mostly the default for anyone looking to charge for copies.
But this changes if we're talking about things that look more like libraries rather than standalone executables, because the GPL is of the opinion that if you call something as an executable, that's fine, but if you call into a library, your whole codebase has caught the GPL fever.
Sorry, I am not trying to put your current employer in a bad light. My apologies. I am not trying to give you answers. I am just wondering if there are ways we could benefit from free software in other ways.
> Why am I suddenly intrinsically bad for taking a paycheck from Google or Apple?
You aren't. But you're not paying me enough to care about supporting you.
You find something I've been working on useful, and you want me to relicense it for you? I'm willing to sell you a copy under whatever license you want.
When I write software in my own free tome, I purposefully use permissive licenses because I want as many people to use my code as possible without limitation.
> Is the role of FOSS developers merely to provide software that people in the "industry" can use to more rapidly develop their proprietary SaaS applications?
I don't understand why you're asking this question given the parent. The parent just said that BigCorp can't use GPL. This in no way means that the "role of FOSS developers" it to serve at the altar of industry. All it means is if you want people in industry to be able to use your code, then don't GPL it. There's nothing more to it.
Your definition of "freedom" is counterintuitive to me. Consider how many more end users would likely use and benefit from your software if BigCorp adopted it, whether or not they had access to the source code.
I don't understand, what is counterintuitive in this definition. Freedom isn't the same as benefit, so I presume second sentence isn't an argument. If users happen to be developers, they might want to fix bugs, or remove annoying functionality - that's the freedom they have.
I said "use and benefit." I could have left out the "and benefit." In what sense can a user be said to have freedom in regards to your software if the user can not even use the software?
Well, think of the inverse. Imagine you never release your software at all, and not one ever gets to use it. In what sense is there "user freedom" in regards to your software?
We're talking about the difference between the GPL and say the BSD license, not necessarily choosing whether or not to release the software at all. Yea, in the latter that definitely limits user freedoms.
But I think people who choose either of those licenses are already releasing their code. It's just that the BSD has a wider contributor base, as businesses could be more likely to contribute back.
What I mean is, if the code is available then the quantity of people benefiting from it is separate from the idea of user freedom. User freedom, in the GPL sense, is freedom to read, copy, modify and redistribute the code and to do the same for anyone else's modifications to that code.
BigCorp can try negotiate different terms if they really want the software under different terms, at least if the software is from a single source (or copyright has been assigned to that person/entity by the other contributors). Such negotiations may fail though, but this is no different to how they do business day in day out with other commercial entities so it shouldn't be a great culture shock for them. To put it further into BigCorp speak: adherence to the license is the standard "payment" plan for GPLed code, if that payment/licensing plan doesn't fit then you may be able to negotiate something else or find a competitor who accepts terms more compatible with your business.
It gets a bit more difficult of course where there are different contributors or the project itself relies on GPL code from elsewhere, which is not unlikely for large projects - it might not be possible (or at least practical) for the maintainer to even consider entering negotiations. This is by design how the GPL is intended to work. And again: this is no different to dealing with code from other commercial entities. If BigCorp doesn't like the choice that SomeOtherDeveloper has made license wise, they can of course take their interest elsewhere - nobody is forcing them to use GPL licensed code (as some people imply by use of terms like "viral").
Personally I prefer more permissive licenses when looking to use things in my own projects, especially in my day job where like you the GPL would generally be difficult to consider, but just like BigCorp this is my choice. It isn't something I would expect others to change their ways to accommodate.
As a free / open source software developer, why should I care? In what situations would I want to make sure that a proprietary software vendor could embed my free software into their proprietary product?
> As I said, I am not only pro-copyleft, I am also pro-permissive licensing. The difference between these is tactics: the first tactic is towards guaranteeing user freedom, the second tactic is toward pushing adoption. I am generally pro-freedom, but sometimes pushing adoption is important, especially if you're pushing standards and the like.
Outside of that situation: because they might give back changes to your software, even if they don't free the rest of the code. Of course, this might be a good argument for the LGPL.
Would you like your bank using not-invented-here special snowflake implementations of security and encryption protocols, or rigorously tested open source ones?
Your bank can't open source it's banking system. Probably in a literal we-lost-the-source-code-in-1993 way.
A bank can use a copyleft encryption library without open sourcing their entire banking system. You just can't make changes to the encryption library without releasing those changes.
The Linux kernel is GPL and is used in countless proprietary applications.
You just can't make changes to the encryption library without releasing those changes.
Actually, you can make changes to GPL software without releasing those changes. The main restriction of the GPL is that if you distribute the software, you have to distribute the source too. But you have the freedom to do any changes and keep them to yourself without distributing anything.
I work in industry as well, and GPL is rarely a problem, at least for pharmaceutical R&D. Perhaps you could be a bit more clear about which industry field you're talking about?
"I work in industry. Anything GPL is a non-starter. I totally understand and appreciate the concerns, but at BigCorp GPL doesn't play.
"
Maybe at some.
I work at Google (in fact, i ran open source licensing :P). GPL is just fine for whatever.
If you want to use it in server stuff, whatever.
If you want to use it in client stuff, great, you ship source code to the right parts.
As long as your product group/etc is willing to do what the license asks, we don't care.
I've met about ~130 of my counterparts at large corps. I'd say about 40% have policies like yours. The other 60% though, are closer to us.
AGPL is very easy to control for the external facing stuff, but not the internal stuff.
For example, based on how it defines remote network interaction, it doesn't differentiate internal or external users.
So if we used AGPL in internal systems that Temps, vendors, and contractors had access to, we'd end up owing all the temps, vendors, and contractors source code to the internal system, regardless of what other NDA's or anything else were in place (it's well settled that you can't contract around or NDA folks into giving up GPL/AGPL rights)
We aren't willing to take this risk (and i'd bet most companies that are doing it don't realize this is an issue :P)
We aren't "ardently anti AGPL", we just don't use it or care.
Certainly, I personally think it's a bad license for a bunch of reasons (related to my response, etc). But Google as whole simply doesn't publicly care one way or the other (IE isn't strongly AGPL).
If you want to use it, great.
We are fine not using it, and we tend not to contribute to AGPL software.
Certainly you realize that with the amount of AGPL source code being so small and not really growing at any real rate, Google simply doesn't have to care?
For me, the answer is that I would like to contribute to that code and improve it if I'm using it internally.
But I can't use it internally if it's GPL, period. The GPL means that I have to GPL my (for example) internal SaaS if I use any GPL code in it. (Yeah yeah, SaaS isn't technically "distribution" of the software, and wouldn't technically trigger me to have to release my source code, but that's still violating the spirit of the GPL if not the letter, and lawyers hate that. And AGPL codifies that "loophole" by listing "as a service" as a distribution event.)
Whereas if the code was permissively licensed, I could actually use it internally in my SaaS, find bugs, fix them, make improvements, and pass the fixes upstream without someone getting pissy that I'm not releasing the code for the SaaS tool too.
GPL really stifles participation in a project if potential contributors can't even use your software because they can't GPL their own derived code.
If the GPL software in question didn't exist you'd be in the same situation.
So you're complaining that there's lovely software but bad corporate policies are a problem for your company. That's not a problem for the GPLed software.
The thing is, they're not bad corporate policies. Our legal department is trying to stay within the law, that's a good thing.
The fact that you're technically allowed to use GPL code in a proprietary SaaS is a loophole, not something to be used in defense of the GPL. What you're basically saying is "GPL is great because you can get around it", which isn't really a case for the GPL but against it.
The legal departments in big corporations are aware of this, and they don't really like the idea of allowing loopholes in licenses to decide what software to use, so they discourage using the GPL.
If you're a software developer who's choosing an OSS license to use for their library, this is a huge factor. If you really do want companies to use your library even for proprietary SaaS applications (like in my example), choose a license that's explicitly ok with it, don't choose one that relies on a loophole to permit people to use it.
And if you don't want companies using your software in proprietary services, by all means use the GPL! That's great! But don't blame my legal department or corporate policies for me not using your library, it was your decision to choose the GPL, and I don't want to go against your decision.
Um, I didn't say any of that at all. Here are my words:
"If the GPL software in question didn't exist you'd be in the same situation."
"So you're complaining that there's lovely software but bad corporate policies are a problem for your company. That's not a problem for the GPLed software."
I seriously do not understand how you got that from what I wrote.
Sorry, I've re-read it several times and I still don't understand it then.
It sounds like you were claiming that the problem isn't with the GPL but with my company having bad policies. So I attempted to defend my company's policies (as I explained in the post.)
The overall point is that I can't help contribute to GPL code because the GPL license prevents me from using it in the first place. (My company's policies are a red herring, they're merely there to make sure I use software properly.) I am theorizing that perhaps a developer may want my contributions, which is why they may want to consider that before they choose the GPL.
Edit: Ah, I think I understand now... when you said my company has bad policies you meant not open sourcing our SaaS is the bad policy, not don't use GPL as a policy. It's an entirely different conversation if that's the case, sorry I misread.
You can always contact author and ask him for another license for your company. Qt works exactly like that, AFAIK: GPL for free projects and commercial license for nonfree projects.
At Microsoft (at least circa 2010) you weren't allowed to even install GPL software, for fear that a developer might wind up using it somehow, and cause the GPL to apply to all of, like, Windows 7.
Sorry for the hyperbole, but the concern was very real, even if poorly defined.
This _may_ have been the default, knee-jerk guidance for the Windows team, or part of it, but it was certainly not true for the whole of Microsoft, even back in 2010. In 2010, Microsoft was shipping a handful of cross-platform tools that we built and tested on Unix platforms including Mac and Linux, where it's literally impossible to avoid using GPL software.
Today, Microsoft ships even more cross-platform tools (Visual Studio Code) where again, it's required to use GPL tools, and we contribute to others. (I hack on GPL code as part of my job at Microsoft.)
Now, of course, you're right that this was much harder within Microsoft five years ago. And one's risk exposure is different depending on the product portfolio you own (with something like Windows being less risk averse than something like Microsoft Bob). But some very key lawyers with their heads screwed on straight have overhauled our system and it's much, much easier to deal with OSS than it was five years ago. But even then it was certainly _possible_ and actively happening in parts of the company.
This statement is false as a blanket. I worked at MS in 2010, and I had vim and git installed on my machine. What they didn't want me to do was to install (or look at!) the source code.
The amount of FUD from rank-and-file employees was shocking though. Based on ignorance, but they just weren't part of the GPL world, and didn't care to understand it deeply. So I don't doubt that you may have asked someone and been told "Oh god, don't even look at that stuff". But it wasn't any kind of company wide policy.
I did end up talking to folks that were trying to make such a company wide policy, but even then what they were pushing for was some kind of GPL registry, where if you installed any open source software, you had to register it with the powers that be. I don't think that went anywhere though.
And http://www.cnet.com/news/microsoft-embraces-gpl-opens-hyper-... from 2009 says "Microsoft embraces GPL, opens Hyper-V to Linux with LinuxIC: Redmond is proving that it can compete with open source on open source's terms by licensing LinuxIC under the GPLv2 license."
This is such nonsense, using GPL software can't 'infect' software you are writing. I could understand having a rule about not putting GPL source code on your machine in the case you might accidently reuse some of it -- but even that seems unlikely.
I guess it's just easier to say 'GPL bad' than actually explain copyright to every developer.
Um, the concern [for source aspect] was more real than you think: friends and I used to send pieces of GPL code to Microsoft, IBM, and so on that potentially solved kernel problems. The goal was to wait until it got distributed to legacy customers, identify the cut/pasted code, prove it in court, and get these companies' source. Just some devious, hacker stuff we pulled out of boredom for a few weeks rather than a full-on operation with any likelihood of success.
However, I have to imagine someone else tried or will try that same trick. It's why I strongly account for licenses of code added to any proprietary, code base. It's also why license management software is a real market rather than a concept. Better to avoid GPL source than try to explain to FOSS types in court later why it was accidentally distributed and you didn't really mean to exploit their work without following the license. Who would believe that given how most companies are about giving back?
The argument in the article is wrong. The assumption is that companies want to extend the software and keep their extensions "locked down." That does happen, but I have seen companies willing to extend software, and make the extension public, as long as they didn't have to make the extension GPL.
Whether this makes sense, or is a case of failure to understand the GPL, it does exist.
> The assumption is that companies want to extend the software and keep their extensions "locked down." That does happen, but I have seen companies willing to extend software, and make the extension public, as long as they didn't have to make the extension GPL.
...so? The point is that the GPL makes it illegal to lock down, while MIT and the like enable it. Yes, some companies will play nice, but they are doing so voluntarily.
The solution to "companies are evil and want to horde my code" is very different from the solution to "companies don't like the GPL; perhaps because they don't understand it, perhaps because they don't like the implicit patent license that may include any patents the company has a cross license to and doesn't have the ability to sublicense."
I think that is commonly assumed to be the most common use case for avoiding GPL. I have no idea whether that is actually the most common use case for avoiding GPL, and I don't know of anyone who's actually done the research on that in a useful way.
Because the language of the GPL is highly centered around "linking", a GPL operating system doesn't present the same kind of corporate use/acceptance/etc issues as a GPL app or library.
Uh... the word "link" doesn't even appear in the GPLv2, so the idea that its language is centered around it is sort of laughable. I think you're trying to talk about the derived works definition and the fact that the kernel license has express language with a specific definition that excludes running programs on the kernel.
I'm not really interested in arguing, except to point out that the kind of ignorance you're showing about how the GPL actually works has far more to do with "corporate acceptance" in "industry" than the actual details do.
GPLV2: "This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library"
Consider that perhaps I'm not an idiot.
Regardless of pedantry, a GPL OS does not raise the same kinds of issues for a typical corporation that a GPL library or application does.
I see the downvotes. Funny, because this really is the part of the GPL that stirs up controversy at corporations.
Yes, it doesn't say "linking" exactly. It talks about "derivative works". Then, the FSF, separately, says that linking to a GPL library (or integrating into a GPL program) is a derivative work.
Or, have a look at the LGPL, created specifically to address this problem. Note that the FSF isn't thrilled about the LGPL.
That's the big driver behind why a GPL OS doesn't create the kind of stir in a corporation that a GPL app or library does. Not saying it's right or wrong, just pointing out the difference.
I work in industry too, mostly with open source software. While our go-to license is a permissive one, we use GPL software extensively and contribute changes back.
There is an argument that companies should prefer the GPL for their own software that they open-source. It goes like this. If you are the copyright holder you own the software anyway and can change licenses at anytime so you are not bound by the GPL. However, your competitors (and future competitors) are. Therefore the GPL protects your company from someone else forking and closing the source for their improvements in the future.
As part of the industry, I assume you don't have a debian machine running a webserver, or a git repository, or a linux box for testing/development, or ...
Are you strictly talking about incorporating GPL code into proprietary products that you sell? That is a different thing, but thankfully there is a cross industry standard that you must pay the author in order to incorporate other peoples work into products of your own. If you add music, you got to pay the musician. If you have a photo in a commercial, you pay the photographer. BigCorp knows how to pay people for their work and why should it be any different in the software industry if BigCorp want to prevent others from using BigCorp products for free?
That's funny. I work in industry, and we have a lot of GPL flying around.
How do you folks get away without Linux (including Android)? It seems like you're in industry, but you're probably not in very successful industry if you don't have a mobile strategy that includes running on Android.
And if you do have an Android app, then you do GPL. You just do it without any sort of sensible policy around it. Again, not all industry is that stupid.
>> I work in industry. Anything GPL is a non-starter. I totally understand and appreciate the concerns, but at BigCorp GPL doesn't play.
I hope you're open to LGPL though. I don't think there's much reason to avoid linking, and a number of free software libraries allow that via LGPL. I've always view that version of the license as a terrific compromise.
Having worked at a company that used a tonne of open source, the lawyer's reaction was, IIRC, basically:
zlib etc: go nuts.
New BSD/MIT/Apache etc: sigh, fine, but you'll need to get it properly registered with legal so that don't forget to add it to that document nobody reads.
Old BSD: you're kidding me, right?
Stupid/joke license: come back when it has a real license.
LGPL: no.
GPL: hell no.
AGPL: aaargh! Get that off your machine RIGHT NOW! We can't even have that on the premises!
The reason for not allowing LGPL is that it's not well-enough defined what linking means, which means it's not worth the risk. The reason for not allowing AGPL is that if your company does anything via the internet, then if any software which is AGPLd gets anywhere near the serving stack, suddenly you're infected. (My current company would rather I didn't use AGPL software at home, even.)
Keep in mind that BigCorp's lawyers have no idea what "linking" means, so they're probably going to veto an LGPL library just the same as they would a GPL library.
It is psychological, for some of us freedom means I authored this piece of code and if you want to use it you do what I say aka GPL.
For some other people it means that here, I wrote it and you use it as you want to use it aka BSDL.
I am more likely to side with BSDL guys on this one, I do not want to do anything other than use a free software as free software if it is branded as free software. :)
A few years from now, when you want to hack on some new gizmo and you find out that the toolchain is a pile of proprietary blobs that only work on Windows and an old version of RHEL, you can thank the "pro-user" supporters of clang and its non-copyleft license.
(I think this is already happening with GPU toolchains but that's not my field.)
This is happening with Apple. Apple were so enraged about a GPL compliance lawsuit that they pored tons of resources into LLVM, perhaps just out of spite.
They were so spiteful that they offered to license the whole thing under the GPL. But because RMS uses an e-mail client written in the last century he missed the offer.
Ted, I am a fan of flak and have great respect for OpenBSD and it's developers and community. I in no way intended to suggest that developers who choose a permissive license "kill kittens" in their spare time.
I was talking about a bigger scale where large companies promote permissive licenses so they can take and lock up.
I respect the fact that BSD developers and those that choose that license think it's the right way to go and, as recent contributions from Microsoft to OpenSSH have shown, sometimes it is of great benefit to the developers to choose such a license. Then again not everyone attracts the attention that the BSD projects do and so I believe there are circumstances where the GPL is more appropriate.
I just don't get why there isn't room for both types of licenses depending on circumstance, developer choice and what's best for the entire software ecosystem.
Oh, jesus. They got $20,000-50,000. Such sellouts, right?
Have you looked at Linux's sponsor list and budget lately? Good thing they GPL'd it - otherwise it might have ended up powering an intentionally obfuscated and user-restricting codebase like Android...
OpenBSD gets less money per unit societal value than any other software project I'm aware of.
Sellouts? I said no such thing nor even implied it. I am genuinely thrilled that MS contributed so much to OpenBSD and will use it as a standard in Windows. I applaud them for stepping up and contributing. Microsoft is not my favorite company but I have no problem acknowledging and appreciating it when they do something right.
I agree that people should contribute more to OpenBSD or their side projects like OpenSSH. I give very little by purchasing OpenBSD gear so I am grateful when a company steps up and contributes.
I put a simple, self-contained HTML/JS/CSS scratchpad (think JsFiddle, Codepen) on Github without a licence. I was contacted because somebody saw the project and wanted to use it to help teach a classroom HTML, but only if the licence was good.
I quickly put it under MIT, which means though I never saw changes back - something I did helped somebody else teach a class of people HTML. That's doesn't put food on my table, but the same effort from me under a bad licence would have meant that good likely would not have come from my efforts.
If you can have passive income projects that sit there and generate revenue over time without further input, why can't you have passive charitable giving, where you put in effort once and others are able to get value from it over and over again as time goes on.
Permissive licences pay it forward in a way that viral licences don't.
That doesn't at all address or relate to the question I asked, but instead provides a completely different talking point supporting permissive licenses as a charitable act.
> That doesn't put food on my table, but the same effort from me under a bad licence would have meant that good likely would not have come from my efforts.
Who is more likely to be hired for paying work: the guy whose code you have benefitted from or the guy whose code you haven't seen?
I believe there is such thing as 'corporate stewardship' and companies ought to give back to the communities that host them. With remote work, and independent workers I believe that responsibility to give back falls on the individual.
I've surely benefitted in my life from open-source software. My income depends on my use of it, so I feel not just a desire but a duty to release work for others in the same way.
It's not direct, but the more code I put out there the more my industry thrives. The more my industry thrives the more work there is in it. The more work there is in my industry the easier it will be for me to find work.
It's a roundabout way of doing it, but I like to think of it as watering the garden I get my food from, instead of harvesting it.
The viral nature of the GPL leaves a bad taste in my mouth like a ideological chain-letter!
I like public ___domain, I like MIT, I like libPNG, but I don't like forcing ideology or licenses on people and THEIR code. Take it, learn from it, modify it, USE it. If I didn't want it to be taken and used I wouldbt bother to post it! The GPL gets in the way of that.
For the example you gave in response to my first reply the GPL license would have permitted them to do as they please. No-one forces a license on you, you choose what license your original code is under. If I would like to prevent my code from being taken and profited from that's also my right. The fact that you can choose what license your code is under is freedom. The non-permissive vs permissive license argument is a moot point, because the very arguments supporting permissive also support the right to use a license such as GPL.
The GPL has a viral clause that says that whatever code touches GPLed code must be GPLed as well. This is a deal-breaker for many people who may be working with code under different licenses without similar viral clauses already in their codebase. They don't necessarily have the right to GPL other people's code, so they have to forgo using the GPLed code.
It's not just the GPL, this criticism applies to any licence with a viral clause.
I understand that as an author I have copyright and ultimate freedom to licence my code under whatever I choose, but I choose to release my code under non-viral terms.
It's not about posting changes back, I don't care if they fork it and run I just want people to use it. I see viral terms a huge roadblock to this type of creativity.
So there's a solid argument for permissive licenses that excludes viral licenses like the GPL!
Nowhere did I say it was bad if they had to post their changes, but in reality it just means they won't touch it, won't have changes to post, and they will keep looking for more permissive code to use.
If a viral licence is an impediment to people using my work, then releasing it seems like a waste.
> If a viral licence is an impediment to people using my work, then releasing it seems like a waste.
I don't agree, there are still enough people who will gain from it. Everyone who wants to learn, everyone who wants to give back, etc. that is not a waste at all, quite the opposite.
I'm not talking about individual developers. I agree with the article's author when he says there is a place for both types of licenses and if a freelance or small team of developers choose a permissive license as a strategy to make money I respect that.
I'm referring to mid to large size companies that simply want to take permissively licensed software and repackage and lock it up so they can increase share holder value. I'm talking about executives who have never developed a piece of software but are smart enough to monetize it on the backs of hobbyists and freelancers.
I don't see how that puts food on anyone's table other than those who already have plenty.
But, hey I come to HN for the debate so thanks for your comment, I respect your opinion.
You obviously have no clue how to understand reductio ad absurdem.
Also, if I were in a better mood right now, I would more carefully avoid being condescending. I don't mean to attack you personally.
I just want to clarify: when someone makes a claim, and another person uses an extreme example that has identical logic to the claim but is obviously ludicrous, it proves that the claim is based on faulty logic.
In this case, if you say something that implies that you can't criticize someone for trying to make a living, this comic proves you wrong by bringing up an example worth criticizing.
Your idea of "oh, this extreme example? it applies to those I disagree with" amounts to "I'm rubber, you're glue" sort of childish nonsense.
Sorry, you have no idea how reductio-ad-absurdism works.
Reductio ad absurdum requires that the absurd conclusion is a consequence of the argument that you are trying to disprove when taken to extremes.
You haven't done that. You've just posted a comic that is a flawed analogy to the point in question.
If I was claiming that any behavior, however immoral, was justified by the need to make money, your argument would hold.
But I don't claim that. I claim that the rational behavior of not selecting the GPL is supported by the argument that it might be against one's financial interest and the interests of a prosperous society to do so.
Your reductio only works if you assert that the GPL is morally superior and not just pragmatically so.
My comment about the comic stands - you are raising the choice of the GPL to the level of a moral choice. Why not just admit that?
Um, I wasn't saying the comic was text-book logic of reductio ad absurdem. It requires a little bit of thinking to understand the context.
So, let's get to the bottom of this: GPL vs permissive isn't itself a moral issue, but making proprietary software is a moral issue.
So, arguing against GPL in favor of permissive specifically because permissive software can help make proprietary software… that becomes a moral issue because you are advocating not just for permissive licenses but for the proprietary software they enable.
For the record, I think in practice, the economic justification for proprietary software is acceptable if the proprietary publisher works especially hard to be honorable and not malicious in how they wield their proprietary power and it can be really shown that they couldn't get by without being proprietary. But just making money isn't an adequate excuse without those other qualifications.
I think the GPL license actually makes user freedom worse by encouraging developers to release software as web apps instead of as client applications. This is because a web application that uses GPL software is not required to release its source code whereas a client application would be required to release its source code.
The difference in user freedom between web apps and client apps is much bigger than the difference between a GPL client app and a proprietary client app. With a client app, even a proprietary one - the user at least in theory can see exactly what the application is doing and what data it is transmitting where.
So for the average user - GPL has encouraged loss of user freedom. Of course this doesn't affect Stallman because he does not use any web apps.
I also feel the the GPL Affero licence (the GPL response to this, by re-wording it so that you still have to share the source if it's a webapp) is not very clear. I know the company I'm working at is willing to be a good GPL citizen, but refuses to touch GPL affero'd code with a 3 meter pole.
I like it in principle, but I don't feel like it's a good solution in practice, at least until we get some cases going before a judge to see how it gets interpreted.
AGPL is perfectly clear: if you make source available under AGPL, you are in compliance. There's nothing to worry about. Plus, nobody ever sues you initially over (A)GPL compliance, they just ask you to come into compliance and only sue you if you refuse. Just release the source initially, and you're all set. Why is this hard?
Ironic and interesting point. The client applications also had more efficiency, reliability, and security when set up right. Really hard to do that with web apps to the point that it took a lot of work by smart people to get it working this well. So, we loose across the board.
> So for the average user - GPL has encouraged loss of user freedom
This is ridiculous i encourage you to remember the state of affaires before gpl. User freedom wasn't even on the map. It changed everything and overall the users gained a lot. Also you should remember that gpl freedom is an ethical question. And as allways if there is an infection the medicine could make the parasites react against it.
Before the GPL, the biggest software companies hiring the highest paid developers were companies that made proprietary software that ran on a users machine and the data did not leave the user's machine.
Now the biggest tech companies are companies that use GPL software to run infrastructure that gives users 'free' services and in exchange takes their data and sells it. Because they are using it as a web, they can keep all their secrets.
Now you tell me, what scenario is more conducive to user freedom and privacy.
If you look at who is actually paid to work on GPL software, I would guess that most people either work for hardware companies or companies whose revenue is from advertisers. Relatively few are working on software that is actually for end-users to run on their own personal computer.
GPL is great if you are Stallman and limit yourself to only what you can build yourself. For the average user, they are less free, more beholden to a platform, and have less control of their data than in the pre-GPL era.
Actually, I think it does not. I think you would be in compliance with AGPL if you had an internal server run the AGPL program and then had your external servers communicate with the internal AGPL running servers to perform work. As long as the web user was not communicating directly with the AGPL, the user to whom you would have to release your modified source is yourself since the outside user never communicates directly.
Next, the AGPL is and will be a very small percentage of GPL licensed software.
Finally, apart from making a political statement, I do not see the AGPL getting any traction. Apart from MongoDB (which has its drivers as Apache) I cannot think of any widely used software that is AGPL.
Also, note that while MongoDB is AGPL, if you look at the contributor license (https://www.mongodb.com/legal/contributor-agreement) any contributor is giving MongoDB the right to use and license your contribution and to make derivative works of which they are the sole owner. They can also license your code under a non-copyleft license to others. I do not see how in this case a (A)GPL is more free than a BSD/MIT license. Along this line, you will see that many successfull GPL projects (excepting Linux and the FSF ones) are of this type where the source code is GPL but any contributions give some type of copyright assignment to the company which then sells basically closed-source licenses to corporations who don't want the GPL.
I think this article (and possibly the speaker the article responds to; I haven't seen any transcript or recording yet) misses one of the bigger poitns of permissive licensing: the ability for virtually any free software project to reuse your code. As a developer writing a library or somesuch, my concern is often whether or not I'm locking a large number of projects out of making use of my code. Yeah, this means that proprietary software can use it, too, but at least I'm credited for the work (as per the terms of most copyfree/copycenter licenses) and other FOSS projects have the same ability.
This isn't to say that copyleft is automatically bad, but rather that consideration for the general development ecosystem is a worthwhile consideration. If you're a Perl hacker, for example, you're probably going to use "the same license as perl itself" (GPL + Artistic License) or perhaps the Artistic License 2.0 because those are the norms of the Perl community. If you're a Ruby hacker, you're probably going to use the MIT license because that's the most common. If you're writing an Emacs package, you'll probably release it under the GPL. If you're writing an Erlang module, I'd reckon the Apache license nowadays to be the new baseline.
This is also affected by which operating system you're targeting. BSD folks will tend to lean permissive, while GNU/Linux folks will tend to lean copyleft. Windows and OS X folks will tend to lean proprietary or permissive.
In other words, what license to pick really depends on the norms of the platform you're writing for. There's no "wrong" answer here unless the license you choose excessively impedes reusability by the broader community you're operating in, in which case you would be wise to adapt accordingly.
I think Richard Stallman is (was?) aware of this. He famously condoned Ogg/Vorbis using a BSD license so that it would be more greatly adopted by developers/companies making music players and the like. This was in the face of the patent protected, extremely widely adopted, MP3 format however.
Good point on how all OSS developers benefit rather than just FOSS. However, the author did address that by noting the permissive licenses goal was mass adoption and FOSS was pushing their notion of freedom.
True. I got the impression that the specific nuance of benefiting FOSS as much as non-FOSS was being a bit glossed over, though.
It's a little bit more nuanced than "mass adoption", too, though. For me (as someone who tends to lean permissive in his software projects), it's more about deduplication of work and making my things as useful as possible for everyone. I'd love for a GPL project or an MPL project or an Apache project or a BSD project or whatever to find enough value in the code I write to not feel that they have to write such code themselves.
"True. I got the impression that the specific nuance of benefiting FOSS as much as non-FOSS was being a bit glossed over, though."
In the original article? Yeah, these people often get so worked up about how proprietary products can benefit that they forget the huge amount of open-source, non-GPL efforts that can draw on the work. Despite the fact that the server traditionally running on every Linux box was an Apache-licensed one who's name I can't recall... jk.
In any case, I fully respect your decision to try to help OSS projects avoid wasted work and make something they can all use regardless of license. Similar to those putting work in the public ___domain. That used to be a badge of pride in developer altruism. Now, the standard license (GPL) for altruism forces the developers will on users of the code. Quite the change OSS went through.
I feel like a lot of the comments in this thread are conflating permissively licensed software with closed source software.
If you want to write software and keep it closed so you can make money off it I don't necessarily love the idea but I can respect it.
But we're not talking about closed source here, just the difference between the GPL and permissive licenses like BSD, MIT, etc. I don't see how creating a killer app and releasing it permissively guarantees a developer an income. The opposite is the obvious effect. On the other hand using the GPL as your public license and negotiating a private license with a company like QT does seems like a logical way to provide user freedom, enjoy feedback and improvements from the community and still allow for a revenue stream.
It's definitely a tired argument at this point so I was actually pretty happy when the author went out of his way to reiterate at the end of the article that there are benefits to both approaches, why can't we all just get along...
BSD was not meant to shape a future, it was created to maximize the reach of its software through devaluation.
GPL was created to shape our future and continue to do so. Not just the forseable reach of our little lifes and immediate surroundings (if any).
I see a lot of people looking at their immediate needs. IMO We need need to give time to Time. The problem is not FLOSS licensing or software. This is mostly a solved problem.
> To return to the arguments made last night, though copyleft
> defends source, in my view this is merely a strategy towards
> defending users. And indeed, as in terms of where freedoms
> lie between those who make use of the source and code side of
> things vs the end-user-application side of things, one might
> notice a trend: there are very few permissively licensed projects
> which aim at end users. Most of them are stepping stones towards
> further software development. And this is great! I am glad that
> we have so many development tools available, and it seems that
> permissive/lax licensing is an excellent strategy here. But when
> I think of projects I use every day which are programs I actually run
> (for example, as an artist I use Blender, Gimp and Inkscape
> regularly), most of these are under the GPL. How many truly major
> end-user-facing software applications can you think of that
> are under permissive licenses? I can think of many under copyleft,
> and very few under permissive licenses. This is no coincidence.
> Assuming you wish to fight for freedom of the end user, and ensure
> that your software remains free for that end user, copyleft
> is an excellent strategy.
This was the key paragraph from my reading anyways. This is not an argument for / against whichever license, it's an argument that different types of code and projects have different licensing trends, and those probably align with how the code is going to be used and the audience that it's targeting.
I sympathize with the author, even though I work at a corporation that doesn't like GPL.
I think big part why the GPL has been lately out of fashion is that many developers work for (big) companies, which of course (as correctly stated) benefit lot more from BSD than GPL.
These developers naturally want to use the great software at work they do or use as a hobby, so they are willing to compromise with the powers at be (business leadership) and release their software under a more permissive license (or pressure their peers working on OSS to release it under more permissive license).
Of course, if these developers acted really rationally, they would collectively rise up against such demands; but then they could just establish some sort of anarchist/libertarian/communist (depending on your leanings) commune where everything is fair and just.
So I think it's a lot of small pragmatic decisions that ultimately lead to irrational results.
>These developers naturally want to use the great software at work they do or use as a hobby, so they are willing to compromise with the powers at be (business leadership) and release their software under a more permissive license (or pressure their peers working on OSS to release it under more permissive license).
The funny thing is that using the AGPL or GPL would benefit them; the company abides by whatever rules they want since they hold the copyright and the developer gets to use the code for their side projects. The only people who are out of luck are competitors who can't use the code unless they want to abide by the AGPL or GPL.
Basically, using the GPL protects the company. The only concern you should have is if a competitor has enough resources and is unafraid of the GPL or you don't want users to self-host (supposedly eroding the revenue stream in a SaaS, though I don't see it since it takes effort to self-host)
I think this quote from the article is what is all qbout.
"In Shane's talk last night, he argued against copyleft because software licenses should have "no strings attached". But the very strategy that is advocated above is all about attaching strings! Copyleft's strings say "you can use my stuff, as long as you give back what you make from it". But the proprietary differentiation strategy's strings say "I will use your stuff, and then add terms which forbid you to ever share or modify the things I build on top of it." Don't be fooled: both attach strings. But which strings are worse?"
What bothers me both about the article and the comments here that they speak in the context of the pro-GPL/anti-GPL debate, but what actually gets discussed is lax vs. copyleft FOSS licensing.
However, the two topics are not the same. I, for one, like the idea of copyleft licensing (for cases where its appropriate), but don't like GPL. GPL has taken the status of "the real copyleft license", but indeed it's an abuse of the idea of copyleft.
Here's why: create the Merry Mermaid Public License (MMPL) as follows: take the text of the GPL and replace all occurrences of "GNU General Public License" with "Merry Mermaid Public License". Also remove all references to FSF and refer to yourself / another non-profit whenever a legal entity is to be named in the text. MMPL will be essentially the same as GPL, just called differently. However, GPL will condemn MMPL in the sense that the two won't be compatible. You can't mix and distribute code bits where one is GPL and one is MMPL licensed. An aggressive monopolist drive is built in to GPL as it decrees incompatiblity with other licenses not on base of licensing conditions, but on base of not being originated from the FSF.
The author gives good reasons for preferring the GPL to BSD-style licenses, but it seems to me that there's an even better license for his ideals: the AGPL.[1] It fulfills the same purpose as the GPL, but it fixes loopholes such as running code on remote servers (most website back-ends).
I've yet to hear a good argument from ideals that prefers the GPL to AGPL. The latter really does give people more freedom over how they can use and modify software.
I'm very grateful the GPL exists, but I don't like the viral clause of the GPL. I find people sometimes aren't able to use GPLed code in their projects which defeats my purpose for putting it under an open licence in the first place.
Lately I just release stuff under MIT which says you're free to do anything but remove the copyright notice, or sue me because you used my code. Other than that it's free for nearly any purpose.
Its good that you have defined a purpose for why you release code. When I see people share a photo on a flikr, a video on youtube, or a song on a band/indy website they also have a purpose for that. Often it is not to allow companies to use it in their proprietary products or incorporate it into commercials, but sometimes they do allow it. Its their choice to decide how viral and restrictives they are when sharing to the public, even if they can't dictate how entitled the recipient will feel towards the conditions.
The goal of the license is thus to define what the author will accept and what they don't. The more authors that actually make an aware choice, the better the result is.
I'm torn. I understand the benefits of enforcing user freedom. But it's not clear to me that users aren't better served by the ubiquity of re-use that the more permissive licenses have encouraged.
For example, permissive licenses have helped with the walled garden that is iOS. But would end users be better off if we hadn't had iOS? If it were GPL'd, sure, but in reality it would never have been. So is its existence, and the competition it fostered with Android, net beneficial to users?
Maybe more concretely, I feel that the deliberate hamstringing of GCC wrt a published IR to be, well, wrong. Again, I understand the arguments and I appreciate the reasoning but it's not clear that the end user is best served by this.
For me, at least, it probably comes down to the simple statement that, as much as I value end user freedom, it isn't always the most beneficial thing for the end user.
On a different day, mind, I'd probably argue the other way...
The first half of the article was good and balanced. I especially like the distinction in lay terms: copyleft to push freedom; non-copyleft to push adoption. That's a great way to describe it to a person contemplating what license to choose. Then, the article goes in a different direction that embodies negative qualities that author critiqued in the related presentation. Let's address a bit of this from my pro-consumer, pro-security/quality, pro-OSS, anti-copyleft perspective. Mentioned that just so my bias is clear upfront and why I push adoption-oriented licenses (esp for open hardware & high assurance).
re stepping stone. Yes, this is the common goal of proprietary use of anti-copyleft software. IIRC, copyleft software got its start using the architecture, languages, tools, and platforms of BSD and proprietary offerings. So, even GPL proponents build on existing work. Anyone wanting an open, free version of a given enhancement can similarly produce it starting with the same stepping stones.
re open to closed. We saw this happen with Apple App Store, the QNX source reversal, attempts to combine open code with DRM, and so on. This is bad. However, it almost exclusively happens with companies whose licensing, TOS's, SLA's, etc allow for this sort of thing. That's where the problem is. Avoiding such companies, selecting safest licenses, and/or ensuring certain conditions are perpetual in contracts/licenses are easiest solution. GPL is actually a successful implementation of my claim, although it wasn't good enough. Affero corrected a major deficiency and more evolutions will probably follow. Many more licensing schemes can happen to reduce negative impact of business participation while empowering users.
The common theme in most gripes is what the companies do. The reason we have this problem is that users almost exclusively do business with scumbag companies. They don't care about terms. They don't care about its ethics. Prior abuses rarely make them change companies (see Microsoft and Facebook). They don't try to leverage their buying power to force (existing) or incentivize (startups) companies to negotiate something that's favorable to them and future-proof in main risk areas. Like the old saying, the only thing that was necessary for triumph of evil was that good people did nothing [while evil kept its eye on the ball and its hands/feet in a sprint].
A lot of these problems can be avoided by simply investing in the right organizations. People who pick up Microsoft's server operating system are in for more schemes than those that used FreeBSD with commercial support. Certain small companies behind IDE's and libraries have had great terms for their users for years with minimal hassles unlike the mess that's Microsoft's development tools. Services provided by non-profits, cooperatives, and companies simply focused on customer satisfaction have done great compared to race to bottom in cost or highest shareholder earnings that get many others scheming on customers. Pick the right people/companies/tools, maintain an out to avoid lock-in (open formats/API's help), and invest in that. Double down on it if they use permissive licenses and re-invest back into their communities.
In the end, this is more a problem of incentives than purely a legal one. People trust companies that don't care about them. They get screwed. Stop doing that. Do plenty more of the opposite. On top of it, explore alternatives [1] to popular source-sharing models in case business opportunities arise. Get momentum going in directions other than companies that do lock-in and lock-down. After all, I've done a lot of business with proprietary companies and have mostly avoided being boxed in. Same goes for FOSS use. Imagine that... All about what you use, how, and from whom. Sacrifices will need to be made, though, and now we're getting back to user demand (incentives) driving the negative practices.
Outside a niche, I don't see it happening because market as a whole won't take responsibility to make it happen. The problems are market's fault, as usual. Good that niche commercial, OSS, and FOSS have given us plenty of good stuff to work with. I encourage all of them to keep at it without a need to fight with any. I avoid GPL strictly for economic reasons: certain investments don't happen, esp high assurance or ASIC development, unless they can recover the cost somehow. Additionally, companies adopting high quality components makes stuff more robust over time. Finally, making money allows them to fight inevitable patent suits that will attempt to put them out of business and create more patents for defensive use. So, for economic reasons, I oppose the GPL in some spaces while respecting it and being neutral in others. My OS is GPL, for instance, and I'm grateful to its developers & community. :)
I think the GPL is a little outdated in that it misses the point on what really matters to ensuring the user's freedom.
I think having an open source application is useless to the end user. I mean really useless in and of itself.
What really matters is standarizing the data format and providing tools to convert/export to various other formats.
Say I'm using application X as a free-software word processor. Two years later I decide I'm done with it, for various reasons it's annoying. I want to migrate to some other application Y.
Also suppose that X hasn't been in development for over a year and no one is maintaining it.
Also suppose X is very complicated and no one understands how the code works.
What do I get as a user? What benefit do I get from X being open-source? Almost nothing.
On the other hand, if X came with tools to "liberate" data from itself, and had its data format extensively documented, then I could get some real benefits.
The only thing open source does is allow developers to collectively work on infrastructure tools. Such as git, etc.
I think having an open source application is useless to the end user. I mean really useless in and of itself.
It's not useless. The end user does benefit from it, just not directly. They benefit from the various modifications and enhancements under copyleft that are either integrated upstream or make it to other projects that they may use. They're also unhampered by usage or redistribution restrictions that may potentially get them into legal quagmire from more zealous vendors.
What really matters is standarizing the data format and providing tools to convert/export to various other formats.
Data formats are software, too. Other than the spec that standardizes them, there is a reference implementation which should preferably be free. In fact, being free is crucially important here: it means any extensions to the format are sent back, instead of a vendor pulling off an "embrace, extend, extinguish" by adding non-standard features to their proprietary implementation which they then lock other software to.
Also suppose that X hasn't been in development for over a year and no one is maintaining it.
Then the project is orphaned. Someone may or may not step up. The good thing is they can.
Also suppose X is very complicated and no one understands how the code works.
And yet the code is there, so it's not insurmountable if the utility is high enough to get past the bus factor.
Perfect example of why "open source" vs "software freedom" is a real issue. GPL isn't "open source" — it isn't about source, that's an implementation detail. It's about freedom. The OSI's definition of "open source" is effectively synonymous, but you are misunderstanding the importance by using the term "open source".
As an end user, software freedom means I can install something on any machine I want, run it as I want, share it with others… none of that requires source. If I want to tweak the software, that may require the source. The freedom is the freedom to change the software — whether or not the change is substantial enough to need full source to do so.
Having software freedom is definitely useful to me as an end user.
> I think the GPL is a little outdated in that it misses the point on what really matters to ensuring the user's freedom.
It doesn't have to be either/or. What the GPL gives us matters very much, what the AGPL gives us extends that farther, and maybe software freedom should be extended even farther.
The problem with "liberating" data formats is that data formats would have to be standardized - which 1) potentially kills innovation, and 2) implies a level of organization and unity of purpose that software practitioners simply don't have.
I think having an open source application is useless to the end user. I mean really useless in and of itself.
What really matters is that the user is alive and healthy.
Say I'm dying of cancer. Two years later I die of cancer.
What do I get as a user? What benefit do I get from X being open-source? Almost nothing.
On the other hand, if X came with a cure for cancer, then I could get some real benefits.
The only thing open source does is allow developers to gain understanding of how it works even if no one understands how it works, and then write tools to "liberate" data from itself and extensive documentation of data formats knowing that it matches the source code. But I suppose you're right, none of that is useful if you're looking for other people to solve your problems.
No one is claiming having an open source application will cure cancer.
FSF promotes "free software" as a means of ensuring the user's freedom.
When in fact, if you have a piece of free software that's old and unmaintained and the code is complicated and no one understands it, your software is by all definitions "free", but it doesn't really give you the freedom you are seeking, unless you are a developer yourself.
Most of the time, you will get more freedom if the developers had documented their data formats and provided tools to liberate your data.
> No one is claiming having an open source application will cure cancer.
What? I thought they were!!1!
> When in fact, if you have a piece of free software that's old and unmaintained and the code is complicated and no one understands it, your software is by all definitions "free", but it doesn't really give you the freedom you are seeking, unless you are a developer yourself.
Well obviously knowledge is power, but criticizing the GPL for users' lack of education is like criticizing the GPL for users dying of cancer. Actually, it's less reasonable: users are free to fix their own ignorance, while it's a bit harder to fix cancer.
> Most of the time, you will get more freedom if the developers had documented their data formats and provided tools to liberate your data.
¿Porqué no los dos? I'm not sure why you seem to think that ensuring license freedom is mutually exclusive with documentation and tooling. If anything, I see a positive correlation with open source and well-documented, migratable data. Have you ever tried to pull data out of an Excel spreadsheet into a database?
> there are very few permissively licensed projects which aim at end users.
Lack of citation and data noted. I'm assuming good faith and going to approach this as I would a fellow colleague :)
I'm also going to assume you perhaps haven't been introduced to the vibrant ecosystem of permissive licensed software.
The article also doesn't mention how GPL is a show-stopper at some companies where we are building proprietary solutions.
Oracle, IBM, Sony, Apple, Microsoft, Boeing all are monetized empires that profit not just from binary blobs, but from providing a superior product. Also, being the patent holder is lucrative.
How do you intend on running a business and feeding your employees, let alone making investors happy following the virtues of GPL? Consulting and support only goes so far.
> Most of them are stepping stones towards further software development.
Ever hear of DragonEgg? (GCC was used to bootstrap LLVM/clang in it's early days.)
Devs use GPL software to write permissive software. Sometimes they do so because they have no choice but to reinvent the wheel because of GPL's rules.
> how GPL is a show-stopper at some companies where we are building proprietary solutions
Is this not one of the the main purposes of the GPL? To prevent companies taking the users freedom by "building proprietary solutions".
> It also fails to mention that sometimes providing the user with the best products means protecting the investment and creative effort painstakingly poured into development of a product.
Nope it doesn't fail to mention this. Your opinion here is totally orthogonal to the original premise of the free software movement (and of the GPL). The GPL was written on the premise that users are better off with objectively worse performing software that maintain the four freedoms.
You probably disagree with me on whether software freedom is more important than software quality but it is important to understand the basis of our disagreement first.
You've completely missed the point of the article, and the entire purpose of Free Software, if you think this is about 'providing users with products' and generating a return on investment.
> if you think this is about 'providing users with products' and generating a return on investment.
In who's eyes?
Consumers want the best product.
Investors want a payout.
How does GPL satisfy either of these?
GPL doesn't have the nimbleness to be viable with the market. It doesn't respect creativity and time of developers or investors - leaving consumers left to pick a proprietary / permissive alternative.
You don't need to be GPL to be open: You can MIT/BSD/Apache and still volunteer to not give out binary blobs [1]
> You don't need to be GPL to be open: You can MIT/BSD/Apache and still volunteer to not give out binary blobs
That's fine but it's only one level deep. What about the people that download your source and accept the terms of your license? They are totally free to make binary blobs and refuse to give source to their downloaders or their changes back to you.
The GPL directly addresses that and keeps the code free, no matter who gets it from who. It's really the only way to guarantee software freedom.
If you don't want to generate a return on the investment of your time, it means you have an alternate source of wealth. Most of us do not have that luxury, and therefore cannot share in the vision of Free Software.
> The article also doesn't mention how GPL is a show-stopper at some companies where we are building proprietary solutions.
> Oracle, IBM, Sony, Apple, Microsoft, Boeing all are monetized empires that profit not just from binary blobs, but from providing a superior product. Also, being the patent holder is lucrative.
I'm really not a huge fan of the GPL but you have to realize those are by design. To a supporter of the license, that's actually a plus.
> How do you intend on running a business and feeding your employees, let alone making investors happy following the virtues of GPL? Consulting and support only goes so far.
If the GPL doesn't fit your business plan, just don't use it. Do you see Open-Source projects using leaked closed-source code (or complaining that they can't do so)? No one is preventing companies from rewriting equivalent code and the authors had the right to select whatever terms they wanted when they created their project. It's their creative output after all.
We also have lives to live - limited resources, money, and days on Earth.
It's more intricate that the way you view it outside the world of academics, non-profits and eurozone states with social benefits that give you the freetime to do that.
If you're open to knowing more, I could elaborate.
> there are very few permissively licensed projects which aim at end users.
Lack of citation and data noted.
Four sentences later in TFA:
But when I think of projects I use every day which are programs I actually run (for example, as an artist I use Blender, Gimp and Inkscape regularly), most of these are under the GPL.
Those are three major data points. Do you have any data or citations to contribute?
For every company that employs personals that refuses to use the best tool for the job a competitor will employ a employee that will and the market will give the more agile company success while the other will fail.
Basic market principles. Religious stances don't save money nor will it produce better goods. Understanding what licenses is suitable where, when and how means being able to compete in highly competitive areas, and only if the market leans towards monopoly can inefficiency survive.
The primary criticism of the GPLv3, from what I know, is that it's backwards incompatible with the GPLv2, creating practical problems with code sharing between v2/v3 projects. That is to say, the GPL is no longer a single "universal receiver", it's been forked.
Then there's disagreements as to whether things like Tivoization are really an issue, as Linus Torvalds for instance doesn't think it is and so sticks with the GPLv2.
Can't speak for commenter above, but v3 has a "patent license" clause that is literally impossible for any large company to comply with.
Not just difficult or undesirable, but impossible.
GPLv3 requires you to offer a free license of any patent you have a license to that might apply to the GPLv3 software to anyone who might want to use that software. Almost any large company has at one time or another purchased broad patent licenses that cannot be sublicensed.
So GPLv3 is an absolute non-starter for any large company. You want to doom a product, license it under GPLv3. It may not instantly kill it, but it will slowly strangle it.
it is also more difficult to demonstrate project independence. if two bits touch, GPLv3 spreads.
v2 at least is worded in a way that allows non spreading if you can demonstrate the functionality can be replaced by a third party lib without altering the software functionality
also it makes unnecessarily hard to comply. in GPLv2 it was quite easy to determine who was an user and who was entitled to receive the code.
GPLv3 makes this unnecessarily difficult because it overreacted at previous GPLv2 shortcoming. Think for example deploying on a kiosk.
What is the impractical consequences if you sold a photo booth kiosk and had to give the recipient the source code for the internal software? I would assume that photo booth kiosks producers got their money from selling the physical kiosk and competition on the internal kiosk software is going be at best an minor advantage. Management software or similar could still be proprietary, through competitors could make management software that is compatible with those kiosks, which is a good thing in my book.
Customers of the kiosks however have no such right to source code, since they don't receive any copies of the software from using it. You enter, you insert a coin/cc, and out comes a photo and maybe a code which allow you to download the image to your phone. Neither is "copies" of the kiosk internal software so the license doesn't involve them.
My name is zobzu. I fight for the users, and I'm standing up for the GPL.
(seriously tho, same license by default, same reasons - feel free to downvote, it won't change my licensing choices)
This makes the usual false dichotomy between 'users' and 'developers' and positions GPL advocates as freedom fighters.
Also as usual, there is no mention of how a GPL based economy can work. The reason the GPL is not loved by developers as much as the freedom fighters would like is because we need to earn a living. If GPL advocates can address that, they would be able to stop wasting time with these rants.
Hi! I, along with many other software developers, make a living out of developing GPL-licensed software.
We build on top of an AGPL licensed platform (Odoo) and we offer both custom development and a SaaS hosting platform - and various services around those. We're not the next Microsoft, but we sell to some of the largest companies in our country (and many smaller ones), and make a comfortable living out of it.
Proprietary licensing certainly makes it easier to build a moat, but it's certainly not required, there are alternative business models.
You seem to be persisting the myth that developers aren't able to make a living under GPL. In the WordPress ecosystem virtually all products are GPL compatible and the economy is worth millions and millions. Developers are doing just fine under it, more than fine actually. I'd like to hear a single case where GPL licensing made a negative difference between financial success and failure (maybe they exist, but examples are never brought up, funnily).
I'm not perpetuating this supposed fallacy. Software developers fail with their products for various different reasons, there just seems to be very little evidence that the choice of GPL has impacted economic viability. At least I can say that there is very little evidence of that in the WordPress ecosystem.
If you complain about the lack of an example of how a GPL based economy can work, you simply ignore existing markets. The WordPress ecosystem (worth billions) is almost exclusively GPL and developers are succeeding with successful products and services, operating businesses in all kinds of revenue ranges. Many small teams and even solo developers are regularly netting 6-7 figures a year. They are doing so utilizing a variety of business models, proving that almost any kind of solution can be made to work in some format, provided it's something people will pay for.
There has always been some push back for the GPL, especially by designers, in the WordPress space. Despite that things are working. We have an entire commercial themes market that is selling GPL based themes, with many successful authors raking in money. Some people thought it was crazy, but theme sales are sky high.
The only reason some developers aren't making money there isn't because GPL, it's because the competition is strong and the work is hard and some people can't or won't adapt.
Stallman had a printer which had proprietary drivers, and he wanted to fix an issue with the driver. He couldn't. He created the GPL so that, in future, people wouldn't have this problem.
Stallman created the GPL because he cared about user freedom.