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?
http://www.wired.com/2015/07/hackers-remotely-kill-jeep-highway/
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.
...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.
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.
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.
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 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.
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?
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.
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.
In fact I think it's a false distinction.
At one time they were very often the same thing
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 have the impression that most anti-GPL sentiment comes from developers who claim their role as something more precious than the role of the users.
So next time another company promotes "freedom" and "open source" let's make sure it actually directly benefits the user.
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.
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.
Is there any evidence of this?
See "Working with the LLVM community": http://llvm.org/devmtg/2013-11/slides/Robinson-PS4Toolchain....
* 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.
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.
[1] http://llvm.org/pubs/2004-01-30-CGO-LLVM.html Read full paper not just the abstract to get the full picture.
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.
> 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.
And the reason I switched was because Clang had better error messages.
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.
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.
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. ;)
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.
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.
For a true picture, look at how well their open sourced Darwin OS project is doing in terms of update and support.
Apple gutted the FreeBSD core team back in the 90s, hiring them all away.
But fairly similar userland.
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.
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.
https://www.phoronix.com/scan.php?page=article&item=clang-gc...
Show gcc and clang to be broadly competitive without a clear winner in terms of speed of execution.
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.
http://www.phoronix.com/scan.php?page=news_item&px=MTU4MzE
That clang is not GPL is more an accident of history than a preference of licenses:
https://lists.gnu.org/archive/html/emacs-devel/2015-02/msg00...
Companies may try to avoid GPL but only if they have another, viable choice.
Sure, and my point was to answer the parent about what freedom does the GPL grant to the users.
Your point is interesting, but is totally besides what I was saying, or the parent.
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?
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.
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.
"indeed there are multiple proprietary compilers and utilities built on top of LLVM—including Apple's Xcode and NVIDIA's CUDA compiler."
https://lwn.net/Articles/582697/
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. """
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.
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.
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.
> 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.
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.
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."
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.
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.
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.
Yes, it does. Because of copyleft reciprocity, all users benefit from modified and enhanced copies to the software.
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.
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.
So, without Apple products? I don't think so. Far from it.
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.
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.
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.
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.
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.
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.
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 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.
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.
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.
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...
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.
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.
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.
"Readline is free software, distributed under the terms of the GNU General Public License, version 3" -- https://cnswww.cns.cwru.edu/php/chet/readline/rltop.html#Int...
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.
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.
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.
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.
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.
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.
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.)
Chapter 1
For Want of a Printer
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.
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.
So how did that work out? As far as I know, there are pretty much no printer manufacturers who open source their drivers.
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.
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.
He was an academic.
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.
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.
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.
> 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.
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.
[1] http://www.jbkempf.com/blog/post/2012/I-did-it [2] https://archive.fosdem.org/2015/schedule/event/appstores/
>Unlike a lot of large open source projects, authors of VLC keep all their rights on their code, even if the code is minimal.
http://www.jbkempf.com/blog/post/2012/How-to-properly-relice...
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.
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.
If you don't want your software to be used on that platform that's your choice, but pretending its about "user rights" is ridiculous.
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...
And yet, the whole iOS environment uses several permissive licensed software. This is a very good example how they damage user freedom, thank you.
https://www.fsf.org/blogs/licensing/more-about-the-app-store...
Here's a more recent release, still urging people to avoid Apple.
https://www.fsf.org/blogs/community/watch-your-freedom-becau...
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.
(quotes pulled from https://www.fsf.org/blogs/licensing/more-about-the-app-store...)
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.
Didn't you just basically say the same thing? The GPL forbids distribution under the App Store ToS, no?
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.
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]
And I agree pretty much with the latter.
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.
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.
"the power or right to act, speak, or think as one wants without hindrance or restraint."
Now you tell me which of these licenses are closer to the definition.
Thank you in advance.
Here's a little haiku by RMS:
Using GPL
is encroaching on our rights
to encroach on yours
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.
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. :)
They just can't release binaries without the source, as they would be preventing other people from doing anything they want with it.
Arguing against that on the basis of freedom is hypocritical.
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?
Might as well monetize them.
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.
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.
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.
It'd be stupid not to hang onto that data.