You emphasized anyone but by allowing developers to take the code proprietary, their users (which are using your code) are being denied the freedom you promote. This is of course the distinction between GPL and BSD-type licenses. One gives developers all the freedom they want while the other ensures that all users (including those using derivative works) are given those freedoms.
>> I feel we've lost ourselves in the freedom of users and forgotten about the people that make the applications for the users.
No, we have not. One form of license ensures all users have the right to do whatever they want with the code. The other form (which some call permissive) grants the right to deny others those freedoms. I understand both stances, but I believe calling the right to deny others rights "permissive" is rather misleading.
Their users are not being denied the freedom to use my code, their users are being denied the freedom to use their code, which is their right.
The cynic in me really thinks its important to wonder why there exists a GNU, and not an organization formed around and sustained by the MIT license.
Unless they know it came from you and where to get it (which will not be advertised), they are. Also, after you die and your source code is gone, the derivative work could still go on to whatever success and none of the users of your code will have access to it except for that developer of the derivative work.
And almost all licenses require attribution.
>Also, after you die and your source code is gone, the derivative work could still go on to whatever success and none of the users of your code will have access to it except for that developer of the derivative work.
This makes no sense. The source code of what I did will still be around, and still be attributed. Dying doesn't make my work disappear into the ether.
Yes it does, unless someone keeps it online or somehow available. But again, just because it technically exists somewhere doesn't mean a user of the derived work will know how to find it, nor what parts that work are actually covered by your code prior to finding it. You are starting to sound like someone deliberately not getting the point of this.
I see a valid need for "permissive" licenses, but the legitimate reasons are rarely cited by proponents of the licenses.
This sounds pretty ridiculous to me. Can you cite an example of abandonware that completely disappeared from the public internet but continued to be used by some user-facing product? It seems to me that if development stagnates on a project entirely, its almost a certainty that the project is unused, or has been forked (and potentially new changes have been placed under another license).
>nor what parts that work are actually covered by your code prior to finding it
So, the open source license should really only be relevant to highly technical users (that is, my parents will never care about the license software is under). I'd hope those users are capable of discerning what the OSS licensed software does.
Of course. The MIT license is the legal equivalent of putting shit out on your lawn with a big 'FREE' sign. There's no need to protect that. The GPL requires you to pay the developers in contributions, which requires enforcement.
No it does not. The GPL is a downstream license. It requires you pass on the freedoms if you share with others. It does not have any requirement that anything be upstreamed back to the place you got the software from.
The cynic is me says the answer is that the people interested in MIT licensing are not very interested in sharing their work with others in an organization.
Don't get me wrong, there are instances where MIT or BSD licenses make sense. Desktop software is not one of them.
What does this mean?
The MPL(v2) forces forks to be open source, but any files added to the project can remain closed source allowing it to be used as a library for closed source applications.
The original article highlights LibreOffice and its success using the reciprocal MPLv2 not without reason.
[Edit: mixed up the first paragraph.]
MPL and LGPL draw a line between code that is allowed to be distributed under a proprietary license, and code where the copyleft applies.
This is often asserted, but unless those proprietary software developers are somehow able to magically erase your own claim to copyright, the user is no less free when using your original version.
My code is not denying anyone's freedom. Someone downstream might be denying their users' freedom, but those are their users, not mine. Downstream use of my code for evil purposes is outside of the scope of my own development.
What is in scope, however, is the idea that a downstream developer should either contribute code back to me (whether privately or via license reciprocation) or not claim one's own product to be equivalent to my code. The Artistic License 2.0 does a decent job at that.
I'm sure that if Linux wasn't GPL, you'd have 'vendors' selling 'HP Linux' and 'Corp Linux' to their locked in customers in no time at all. The only reason Linux grew up to this point is that the vendors are forced to contribute back and cooperate (up to a point). Mind you it might also be the reason Linux is so bloated these days, but at least there is no vendor lock in...
As a small example, someone decided a few years back to release a "Arduino UI" over my own simavr[0] as an indigogo project. ie trying to be paid to package a demo I made (for free): he had screenshots, a few promises and no source code. I managed to email the guy telling him I wanted to see the source code of the whole lot and somehow, the project fizzed out.
If my project had been BSD, I might have seen someone making money from my project and associate my name with something that I had zero control on. When I give a project away, I want it to stay free for use, and I really hate to see 'packagers' who don't contribute anything at all move over and try to monetize it.
Same story as when I released freewares a few years back, I had a note saying it was NOT ok to package it on 'CDs' sold around.
It's in the best interest of a large company to contribute until the project gains a large userbase willing to pay for extra features, while selling forks (with added proprietary features).
Then a company quietly pulls out of upstream development to focus on developing and selling their fork. Chain reaction and the other companies quickly follow the example.
Customers trusted that they were using a "mostly" Open Source project but suddenly end up having to choose between proprietary products with an open core.
If he went along with his product being forced to be open, what then? It still has your name associated with it, he might still sell some copies. I'm just not getting the principles.
it's not the first time I see that, at my previous company, a guy took most of my in-house (closed source) middleware layers and was selling them as a 'product' as is on the interweb.
People would rather be objectively worse off rather than feel that they had been taken advantage of.
If we look at it from a utilitarian perspective having someone who didn't add much capture all of the commercial value seems to be pretty poor. If the feature he was adding was worthwhile I bet he could have been honest and convinced people to pay him to add it. Everyone would have benefited and paying him would have been worthwhile and necessary because while he couldn't have legally kept it closed source, he didn't have to write or release it at all.
I don't know. For such a complex project like linux you can't do all by yourself and you most likely want all the improvements and extensions done by other people.
To be able to incorporate all these changes you have to keep your code base compatible and the easiest way to do this is to give back your changes.
But even if this seems to be the most sensible way to go, an other license might have allowed people to be a lot more unreasonable.
On the other hand a lot of WiFi router vendors violate the GPL by not releasing the code and contribute nothing back to Linux.
NetApp is a very good example, as they contribute NFS code back to Linux but not FreeBSD.
Why do you think that might be ?
Literally every company you mentioned contributes code to FreeBSD, so what are you even talking about[1][2][3]?
[1]: https://freshbsd.org/search?project=freebsd&q=netapp
[2]: https://freshbsd.org/search?project=freebsd&q=emc
[3]: https://freshbsd.org/search?project=freebsd&q=iXsystems
Hint, shitty little few line fixes != contributing back.
What a disingenuous response, Linux does not have the WAFL Filesystem and so why point out wether FreeBSD has it or not. Also NetAPP released Bhyve and EMC Isilon has made over 4000 commits to the FreeBSD tree, those are serious contributions regardless off what you say.
As a member of the Software Freedom Conservancy board you should seriously stop spreading Misinformation and being so dismissive of other FLOSS projects.
And one counter-example isn't enough refutation.
not saying i believe either of you. just saying, language matters.
For me, GPL doesn't go nearly far enough, and I licence everything I write under AGPL.
How is the contribution process organized? How willing are the developers to incorporate foreign extensions?
There a quite a few factors that determine how such big projects work and at the end it's IMHO always the people involved that make the difference.
I come from a perspective of hating the corporate world for the two decades I've been in it; feeling deeply overpaid compared to the guy who cleans my trash bins every day who I feel should be paid more.
The old 1990s/2000s vision was of a more just and equitable society. Today we have garbage like Android where vendors just release binary blobs and don't contribute anything useful back (non-upstreamble patched and proprietary/custom/terrible kernels).
The people who originally wrote a lot of OSS and Linux software were envisioning a world where Adobe tools would be replaced by Gimp/Inkspace and the Ubuntu desktop would make Windows obsolete except for specific MS software/tasks. That never happened.
Today software is more closed than ever. You can't run a modern x86_64 system with open firmware, and most companies simply release middle ware under an MIT/Apache license. They want you to build tools that work with their closed garden platforms, but not re-create their platforms.
The reason that never happened has nothing to do with the licenses. It happened because most purely open source programs have abysmal UX. Every time I open Inkscape on my retina macbook I feel like I'm grinding the machine against concrete - it's slow, looks awful, doesn't scale and doesn't use the system's native UI libraries. Somehow all of RMS's charm never seems quite enough to convince designers to fix the glaring, obvious problems.
But who is working on it? Obviously not you. Obviously not me. It's a lot of work. I've looked at code here and there and often said "..huh..that's not has bad as I..oh no wait..yea..yea it is..I wish I had the time to work on this."
If some of the Stallman-ish/revolutionary ideas had happened in the last decade, maybe all of us could spend 20 hours a week trying to fix/improve/rewrite the software we like/need. Today software devs are slaves to the industry. Even if we get paid well, many of us are still working for things that will bubble and die. The only things companies open source is middleware that can make them important.
Money is addictive and it's taken people away from that ideology that simply doesn't pay the rent. There's something deeply wrong with all of this, but we're in another state of hypernormalisation, so it's very difficult to see or address in a meaningful way.
Could you expound on what DarkTable, GIMP, and Inkscape needs to be more comparable to the Windows/Mac alternatives? What are the crucial, missing features?
As a hobbyist photographer and video editor, who has used Lightroom and Photoshop extensively, I find that I manage fine with alternatives available on Linux.
> But who is working on it? Obviously not you. Obviously not me. It's a lot of work. I've looked at code here and there and often said "..huh..that's not has bad as I..oh no wait..yea..yea it is..I wish I had the time to work on this."
I am working on it. A lot of us are. But we need to know what to implement. We need bug reports and feature requests. DarkTable alone has almost 20 000 commits and 200 contributors. The Linux kernel has about a 1000 contributors for every release.
Does it look like we're not working on it?
And money? ... Well, yes, most HN commenters seem to be very money-centered. After all, it's a site about starting new crappy companies, pushing shitty, useless products noone needs. They don't give a shit what they partake in, as long as the paycheck is right.
But, nevermind that.
A lot of open source contributors are paid full time to do this. So you can work on open source 24/7 and get a fat paycheck, if that's your thing. The two are not mutually exclusive.
Then there are those who actually code because they like it, you know. Because it's their passion. They might endure a shitty job to make a living, but in a weekend they do 50 commits to open source projects.
Be a slave if you want, I choose not to. I work on whatever I want.
Frankly, yes.
I can't speak for the experience on linux, but on mac Inkscape needs to:
- Support high dpi displays
- It needs to scroll and zoom smoothly. (There's no reason for it to lag while scrolling and zooming on a modern computer. Every other app on my system manages it).
- It needs to use the operating system's menubar instead of xquartz.
- Use native controls for everything. That open/save dialog looks like something out of the 90's.
- It needs to support smooth scrolling.
That would be a start.
These problems do not exist on the Linux version.
Proprietary OS users are going to judge Inkscape (or Gimp, or any other Free Software) from what they see on their platform. If it lags and doesn't support High DPI on their platform, they're going to assume the same is true of the GNU/Linux version.
Some users won't switch because of this faulty assumption.
Native UI… while there is little point it catering to users who won't switch anyway, it will still reflect badly on the application. Widgets that look like "something out of the 90's" will say to the user "I am an old unmaintained app" whether that's true or not. Users are highly influenced by an application's look.
I think focus and efforts should be directed at making good software for Linux. And I do not think that porting OSS and free software to closed systems is a good strategy for converting users.
Users switch from macOS and Windows to Linux for all kinds of reasons, but there is no point in trying to "lure" them in any way. It will be of own volition.
That said, I think this is but a small part of the problem. The bigger enemies are the bundling of Windows with new computer (no separate purchase of the OS), and windows-only games. They're the main reasons behind the proprietary hegemony on the desktop.
When so few desktop computer run Linux, half-heartedly supporting Windows and MacOS comes of as a bit haughty. But if Free platforms are the norm, supporting the proprietary ones at all will actually sound generous.
Scrolling is pretty choppy and it doesn't support smooth/inertial scrolling.
So 3/5 of his listed issues exist on the Linux version.
Even if you, yourself don't want to do it, the attitude you've taken here is exactly the attitude which drives people away from OSS.
The problem is, his side is "winning". Linux is quite hostile to proprietary software, so not that many people will use Linux since apps > OS. So if OSS doesn't push for better apps even on proprietary systems, it won't even get out of this catch 22.
People often seem to forget just how small Apple's desktop marketshare is.
Like I said in a comment above, Apple's desktop share is incredibly small percentage wise, but more than big enough for them to sell desktop hardware.
Now hardware vendors also offer Linux (Dell, System76).
Linux/Unix absolutely crushes it when it comes to server/infrastructure, academia, and research. Who cares if official numbers call desktop marketshare of 2% or 5%.
Well, you should care. You should care when your clients or friends send you a file in a format that you can't open or transform properly on Linux. When you want to print something and your printer doesn't have drivers for it. When you want to play an AAA game and it's not available for Linux. Etc., etc.
I manage (and share with my peers!) the books for an organization with GNUCash.
I collaborate on and write papers with LaTeX, write my code in languages with open standards, use primarily open source compilers, and run my code on Linux cluster which use open-standard parallel communication APIs and open-source implementations.
I do not play video games.
My office printer is plug and play with Linux/CUPS.
All done on my trusty custom linux distro (Exherbo) for years. Oh, and I haven't reinstalled since 2010 but I am running the most recent open-source GNU/Linux software.
Maybe my life and my needs don't match others', but then again maybe erikbye's don't either. Anyway, that is why I do not care about more people using Linux. If anything, more Linux users have made the internet a less useful resource for helpful Linux knowledge.
Why should I care?
P.S. my phone is another story, but I expect different things in that space.
And you probably shouldn't care, except for altruistic reasons :)
Linux has 1950+ games on GOG and 6500+ on Steam. Some of them AAA.
When it comes to file formats, I'm sure there are certain formats that poses a problem, but at least not the most commonly file formats exchanged. Like Microsoft Office formats; LibreOffice opens pptx, ppt, xls, xlsx, docx, doc, docm, etc.
Inkscape as mentioned above, opens Adobe illustrator files.
Both GIMP and Krita opens Photoshop files. Krita perhaps being the most appealing alternative to Photoshop users (UI-wise).
And normally, if you have clients, they don't arbitrarily send you arbitrary files in random formats. You have agreed on a workflow and file type.
Whoa.
Would any of Stallman's ideas change that? If you could wave a magic wand and make all the BSD/MIT sourcecode out there GPL, how do you imagine that resulting in the gimp being funded, or staffed by good UX designers?
I suspect it might put a lot of engineers out of business, because of how much the modern development industry depends on opensource. But then programmers would just have less money. I don't know how that would help bring about stallman's utopia.
Asking as a person who's never done "real" editing work, but has dabbled here and there and finds Inkscape to be one of the more pleasant OSS projects. I wholeheartedly agree that Photoshop kills GIMP, and I understand the reasons why. So I'm curious what the reasons are for Inkscape v. Illustrator since I haven't run across them?
That's not a reason to stop believing and helping with small things. I don't say you don't contribute, I just say that "difficult" doesn't mean "impossible" in any way :-)
Most open source stuff actually is poorly engineered, if engineered at all, because a lot of it is developed by beginner-level coders. Now, I do of course know that many, many commercial products are full of crap, too ... but engineering excellence still mostly goes into commercial products. Obviously. It goes where the money is, and in most product categories that can't/won't be open source.
Almost every open source project is completely focused on implementation, all the while implementation is only one facet of a software project. All other facets are usually neglected.
Yes, there are quite some projects one might call "industrial-strength XY" -- but the vast majority aren't and never will be. This is also not just a numbers game; a large number of crap-quality open source stuff is incorporated into widely deployed stacks. Just take libraries for file formats, just a couple days ago we got a dozen or so CVEs in libtiff ranging anywhere from denial of service to arbitrary code execution. That thing will be on most web servers.
Ubuntu is pretty solid but I would be a liar if I wouldn't admit it has serious flaws (e.g. making the user execute superuser shell commands to test and enable hibernation is pretty shitty UX). I'm tech-savvy enough to be willing to accept these trade-offs but I can easily see the appeal of macOS (even if the naysayers are right and Apple have lost their way).
I started off the year by giving a couple of alternative browsers a chance to wean me off my reliance on Google Chrome and even Brave was a more workable solution than Firefox: in order to make Firefox work properly I had to learn about its multiprocessing mode and individually test extensions from the official addon hub for compatibility. And while the dev tools certainly feel like a lot of effort went into them they come nowhere near the UX of Chrome's.
Even GitLab needed a lot of time to reach a state where it can be considered a serious alternative to GitHub (sans the community around GitHub, sadly). And GitLab has an entire company around it and is "merely" open core.
These days when evaluating software alternatives for any given problem the words "open source" are no longer a selling point for me. Even worse: if it's not tied to a commercial entity somehow deriving profit from it, I'm less inclined to use it. Self-hosted open source web app maintained by volunteers? That's usually code for terrible UX and show-stopping bugs.
Do you think the tool ever makes the artist? I have seen great works of art made with a pencil. A piece of coal. A twig and blood. A simple needle and ink. I have seen great works of art made using Microsoft Paint.
> Ubuntu is pretty solid but I would be a liar if I wouldn't admit it has serious flaws (e.g. making the user execute superuser shell commands to test and enable hibernation is pretty shitty UX). I'm tech-savvy enough to be willing to accept these trade-offs but I can easily see the appeal of macOS (even if the naysayers are right and Apple have lost their way).
I don't like Ubuntu and I don't use it. But, there are plenty of things that can only be done using a terminal in macOS, as well. In fact, macOS/Apple is pretty much known for hiding things from their GUIs.
Anyway, I do not agree that typing in commands are bad UX. Many things are far easier and faster to do in a terminal than through a GUI. One example: installing software.
> I started off the year by giving a couple of alternative browsers a chance to wean me off my reliance on Google Chrome and even Brave was a more workable solution than Firefox: in order to make Firefox work properly I had to learn about its multiprocessing mode and individually test extensions from the official addon hub for compatibility. And while the dev tools certainly feel like a lot of effort went into them they come nowhere near the UX of Chrome's.
Why are you talking about browsers and comparing Firefox to Chrome, are you trying to compare open source vs closed-source? Do you know what Chromium is?
It sounds like you are actually trying to say something as stupid as: open source projects are generally worse than closed source projects?
Most Linux desktop applications sadly have no good business model. If you have a business model you can pay developers, designers, support, writers, etc.
Adoption of business friendly licenses in detriment of GPL, means we will get back to those days.
Another way to look at this is that it has allowed companies to contribute to open source at all.
We'll never see how the industry would have developed if there had only been GPL and closed source with nothing in between but I believe we're better off this way because I don't think enough closed source companies would have made the jump to GPL.
Right now I'm using an open source OS published by a commercial company, running an open source browser published by a commercial company and make my living developing software using open source libraries published by commercial companies. Most of the software these companies produce is open source and most of the open source software is non-GPL, yet they are enabling me to stand on their shoulders for free.
Political tangent: I think a pure GPL open source ecosystem is impossible in a capitalist environment. Much like Communism it only works when executed at a global scale to achieve the critical mass. If GPL is Communism, non-GPL open source is Democratic Socialism. Purists think it's a stopgap at best or distraction at worst, pragmatists see it as the only viable alternative to the tyranny of closed source.
Also, Chrome for Android isn't really open source either, see the FAQ: https://developer.chrome.com/multidevice/faq "Chrome for Android is derived from Chromium. Since the launch of the first version, we have steadily open sourced all the critical components. You can build various Chromium components for Android as used in Chrome for Android using the instructions here."
Although to be fair, Google Chrome itself is not open source (although Chromium is). The main reason I'm using Chrome rather than Chromium is that I like the closed source parts too (e.g. the Google-specific integrations).
I don't think this is true. It's not particularly hard for developers to comply with it, especially those who are used to operating in an environment where most software is proprietary. This is the world where corporate licenses and contracts end up regularly end up into triple-digit page lengths. It's where the answer from management to the question "can we use this third party software?" usually defaults to no regardless of the license. So as long as there is this kind of restrictive proprietary licensing, I believe there will be a need for copyleft to counterbalance it. Sometimes there is a real risk of a rogue organization trying to take free (libre) code in order to crush the community with it.
The fact that there is so much software out there that uses non-copyleft free software licenses I think is testament to how many, many of our techniques and algorithms have become trivial and commonplace. This is good that friction is being removed in these cases, no matter what license the downstream developers are planning on using. It's the sign of a mature industry.
This is clearly up for debate.
Software-freedom as an interesting social factor is first and foremost about users, not software-publishers. Basically as a user of free software, I should be free to modify the code of the program I'm using.
While I as a professional programmer prefer using permissively licensed libraries (MIT/BSD), because they are easier to integrate, that means I take free software and make it into non-free, commercial software in the process.
That means the users of my work-output will enjoy less freedom than I had (as a publisher, a non-user). That's undebatable. So freedom is lost.
When not constrained by work-requirements w.r.t. licensing, and I write on my own spare-time hobby-projects, I'd like that code to be free and remain free.
I'd like that any user of that code I just wrote (note end-user, not someone bundling my code inside a different project) should have the freedom to modify and fix that code.
And the only way to guarantee that is with a copyleft license like the GPL, because it preserves end-user freedoms which BSD/MIT-style licenses (intentionally) doesn't.
So that's the only license I use.
Yes. That means developers just like me won't use it in commercial projects, but I don't care about that. I care about end-user freedom.
EDIT: Terminology, as outlined in child-post.
No, it's about the software. Free software is free in the sense that it can't be owned, like a common good. Saying you shouldn't be able to own (i.e. control access to) software is very similar to the argument that you shouldn't be able to own land. This is a political ideal.
The rationalization of that ideal is often made to be about the users but the benefits are indirect and whether they hold up in practice has not yet been reliably demonstrated as far as I'm concerned.
Arguing whether permissive or restrictive open source licenses are freer is mostly and argument about the definition of what "freedom" actually means.
GPL advocates say open source is about the freedom of the user to get access to the source code of what they are using. Advocates of permissive licenses will say open source is about the freedom of the downstream developer to bundle and distribute the software in any way they please (including in the creation of closed source products).
Saying that one or the other of these "freedoms" is not really a freedom is literally just an argument about semantics and not meaningful unless you're specifically interested in having only that conversation.
EDIT: Pragmatically IMO the freedom of the end user matters less because they need more than just access to the source code to derive any value of having that access, whereas for a downstream developer the value of being able to do as they please is extremely direct. Especially when talking about libraries which by themselves exist merely to help developers create software and frequently only use the GPL to force the hand of downstream developers when picking a license.
Again, like I said, that's clearly debatable.
First I think we need to shoehorn some terminology into this conversation in order for it to be useful.
You have two clearly distinct roles. You call them "developer" and "user", but that's really imprecise and doesn't correctly capture the use-cases which we're discussing, so here's my attempt:
* A publisher (what you call a "developer", someone who releases software, different software, one which will have to "deal" with reciprocal licenses).
* A user (one which runs software, usually on devices he own).
It may not be the norm, but a user may very well build and modify the software he uses (that is: do development work), and submit patches back upstream (instead of forking/bundling the code and modifications in another product). So while clearly a developer, he is first and foremost a user, and he doesn't need to care about licensing, since he doesn't actually release anything on his own.
Example: As a user of a device I buy, I want to be able to modify and replace its firmware when I find it lacking. In this case I'm a user, not a developer, at least not until the need arises.
And a "normal user" may not be able to do all these things, but as others have noted, there may be a pre-existing development community which has pre-modified builds available (like Cyanogendmod, OpenWrt, Coreboot, whatever).
In that sense, things being open to me, the user, the owner of the device running the code, has an high value anyhow. Not having control over what runs on my devices is unacceptable in a post-Snowden, emerging IoT-ridden world.
And I think those concerns are much more important for the IoT-everywhere world we're moving into, than some mere licensing inconveniences for publishers when they free of charge incorporate other people's work into their own product.
Frankly, I was cynically happy when a lot of GNU projects were licensed under GPLv3, and suddenly everyone who locks down their firmware (which is usually a big hunk of GPL code + a piece of shit web UI) was sent scrambling for alternatives and, gasp, even having to -- hear this! -- pay for the software that they proceed to resell. Outrageous. It also fueled the development of really good alternatives. It did make my life more difficult, but I'm satisfied that it also made life more difficult for companies that lock down their users and whose business model is largely planned obsolescence + no privacy.
(Note that this is heavily skewed towards embedded systems :-) )
One thing I still considerably like about BSD-type licenses is that they do not incentivize "community leadership and involvement" and half-baked upstream contributions for the sake of companies being seen as "thought-leaders" in their respective "communities". It does mean less upstream support for a lot of things (most visibly drivers), but it also means that crap in-house hacks stay in-house rather than being "contributed back" to communities whose users don't really want them, but don't really have a choice now that the community leaders are largely corporations engaging in free software circlejerking. This involvement for marketing's sake is a big part of why using a Linux system is so painful nowadays, six or seven years after it no longer needed to be so painful.
This is not necessarily a good thing.
Lower adoption rate of GPL'd software means less freedom for the user.
Especially painful hacks are graphics and WiFi drivers.
The trouble of course is that people do not go to complain to, say, Nvidia that their GPU does not work, but to the distribution maintainers or kernel developers who have no control over the driver.
This particular type of hurt is why I like GPLv3.
You reverse cause and effect. The GPL is what you choose (or in this case choose not) to have the effect you mention. You're not forced to use the GPL nor the projects which uses it.
> I've realised that the GPL licence just causes more pain and frustration to developers.
It doesn't. If it causes pain and frustration it's because GPL forces people into thinking/believing into a political agenda. Disagreeing on political things is always painful. So the problem is not the GPL. The difficulty is that some choose the GPL because of the political thing and therefore, they force (the GPL helps a lot at taht) other developers to interrogate themselves about those political questions. And they may get frustrated or dad or whatever, but ultimately, they realize that they don't align with the ideas embodied in the GPL, or in another way, they realize the cost of sticking to the GPL.
The GPL is not the problem. It suits people whose mind are aligned with the FSF's goals, and for them it's perfectly fine. Just realize that it's not for you.
Now, having practiced the GPL, I can assure you that it definitely embodies the political ideals of the FSF and that sooner or later, you'll come to confront with people who don't get it, and "confront" is not a weak word. Know what you stand for.
The problem is that many projects choose licenses without carefully assessing all the trade-offs. If someone already built the thing you need but chose to release it under the GPL it might as well not exist if you can't use GPL code in your project. This is especially true if the value added by the library is minute in comparison to the overall scope of the project (this is by design). Just ask any developer who inherited a non-GPL project from a junior developer who doesn't understand licenses and accidentally used GNU readline.
If a library naively omits the license altogether (based on a widespread misunderstanding that "no license" means "public domain"), they will usually be able to switch to an open source license easily.
If a library naively uses a permissive license, you can simply incorporate them in your project (whether that project is GPL or not).
If a library naively uses the GPL, not only are they likely locked into it until the end of time but the code might as well not have been written at all unless your project is already GPL or you are willing and able to switch your license to GPL.
I'm glad the GPL is what it is : it's so tough you can't avoid the debate. And that debate is soooooo useful...
First off, thank you for acknowledging that permissive vs copyleft licenses is a trade-off between developer and user freedom. So many people claim that one is strictly less restrictive than the other, and that's simply not the case. So, which style of license you should choose is a question of who needs the freedom more.
In my opinion, users have very little control in the current state of computing, so I am inclined to release as much of my work under the (a)GPL as possible. I think that's worth a little developer frustration.
I'd also like to point out, that this is a moral issue more than a practical one. It applies equally to my stance on things like limiting the power of law enforcement.
In the world the GPL envisioned, most people would also be developers, at least occasionally. That's obviously not true today, but as algorithms take over society, we may still see progress in that direction. There are some communities, such as many academic disciplines, where it has become a reality–economics may be a good example where a large majority of graduates today have done some coding, and where a field profits tremendously from OSS licensing.
Fundamentally, it's an argument analogous to the political fight about the meaning of a "free market": Are antitrust regulations a undue intrusion into the freedom of large companies, or are they necessary to preserve the freedom of consumers and competitors?
The essential shift since the GPL was written is the web, obviously. In one sense, OSS has flourished, with it becoming the default stack of most industries, including the web. On the other hand, end-users rarely see OSS. These issues may be linked, because the client/server model allows companies to use OSS, even GPL, to provide proprietary services.
Slowly but surely I noticed that the licenses became the main point of contagion and I did not actually care about the letter of the license anyways. I wanted people to use it and not have to worry about it. I know I'm not alone.
I look on the GPL somewhat differently. I look at it as a means of payment to the community (and to myself by extension for my own work).
I want to be paid for my code and the things I create. But I also want to give back to the community. The GPL allows me both. You may ask, though, what kind of money can I get if I give the code away?
I don't want money.
I want code.
Code for code. That's what I want as payment. I want the code so I can learn from it. So I can make my code better. So I can make the thing I made better, and so I can give that better thing out to others, so they can make their things better.
I could make my code proprietary and "closed" - but that doesn't mean I'll get any payment for it. In fact, it might be copied and pirated. Proprietary code also doesn't allow me to share the code.
Releasing it BSD-style allows me to share the code, but I still might not get any payment for it. Honestly, I don't want the money - I don't need the money.
But code? I can always use more code. I can always learn from other's code. Code is very valuable to me.
Another thing - I know that if I die, or if I stop giving away my code for some reason (by choice or not) - my code can live on, and continue paying back to others in code. I don't have to worry that someone out there won't be able to use the code or run the code because the hardware has changed so much (they might have to recompile, or perhaps rewrite some of it - but they have the code to do so), or if it has a bug, they can fix it with the code.
I look at the GPL as a means of paying for code, and getting paid for code - by being paid in code.
This means that a wider range of people/projects are likely to use your code, but any bugfixes or in-file features need to be open sourced. This results in a higher quality of code, more complete and rounded libraries, and not everybody's kitchen sink gets sent upstream for potential merging.
You don't have to. Don't use the GPL'd code. The author of the GPL'd work has chosen unwaivering freedom for the user over all else. You are free to write your own implementation. Why should that developer have to allow you to use her code in proprietary software?
Speaking personally: I'm a free software activist. I write my code in the hope that it will be useful to others, but under the condition that it always remain free/libre. I would rather my software never be used at all than be incorporated into a proprietary program. In certain cases, depending on the community (e.g. Web), I recognize that my choice might certainly mean that nobody will use the software. If I choose the LGPL for something to permit its use in proprietary software, then it's a strategic choice.[0] I currently have no LGPL'd projects.
In a perfect environment without any means of coercion it would make sense. Nobody can be forced to release his source code if he wants to distribute binary. Anyone who wants to have source code is free not to use programs and their forks it if the source code is not provided.
The problem is that we live in a world with copyright and patent laws which allow someone not only to fork your source code and distribute it in binary form, but also to attach various restrictions to it and make governments impose those restrictions on you by means of force, literally. For example, they can prohibit reverse engineering or add some feature which you can't reproduce due to patents, place trademarks all over the place and add copyrighted art in case of games.
That is why less permissive licenses may make our world more free, as in reducing coercion. Apache-2.0 prevents patents abuse, but does not restrict new contributors. GPL not only grants patent license, but prevents others from abusing patents and copyright law. Thus, despite forcing attribution and releasing source code, it brings us closer to the perfect coercion-free world.
GPL cares about the users of the software, not only the developers, and makes sure that, if they receive some software, they also get the source.
Are most motorcyclists also mechanics? No. Do most motorcyclists care about the minor details of the inner parts of the motor, or scientific methods used within? No. Most just want a motorcycle that is cheap, function properly, and yet this specific motorcycle was strongly disliked and viewed as a trap. You could not repair it when it broke and you could not recover the investment by reselling it.
So say you are a non-developer and buying a e-reader with a bunch of DRM. The publisher go busts and you want to recover your investment. At that point you do care that you own a brick rather than some general purpose computer, but its to late. You are stuck in the trap.
At least? So the person already selflessly donated an open source library to the world, even if only usable if you comply with certain terms, and that's not enough? I frankly don't get this perspective at all.
Why not only let other people use it in their products, if they make their code available on the same basis as I released mine?
Code in itself isn't useful. You're not improving the world by writing code. You're improving the world with the impact that code can have and the value it can deliver.
But don't forget the LGPL, which lets GPL code to be used even inside proprietary one.
It may improve the world. From my perspective code that is built to extract value eventually attempts vendor lockin to create a long term revenue stream.
That is one freedom I support.
nah
> As a small P.S. to this, I think the middle ground is using the GPL for actual end-user applications, but leaving libraries and developer tools completely open with something like Apache-2.0 or MIT.
Thats closer. Non-reciprocal licenses are fine for projects that provide no value themselves. But for everything that provides direct value, reciprocal licenses like MPLv2 or GPL are better suited.
Freedoms to alter and redistribute... These are powerful things and very different from commercial considerations or "how much hassle it causes a developer". If you're coming at things from that point of view, GPL will rarely seem a good fit.
To me the issue with the GPL is that it is incredibly dated; it was designed for the time back when the users were more often than not a developer. Things change in 30 years and the GPL has completely failed to adapt IMO.
I see far more MIT and Apache than all version of the GPL these days, especially since I gave up on GNU/Linux distributions (and helping out working on them) on the desktop a few years ago.
Want code to be open forever, and for you and your contributors to not be taken commercial advantage of? GPL could be a good choice. Do you desire total world domination (for a new protocol, for instance) then go with something like MIT that allows both open and commercial implementations to interoperate easily, without a lot of license drama.
And yes, some people may "feel" as you say, that they only want to contribute to GPL projects. Sometimes for religious reasons, sometimes other reasons.
For my part, there are some kinds projects that I would not contribute to under MIT/BSD style license, because I would want my work to be available to some community without being taken advantage of. Certain pet hobbies of mine fall in that category. OTOH, there are many BSD license projects where I am happy to send a patch or two because I benefit from the ecosystem in numerous ways, including commercial support for said BSD software.
Wouldn't dogmatic be the more appropriate word choice?
Of course, if you have a more favourable view of religion than me, you might disagree.
Google's definitions of religion:
>the belief in and worship of a superhuman controlling power, especially a personal God or gods.
>a particular system of faith and worship
>a pursuit or interest to which someone ascribes supreme importance
and of dogmatic:
>inclined to lay down principles as incontrovertibly true
I think the most precise use of religion is in connection with faith or a core belief system and lifestyle (which some open source advocates certainly fit), while strong positions in a particular topic or narrow scope, e.g. the GPL, tend to be better described as dogmatic.
Which, reading back to the parent comment and the scope of the thread, I guess either could be used fairly appropriately.
A better place of where I think dogmatic would be the preferred wording would be in reference to tabs vs. spaces or vim vs emacs.
There are different concepts and types of freedom; collapsing them all into one singular concept is incredibly reductive and misleading. There is also the freedom of the users to take into account, which the GPL tries to guarantee. Why should only the freedom of the developer matter?
>and forgotten about the people that make the applications for the users
The freedom of the developers matters. But as any jurist or philosopher will tell you, freedom does not mean the freedom to do whatever you want. This was noted by Hegel as he described the freedom of the savage being a kind of unrefined freedom, restricted.
Your argument is similar to saying that we should think of the freedom for the people who want to take away the rights of others. Arguably they should not have that "freedom" at all. Your argument is a very poor one.
That sounds like the "if you can't sell yourself into slavery, then you're not free" line of reasoning.
And it sounds weird that you want anyone to be able to do stuff with your code, but you support people taking that freedom away from others.
I think this sums it up.
When I was younger, mostly hanging around on IRC servers and forums, coding just my own cool projects, I strongly believed in the GPL. All of my projects had it, and I wouldn't even dream of allowing someone to use my code without making their entire project open too.
That's the first type I think. The second type is the more HN-style professional programmer.
Now as I've grown up a little and interacted a lot more with the programming community, I've realised that the GPL licence just causes more pain and frustration to developers. If I want my source code under Apache-2.0, why should I have to change it to GPL just for you.
I want anyone to be able to do whatever they want to with my code. That includes developers wanting to create a proprietary application. Telling them they can't is not freedom.
I feel we've lost ourselves in the freedom of users and forgotten about the people that make the applications for the users.
---
Edit: As a small P.S. to this, I think the middle ground is using the GPL for actual end-user applications, but leaving libraries and developer tools completely open with something like Apache-2.0 or MIT.