> In the strange world of OccupyGPL, that's a “restriction”, I guess because it… restricts you from placing restrictions on someone else? But that's as silly as saying that outlawing slavery reduces freedom, because it takes away some people's freedom to own slaves. Hey, the analogy may be inflammatory, but the logic is the same, and it doesn't make sense in either case. The freedom to take away others' freedom is not a meaningful freedom to have — the proper word for that is not "freedom" but "power".
Where have I heard that before? Oh right, as usual, the FSF said this long ago:
"[O]ne so-called freedom that we do not advocate is the 'freedom to choose any license you want for software you write.' We reject this because it is really a form of power, not a freedom.
This oft overlooked distinction is crucial. Freedom is being able to make decisions that affect mainly you; power is being able to make decisions that affect others more than you.
...
We in the free software movement are not opposed to business, but we have seen what happens when a software business has the 'freedom' to impose arbitrary rules on the users of software.
...
We believe you should decide what to do with the software you use; however, that is not what today's law says. Current copyright law places us in the position of power over users of our code, whether we like it or not. The ethical response to this situation is to proclaim freedom for each user, just as the Bill of Rights was supposed to exercise government power by guaranteeing each citizen's freedoms. That is what the GNU General Public License is for: it puts you in control of your usage of the software while protecting you from others who would like to take control of your decisions."
"Making a program proprietary is an exercise of power." So is releasing source code and limiting what they can do with it. Or forcing them to do extra things (share source) if they do certain things (modify source).
Stallman believes that linking against a DLL constitutes a derived work that would be subject to the GPL's copyleft nature. The legal validity of that belief is unknown. You're free to call that freedom if you like. I'll be over here in a corner considering it an abuse of power.
"If we confuse power with freedom, we will fail to uphold real freedom." On that I do not disagree.
GPL and copyleft further a cause. It's primarily for increasing user freedom. User freedom isn't developer freedom. It's everyone's freedom, indirectly. You're free to disagree with its agenda. But recognize it as a cause.
Other causes seem to be respected or at least understood. No one, for instance, is surprised to see that save-the-whales advocates try to save the whales. They recognize their cause. They may disagree with their cause. They may question why it's a worthy cause. They may think it's a counterproductive cause. Maybe they ultimately love the taste of whale. They may disagree with semantics. That's inevitable. It isn't helpful, however, to exhibit (or feign) ignorance of the nature and motivations that would understand it as a cause. Unfortunately, that's a common habit when it comes to those who argue against GPL. GPL isn't for everyone. It's that simple. For developers who do feel that GPL speaks to their goals, I raise a glass. When possible, I use their software and develop in kind. Why? I agree with that cause.
> Stallman believes that linking against a DLL constitutes a derived work that would be subject to the GPL's copyleft nature.
Basic software dependencies, with few exceptions, are subject to GPL. Why would anyone expect otherwise?
> The freedom to study how the program works, and change it so it does your computing as you wish (freedom 1).
I actually can't do that with GPL code - not because my employer tells me not to but because I know that could get my employer into trouble.
With MIT/BSD you run the risk of someone taking the code and never contributing back. With GPL you run the risk of excluding people from the ability to participate.
There is no license that encompasses all rights and freedoms because it's probably impossible to create a set of rules that would encompass everyone. Our freedoms are strangely mutually exclusive in some ways. I think forrestthewoods issue with GPL is that it is toted at 'the' way to preserve freedom - where the truth is that it's the way to preserve one form of freedom. That's why I never, ever, say "freedom" when talking about GPL and rather always say "free as in beer."
> The freedom to study how the program works, and change it so it does your computing as you wish (freedom 1).
>>I actually can't do that with GPL code - not because my employer tells me
>>not to but because I know that could get my employer into trouble.
This is extremely loose and deceptive talk. That freedom is genuine and valuable. You are talking about something completely different, that has no bearing whatever on freedom 1.
The company I work for modifies and revises GPL'd code all the time. It causes us no problems whatsoever, because we don't release or distribute it. Instead we just use it internally for our own purposes. Nothing in the GPL restricts your use, abuse or modification of the code. It only restricts how you can go about sharing and distributing it.
> It only restricts how you can go about sharing and distributing it.
Let me clarify this: the GPL allows you to redistribute your modified version. It only mandates you give your users the same rights you were given, so that they too can study and modify and share their work.
You get to stand on the shoulders of giants (for free!), but you have no right to prevent others from doing the same.
"but you have no right to prevent others from doing the same"
That's not quite right. It's not you have no right to prevent others from doing the same. Neither GPL nor MIT let you stop other people from standing on the same shoulders you stood on. The difference is whether you must let people stand on your shoulders. GPL forces you to open your shoulders. MIT lets you choose to share your shoulders or not.
If you use a GPL ladder to get up, you are mandated to leave it in place so that others can do the same. With a MIT ladder you are free to pull it up behind you.
Now the latter may be more free in the absolutist sense, but it is a very antisocial kind of free. But then the corporate world has proven again and again that it will be very antisocial if it gets them a pound of flesh...
If you use a GPL ladder to get up and then climb even higher then you are mandated to not just leave the ladder but to extend as you continue to climb.
If you use an MIT ladder to get up then climb even higher then you have the choice to extend the ladder as you go or not. Or partially extend it in some places but not all. But there is literally nothing you can do to the original ladder. It's there for anyone else to use exactly as you used it and there's nothing you can do to stop them.
Fair point. You get the right to stand on the shoulders of giants, but you have no right to prevent others from standing on your shoulders as long as you are on the shoulders of giants.
Your use of "rights" is a little unclear. We all stand on the shoulders of giants in all things. Yet I most certainly have the right to prevent people from standing on my shoulders. I write proprietary code for video game entertainment so I regularly take advantage of that right.
The GPL license has the right to limit what freedoms I have as a developer if I choose to use code it covers. It limits the freedom of some people (developers) to protect the freedom of other people (consumers). I similarly have the right to choose a different license that prioritizes my freedoms of a developer over the freedoms of consumers.
And all of these things are possible due to the restriction of freedom over all of us as governed by copyright law.
You only have the right to prevent people from standing on your shoulders as long as the giants you are standing upon did not dictate the terms under which you get to enjoy the view. If they say that being generous is a condition to stand on their shoulders, those are the conditions.
The GPL limits your freedom of limiting the freedoms of others given by those who wrote the software your software depends upon. If you want to limit the freedoms of your users, you don't have the right to use software explicitly licensed to preserve those rights to limit them. If you want to do that, you either use software that was not made to preserve user freedoms, such as software licensed under BSD, Apache, or you write your own.
> And all of these things are possible due to the restriction of freedom over all of us as governed by copyright law.
> With GPL you run the risk of excluding people from the ability to participate.
Prohibiting actions and thus excluding people is the point of GPL and most licenses. GPL is a cause. I'll keep reiterating that point. To some people, "freedom" means a WTFPL license. To many GPL users, WTFPL would be antithetical to their pursuit of freedom. Freedom is abstract. Many people feel they must perpetuate certain underlying principles to embody any semblance of freedom. Paraphrasing the views of Free computing advocates: in a world where oppression is normal -- in this case, speaking of any inherent oppression in non-transparent boxes that comprise most of software and hardware today -- one tactic to break the cycle of abuse is by harnessing any available tools of the system (e.g. copyright law). There are various voluntary, peaceful strategies to promote freedom. That's one.
Freedom means many things to many people, understandably. To me, GPL does speak to a 'freedom' I want to increase. Personal freedoms of developers and companies [to do whatever they please] is only a secondary concern. Your employer is a secondary concern. Perpetuating transparency in computing is the primary concern.
But you only risk getting your employer into trouble because they're committed to releasing proprietary software. The FSF considers proprietary software evil; the GPL inconveniencing developers of such software is a central goal, not collateral damage.
Now, if the concern is that you can't modify a GPLed text editor or compiler or browser or other such tool at your workplace, that shouldn't be an issue. Unless you're releasing modified binaries from GPL code, you are under no obligation to distribute your changes to the source.
> Now, if the concern is that you can't modify a GPLed text editor [...]
That is indeed the issue. The concept is that I might read some algorithm or solution as a whole while working with the GPL code. This solution, even if not directly copied, might end up in the code of the proprietary (and patented) product.
If prosecuted in America, where the court is interpretive on new issues, this could result in trouble for my employer. Having no previous rulings to go by, there is no way to approximate the outcome of a case such as this and hence looking at GPL code could constitute a risk.
A good "inverted" example of this is when Oracle went after Google/Android for supposedly having copied a hashing function. The obvious question and defense is: common data structures have obvious hashing functions and there is a good likelihood of coming with identical or near-identical code, i.e. serendipity.[1] Even though there is no proof that the code was copied, the court ruled in favor of Oracle on the grounds of "structure, sequence and organization of an API is copyrightable."
How this applies to GPL code, from my situation, is uncertain. GPL has patent clauses, so it's really risky.
In that case you can't possibly read any code whatsoever.
Yet again the GPL does not restrict your freedoms. It just adds to them if you're in the pro-user freedom camp of software development and leaves you no worse off if you don't.
> In that case you can't possibly read any code whatsoever.
Hyperbole isn't really called for. I can read MIT/BSD because that has patent allowances.
I'm not saying that GPL is bad, I am saying that GPL serves different freedoms to MIT/BSD which in turn serves different freedoms to proprietary (which does have freedoms, e.g. liability).
There is no one size fits all solution to licensing and there will never be.
Without reading the code, how do you know you're not inadvertently reimplementing something the same way a GPL program does?
If you are truly concerned about this, the best way to avoid copyright complaints is to be aware of what's out there already and deliberately build a different implementation. I would argue that it is more beneficial -- from your point of view -- to read as much GPL code as possible.
Let's stipulate that this hashing scenario (I don't know much about it) is an example of a common algorithm that is the best way to solve a specific problem... it probably is. The only way in the US to defend that premise legally is to go to court. If the court decides against you, you have to lobby the legislature. Is the process convoluted and costly to the point of being broken? Probably, but this is how the the law comes to grips with changes in society, and there's really no alternative if you want to live and work in the light of day.
> This solution, even if not directly copied, might end up in the code of the proprietary (and patented) product.
I and many others are deeply opposed to proprietary and patented software. I (of course) understand you need resources to build software, but I think there are other ways to acquire those resources. The vast majority of software that people use is open source, free software (Firefox, Chrome, Nginx, Apache, Java, PHP, .NET, Linux, Android, MySQL), and this has been amazingly great for society (admittedly mostly rich, western society though). Can you imagine the cost of a browser if everyone had to license it and all the technologies contained therein? PNG, JPEG, GIF, SVG, SSL, JSON, XML, 2D rendering, font rendering and layout, hardware accelerated rendering, JavaScript, JavaScript interpretation & JIT, DOM processing, CSS application, user interface toolkits, video codecs, audio codecs, network protocol licenses, memory management algorithms, blah blah blah. By the time you were done, Firefox would cost $60 a copy - if you were lucky.
> Without reading the code, how do you know you're not inadvertently reimplementing something the same way a GPL program does?
Fair point. At the end of the day it's complex so I go for the simplest solution: avoid GPL code in any way possible.
> I and many others are deeply opposed to proprietary and patented software.
I'm starting to understand that from the responses, now. Although I work in proprietary, I try to look at software licensing from a more neutral standpoint - which might not be popular around here.
Please cite a single court case in which a engineers reading of source code has been used as proof of intentional infringement of a patent or copyright.
I hope you do not read newspapers, HN or other places which publish information about new technology. Newspapers seems much more dangerous than source code, as they often publish news about patented technology. Think of the risk that you inflict your company, as a single miss clicked link can cause ruin in a future patent case. Better to cut down on any contact with the outside world.
> Please cite a single court case in which a engineers reading of source code has been used as proof of intentional infringement of a patent or copyright.
It might help if you read the entire comment, instead of patronizing it after reading a single sentence. I did actually address that.
> Better to cut down on any contact with the outside world.
>> there is no way to approximate the outcome of a case such as this and hence looking at GPL code could constitute a risk.
contact with the outside world also constitute a risk, and there is no way to approximate the risk. Beware!
The Oracle vs Google case is not about google employees reading source code. They copied header files, which neither party denies. The case resolve around the question: Does copying header files constitute copyright infringement. Talking about reading source code in this context is FUD, likely from someone who has an agenda.
> GPL and copyleft further a cause. It's primarily for increasing user freedom.
I don't disagree that that's the intent of the GPL and copyleft; I'm not convinced that (once the pragmatic case for Free software was established), that it is the actual effect of the GPL and copyleft. User freedom is maximized by having the most software available under the least restrictive licenses; copyleft licenses add restrictions with the intent of using those restrictions to compel downstream developers to also release modifications as Free software. However, if there are already pragmatic benefits to releasing Free software, the marginal benefits of those additional restrictions in terms of actually promoting practical user freedom is reduced, while the additional restrictions are, themselves, restrictions that can limit the freedom of users.
> You're free to disagree with its agenda. But recognize it as a cause.
I can recognize it as being directed at serving a cause and still think it does so poorly.
> Basic software dependencies, with few exceptions, are subject to GPL. Why would anyone expect otherwise?
Because interoperation with something doesn't make it a derivative work requiring a copyright license usually (though, I suppose, that view of Stallman's is consistent with the still-on-appeal ruling on API copyrights in Oracle v. Google.)
You are hiding in a corner, seemingly without knowing why the theory exists or what it is. Strange as it might sound, but the theory behind GPL with linking was not made by Stallman.
Many years ago Steve Jobs asked Stallman if Apple could link some proprietary compiler software with the GPLed GCC. Stallman initially thought it seemed legal, but asked a lawyer whose expertise in law and legal theory naturally surpassed that of Stallman. The lawyer replied that a judge would look at the final product and ask if it was two separate programs, or whether it was "really" one program with differently labeled parts. This lawyer concluded that the product would most likely be seen as a single program in the eyes of a judge and jury, and thus create a single work, i.e. a derivative work, if Apple's proprietary compiler parts and GCC was combined.
This is the basis that forms the legal recommendation that FSF has made regarding copyright and linking. If someone believes that a judge/jury would act differently, they are perfectly free to test it in court. By now it is going to be almost 30 years of industry legal practice in dealing with the question, but in the legal question is as simple as stated above.
I'm not really an advocate for the GPL, but I think when people express this sentiment they are going out of their way to misunderstand things.
The 'limits' imposed by the GPL just limit people from reducing the freedoms provided to the code that is covered... So it limits your ability to use GPL code to reduce the freedoms of others.
In GPL-speak freedom means code transparency while you're defining freedom to mean something else (the ability to do whatever you want with code... including reducing GPL'd code transparency).
It sounds convoluted to try and explain this but to me it seems pretty simple and self-explanatory.
I honestly don't think it's simple. How can I possibly use GPL code to reduce anyone's freedom? By creating some derivative work? By doing so, I have not diminished your access to anything that already exists!
The way I understand it, the GPL guards against the possibility that some non-free derivative work will prove more popular, and so crowd out the free original - "to turn free software proprietary" as the FSF states it. This crowding-out may be a legitimate concern, but it's a subtle one: it's protecting code by preventing a certain class of competition, an act which may not be in the interest of users, who would probably welcome more choices.
I can draw an analogy to "poison pill" provisions: they protect the company from takeovers, but often work against the interest of shareholders.
> By doing so, I have not diminished your access to anything that already exists!
If you release it as proprietary, you have a license that says "You may not copy this program. Unauthorized copying will result in law suits". If someone get a copy of that program, how are they not restricted in their freedom to read, run, modify and share the program running on their computers?
As a developer, I do not wish to be a contributor software under such licenses. I will not support you with money or code. The only deal that I would accept is if we abolish copyright altogether, as then the restrictive license you want to use is void and null.
"I honestly don't think it's simple. How can I possibly use GPL code to reduce anyone's freedom? By creating some derivative work? By doing so, I have not diminished your access to anything that already exists!"
Suppose you were a farmer that left town for a week or two. In that time I came in, fed your chickens and then took all the resulting eggs.
How can the above be theft? I haven't diminished your access to anything you already owned!
I think the example appears to be in support of GPL. The farmer here compares to whoever releases GPL code and who feeds the chickens are the users of the GPL code. Am I wrong?
I have to avoid GPL and LGPL code like the plague because I have to release close-sourced commercial software for my employer, and look for BSD licensed code for my own software because I have to eat.
It's an interesting statement to make! I think both GPL and non-GPL have their merits and good/bad points, but I have worked hard on something and don't want to give it away. Stallman would likely steal the bread that I had taken to put on my table then.
Of course it's an exercise of power. Putting any license whatsoever on any piece of code is an exercise of power.
Stallman doesn't refrain from exercising power any more than he refrains from taking advantage of existing copyright law. He just tries to wield his weapons in a way that he thinks will further his ideals. You may, of course, disagree with his ideals, but that doesn't mean that he confuses power with freedom.
GPL requirements don't apply to just making modifications. They only apply when you publish the modifications for others to use. In other words, they have no effect on your freedom, they only serve to protect other's freedoms by restricting you from imposing non-free terms on those other recipients of your published code.
Admittedly, this does have a clearly negative side-effect: it causes incompatibilities in cases that otherwise would remain free. But even that is not the case for your own modifications you use yourself and don't publish.
Arguments about GPL vs permissive licenses are pretty much moot when so many companies are building SaaS software. Without the Affero extension, GPL is pretty much toothless to stop SaaS companies using your software without releasing their source code.
Personally, I think there should be an Affero LGPL since the abundance of permissively licensed code makes my day job so much more pleasant and I would be happy if everyone was forced to share their contributions. Though I will say that even AGPL seems like it has a hole where you simply expose whatever library you want to use as a network service, and you only have to release the wrapper.
But I'm a little confused by what the goals of the GPL license are besides a warm and fuzzy feeling that no-one is ripping them off though. Professional software developers outnumber volunteers by huge margins, most people working on open source code bases are getting paid to do it.
The ability of corporations to make use of open source is what funds most of the actual development. If you couldn't run proprietary software on Linux, it would probably not be getting any significant attention.
Hence my thoughts on LGPL being a superior license to actually making sure improvements see the light of day. GPL is simply a nonstarter for most companies since they're trying to build up a useful asset and are not willing to open source key bits of it (which are generally not technically interesting), but are more than happy to release improvements to infrastructure, since that's not their core business.
Is it just that the atmosphere has changed? When GPL was a more common license, it seems like they were really fighting the good fight, since companies weren't willing to release anything lest they give up some competitive advantage, whereas these days at least some code is being released.
> what the goals of the GPL license are besides a warm and fuzzy feeling that no-one is ripping them off
GPL ensures freedom for users of the software, not developers of the software -- a distinction that is missed every single time licensing is discussed. Developers that use the GPL are (hopefully consciously) making a choice to ensure software freedom for their users.
This article did a very good job of tackling this this from another perspective, by addressing the usual (and tired) argument that the GPL offers less freedom than more permissive licenses due to the share-alike clause. Limiting "power" to take away freedom is a nice way to put it.
Not to derail this discussion, but my personal opinion is that the GPL is a bit ahead of its time. With the marginal cost of software being nil, the path of least resistance is just to make software free. The problem is, someone still has to produce this software, and unless we hit post-scarcity, production is going to cost money [1]. So the GPL straddles an awkward tension between ideals and economic reality right now. This is in addition to the more overt goals of FSF/GNU in terms of privacy, control and self-determination, which RMS has proven to be quite prescient about.
[1] "In the long run, making programs free is a step toward the postscarcity world, where nobody will have to work very hard just to make a living. People will be free to devote themselves to activities that are fun, such as programming, after spending the necessary ten hours a week on required tasks such as legislation, family counseling, robot repair and asteroid prospecting. There will be no need to be able to make a living from programming."
Nearly every argument against the GPL is based on convenience or desirability for developers. I think in a lot of ways that's the primary split between the FSF free/OSI open source factions.
Reading the GNU manifesto was a lifechanger for me. Even though I've strayed (i.e. am employed producing proprietary software), I still believe the GNU project and the FSF are the most important things to ever happen to the computing world.
Or to put it a different way, the GPL don't distinguish between user and developer.
Frankly i have noticed a trend towards a more hard set distinction between the two as of late. The perfect example is the Google Chromebooks, and their "developer" switch.
Thing about that switch is that when flipped, in either direction, it will wipe the device clean. Thus going from user to developer or back becomes a very big deal.
This is very different from earlier personal computers, where one would often have some kind of programming language (usually a Basic variant) right at hand.
Thinking about it brings to mind the scene in Tron: Legacy when the main profess himself not a program, and the presenter declare him a user in a mocking tone.
I almost get the feel that "users" are considered no more than cattle, to be fleeced (or worse) ever so often for cash to keep the farmers (developers) happy.
And formulating it like that i find myself reminded of the claim about magazine subscriptions, that the reader is not the customer but the product. The real business of the magazines are that of selling ad space.
I wonder if the same mentality is seeping into the "app" and "cloud service" spheres.
And all this brings to mind the enclosure movement, that brought many a former small scale farmer to the cities to become a factory worker. This because what used to be common grazing land etc, had been privatized and fenced off.
> GPL is pretty much toothless to stop SaaS companies using your software
That's because the GPL doesn't restrict use. It is not an EULA.
(Of course, it has disclaimers related to use: by using the software, you agree with the liability disclaimers, but you don't have to agree with anything else just to be a user.)
Users are free not to share their modifications. Until you redistribute, modifications are basically a form of use.
This is in line with the GNU philosophy; Stallman certainly doesn't want you to feel that you're restricted from privately inspecting a program and altering it to suit your needs.
This ought to be easy to see. If I take a modified emacs, put it on a web server, and provide access to it via a terminal emulator in a web browser, I've effectively distributed it without actually distributing it. It's an end run around the GPL.
That doesn't have anything to do with my argument, which describes a scenario in which there is a user who took some program and adapted it to suit his or her needs, running on his or her own equipment.
In this situation, the program has additional users. However, they equipment doesn't belong to them. They are only visitors to someone else's private property. Even if they had the source to the modifications, they would not be able to make further modifications and put them into effect on your server, since they don't have administrative access.
There is no run around the GPL; the GPL is simply not applicable. It can't give people the right to tinker with your private property.
Never mind not having the GPL-granted rights: if the users are getting a free service, they don't even have any right to expect that it will continue. Tomorrow you might pull the plug on the server (perhaps forced to, due to economics) and that's that.
The issue here isn't whether or not there is a GPL violation. There clearly isn't; the GPL simply isn't applicable.
The issue here is that gullible users make uninformed choices such that they throw away freedoms. The "takes away your freedom" rhetoric therefore rings untrue. That's like saying a contract that you irresponsibly signed without reading it has "taken" your freedom away. Where is the personal accountability?
The only genuine freedom-related problem is that widespread use of anything creates pressure on people to become users, simply in order to interoperate with the majority. The naive lemmings who unknowingly give up their rights create pressure on others to knowingly do so. I certainly don't want to be coerced into signing up for some SaaS just because it has turned into the only way of doing business.
> We don't see any sensible way to address the SaaSS problem with license conditions on particular programs. Even to write a legal condition to distinguish between SaaSS use and non-SaaSS use would be a challenge, and if we had that, it is not clear what we would want to require in the SaaSS case. Thus, our solution to the problem of SaaSS is simple: refuse to use it.
> If a program is meant specifically and only for SaaSS, you shouldn't write it. But many programs are useful for a variety of kinds of services, including some that are SaaSS and some that are not. It's useful to write and release these programs so people can set up non-SaaSS services with them, and good to release them under the AGPL.
So it seems like they do see it as an issue, but not one they can really do anything about in terms of licensing.
Yes, just the other day I was thinking over licensing options and realized this was needed too. The common way around it is to just grant an exception like Mongo did with their driver. Also, the Java world has been granting a classpath exception to GPL for ages.
However, many people confuse AGPL for this non-existant Affero LGPL because they think that they can use an AGPL library in their proprietary code. I believe Mongo has contributed to this confusion but that ultimately the lack of this alternative license is mostly to blame.
Regarding the rest of your post I disagree but more words explaining the value of GPL have been written than code :) so I'll not address that.
I think the number of companies taking free software and making meaningful changes that they don't contribute back to the community is not that big at all, though I don't argue that some probably do exist.
Consider the overhead involved in maintaining and packaging your own code base while still including updates from origin. Wouldn't it be much easier to submit a merge request so that you could just apt-get install the package and not worry about your own custom branch, not to mention feedback on your change from a much wider audience who are familiar with that code base? And then there's the fact that you're exposing yourself to liability that, again, would be solved by that merge request. It just seems like a lot of the ones that do, do it out of ignorance rather than malice.
I don't disagree that companies need to build up assets, but I think for most companies including SaaS ones, those assets are systems which are comprised of unmodified FOSS software used in [sometimes not] innovative ways.
That may be the case now that FLOSS is worldwide renowed and people are starting to realize that private forks are costly, but it wasn't always so.
The GPL was instrumental in forcing people to behave when nobody knew what to do, and it has been so successful that now people expect the behaviour enforced by it even when using more permissive licenses.
> But I'm a little confused by what the goals of the GPL license are besides a warm and fuzzy feeling that no-one is ripping them off though.
To make sure open source developers aren't used as sharecroppers by companies that take their work, sell it for a profit, and don't release any improvements or allow anyone else to benefit from the fact the original work is open source.
>>but are more than happy to release improvements to infrastructure, since that's not their core business.
Without GPL companies choose what their `core business` is. I don't want to argue with a product vision manager what to release and what not the release - its much easier for me to remind them of the law.
> But I'm a little confused by what the goals of the GPL license are besides a warm and fuzzy feeling that no-one is ripping them off though.
To make sure open source developers aren't used as sharecroppers by companies that take their work, sell it for a profit, and don't release any improvements or allow anyone else to benefit from the fact the original work is open source.
For anybody reading Eridrus' comment, it's a bunch of non sequiturs that indicate no understanding of software licensing.
Rather than go through each sentence and point out why it's wrong myself, just read the GPL and a couple statements by Stallman first. Then as an exercise, read each sentence and point out why it's either wrong, or not even wrong.
As a developer, the GPL is useful when you want to ensure that people don't take your work and profit from it. So it's often useful when companies want to level the playing field, without allowing competitors to gain an advantage. A cynic might say it allows you to subsume the competition, and control the market (if you maintain control of development). This can make the GPL a "safer" license for companies to release code under in some situations.
The GPL is also useful if you have a political interest in moving the community as a whole toward open source software for everything.
BSD-like licenses are useful when you want to gain adoption above all else. So BSD-like (or dual licensing) can be useful for example for file format reference parsers, tools were you want to gain adoption by companies (perhaps to later provide consulting work).
As a user of software (not a developer/vendor of any kind). You probably don't care, as long as you can gain access to the sourcecode, so you can potentially get bugs fixed by a contractor. But the GPL protects users interests, so it may well be in your interest to support the use of the GPL on new projects.
I think what you mean is that it is useful when you want to ensure that people don't take your work and unfairly compete with you with it. Imagine this scenario: I spend $1m writing an embedded software development chain. This embedded system will do 90% of what everyone wants. My business model is to charge people for writing the code to make it do the other 10% that they want. Since everybody's 10% is likely quite different, it makes total economic sense for me to release the code under a free license in order to drive adoption of my tool set. There will always be more work for me to do and people willing to pay for that work.
But as a commercial entity I have a risk. The risk is that if I release my tool set under a free license, somebody else will pick it up and offer services as well -- competing with me. However, I wrote the damn thing, so I feel pretty comfortable that I can out compete other people. Even if some people take a slice of the pie, if I can get very high adoption by distributing for free (no cost), I will still be ahead of the game.
What I'm really concerned about is that somebody may make a proprietary change to my software and lock customers into their version. In this way, I've sunk $1m into the project and they may only invest $1k but be able to lock me out of my own market regardless of whether or not I'm a better programmer.
Although the GPL was not built with this in mind (I don't think) it is a very powerful reason for commercial entities to embrace the GPL. In fact my choice of example (embedded tool set) was not entirely random. See: http://www.oreilly.com/openbook/opensources/book/tiemans.htm...
As the article mentioned, the choice of free software license is really dependent upon the circumstance. Slowly big enterprises are waking up to the idea that free licenses allows them to create consortium like development endeavours with very low barriers. They tend to use them when trying to stake out territory and when adoption is more important the instant revenue. One day, I believe they will realize the the GPL allows them to take a step further -- to fuel adoption that sells services.
Yes, this is what I meant. I also had a specific example in mind. Here's the scenario:
You're a hardware vendor, you lead the market. The hardware you sell has also has a software component. You'd like to take software out of the equation while maintaining your lead in hardware.
So you release the software under a GPL license. Other hardware vendors can start using the software, but they gain no advantage over you.
With luck, because it's free and widely available, your GPL software becomes a de facto standard. You maintain some control over it's development. But overall software becomes less of a factor in purchasing, which is now based on hardware (which is what you wanted, perhaps because your hardware advantage is secure).
New entrants into the market will also find it difficult to compete with you on software. Eventually a foundation may form to develop the software (like Symbian for example). Such a foundation pools the resources of a number of vendors, making it even harder to compete on software.
> the GPL is useful when you want to ensure that people don't take your work and profit from it.
Huh? Are you saying you can't make a profit from gpl-ed code? Then why was it written to begin with? If company A can profit from it, then so can company B.
As far as licenses are concerned anyway. Time to market and network effects are probably much more important.
> Huh? Are you saying you can't make a profit from gpl-ed code? Then why was it written to begin with? If company A can profit from it, then so can company B.
I think selling GPL'd software is a difficult proposition yes. I don't think I know of any of any GPL projects which are sold for profit (unless there's some other value-add, in which case they are selling the value-add not the GPL'd software).
> As far as licenses are concerned anyway. Time to market and network effects are probably much more important.
In a limited view of software where you're only talking about websites you're possibly correct...
There are plenty of dual licensed codebases that make a profit with no additional value add (other than not having to respect the GPL.) For example, the popular C++ gui framework JUICE[1]
I cannot take any GPL code and put it into a product and sell the product without releasing the source.
As the source would have to be available, people could take the source and compile the software and then wouldn't have to pay me, so I could never make a profit.
It's why GPL and LGPL code is best (totally?) avoided in commercial closed-source products.
By the way, you always have the option of dual licensing your (A)GPL code, because the code is yours. You can AGPL your web app and make a deal with a company for a commercial license that will let them derive another web app from it without having to distribute changes. You can make deals with different clauses with different companies.
OccupyGPL previously complained that GPL wasn't really free because it imposed the burden of freedom on the business trying to sell a closed-source product who was hoping to use GPL or other Copyleft code.
> In the strange world of OccupyGPL, that’s a “restriction”, I guess because it… restricts you from placing restrictions on someone else? But that’s as silly as saying that outlawing slavery reduces freedom, because it takes away some people’s freedom to own slaves. Hey, the analogy may be inflammatory, but the logic is the same, and it doesn’t make sense in either case. The freedom to take away others’ freedom is not a meaningful freedom to have — the proper word for that is not “freedom” but “power”.
A more pragmatic way to put it is that it restricts you from using the code in the many real-life situations in which GPLing your entire program is simply not an option. The ideology behind the GPL is fundamentally utopian: it starts with a result - that users of software should have the freedoms to use, modify, share, etc. - and reverse engineers the rest of the world from there, including business models that are very different from the way most companies operated at the time of its creation and now, and which are not always practical. This isn't necessarily a bad thing, as it leads to a quite firm and well-defined set of principles, and can serve as a lighthouse for real businesses to try to navigate towards. But it means that individual developers often find themselves in situations where the GNU philosophy is irrelevant - while it's talking about the choice of whether to write free or proprietary software, or this blog post is considering marginal issues like the physical difficulty of distributing source code, they have, for various reasons, already found free software unacceptable as a premise, and are faced with the choice of what software to use. By virtue of their employment or business situation, they are not in the "club", and certain software only available to the "club" is therefore unavailable. From this standpoint, it's easy to see why the GPL feels like a restriction of freedom.
Sometimes the premise is more mutable than it originally seems. See "Why CLISP is under GPL"[1] (an email thread barely younger than I am at 22), the old Apple Objective-C thing, and probably a lot of other cases; or look at the case of the Linux kernel, where the utter technical dominance of a GPLed program over all alternatives in certain spaces (particularly embedded) has made a lot of companies who clearly want absolutely nothing to do with free software put up source release webpages. Such examples are often cited as benefits of the copyleft strategy, and rightly so. But for better or worse, they're the exception rather than the rule.
Businesses has been limited in a very pragmatic way from doing what they most would want to do: Take money from people. The way you can take money from people is extraordinary restrictive in society, limited to fair trades and agreements. They are restricted from applying a freedom of entrepreneurship that privateer and slavers enjoyed in 19th century, or mobsters during the early 20th century. Stealing, murder, slavery, and plunder are all restricted ways to reach profits.
One might wonder why more businesses succeed today with all those restrictions compared to the times when everyone was free. It almost seems that freedom is distinctly bad for everyone, and restrictions, harsh has they might be, benefits everyone. I think it might be correlated with the businesses desire to be protected, as a ship full of gold serves little purpose if it is all stolen by someone else.
Wow, that is insanely over the top and also pretty poorly written. I appreciate the irony of using a historically leftist image like the raised fist to promote what is essentially a pro-capitalist message ("Even if these people are companies who want to develop proprietary solutions. [sic] A company using your technology will increase the value of the project").
http://choosealicense.com/no-license/ neglects to cover liability, focusing only on permissions. While you may have a "right" not to put a license on your distributed work, you are open to liability if that work is implicated as a cause of some harm. A good chunk of the MIT license text is about liability, and it's ALL CAPS, which makes it 90% by weight.
Isn't this extremely US-centric? In my country, I can't even imagine someone suing (much less winning) for using a piece of software they got for free.
Well, the BSD and MIT licenses are named after institutions that are in the US of A. Many popular software licenses are American, and are based in American legal doctrine.
Liability related to something which was "free" makes a certain amount of sense. Something given away from free could be harmful. Just because the giver didn't take compensation doesn't mean it's not their fault.
Basically, when you give something for free, you're implicitly making a representation that the thing is good. If you don't make any disclaimers, then that representation is all there is. And so if that something you gave away causes harm, your representation now looks like a misrepresentation: you tricked someone into being harmed by your gift.
That's what I think is the general idea.
If your country doesn't have this sort of concept among its legal doctrines and statutes, that's kind of bad!
After viewing this link, I think RMS might not be seeing the big picture here. There isn't merely an attack on GCC, but rather an attack on Free Software itself.
HN has proven for the past few years that the valley is less in-tune with individual freedom than they are with corporate-compatible licenses. This has understandably created some disconnect and often friction between us. but regardless, stay with me on my reasoning.
within a three month window, we have seen:
* a downright (successful) coup by systemd, which is an RPC backdoor for proprietary corporate software to bypass GPL restrictions via trivial bits of LGPL'ed code, wrapped in the controversial plan to swallow the GNU toolchain whole.
* very real talks about (GPL'd) GCC being replaced by (BSD Licensed) LLVM, followed by the peanut gallery using this as an example of the inferior quality of the GPL.
* an outright attack on the GPL, using the slimiest sound bytes and half-truths, for not being corporate-compatible.
Call me a conspiracy theorist (Literally: one who has a proven hypothesis about a group of people working together to commit a crime), but in the eighteen years I've been running linux, I've never seen this large an effort to sway people from using Free Software before. And no, I haven't forgotten about SCO v. IBM[0], "Get The Facts" campaign, or Halloween Documents I and II[1].
It would be easy to make a case for Microsoft, still being run by Steve Ballmer[2], as the culprit. But Apple and Cisco (and Red Hat, post-CentOS purchase) are not very good players in the GPL sandbox, and we can't exactly rule them out. All I know is I see a pattern, and, Confirmation Bias notwithstanding, I'll keep talking about it if these sort of articles continue getting frontpaged on HN.
This site just reinforces my view that people are getting more insane and lazy, and to stick with releasing my own software under GPL...
It won't prevent anyone from "stealing" my code (e.g. incorporating it into their own code without giving any credits nor releasing their modifications to the public), but at least their conscience will make them feel a bit worse, which I believe OccupyGPL is a sign of.
I had my own share of rip offs when I generously released my SQL database server code under a more permissive license and as a consequence for multiple years students ripped it off for their own projects at one university I attended, and pretended they wrote it themselves...
Where have I heard that before? Oh right, as usual, the FSF said this long ago:
"[O]ne so-called freedom that we do not advocate is the 'freedom to choose any license you want for software you write.' We reject this because it is really a form of power, not a freedom.
This oft overlooked distinction is crucial. Freedom is being able to make decisions that affect mainly you; power is being able to make decisions that affect others more than you. ... We in the free software movement are not opposed to business, but we have seen what happens when a software business has the 'freedom' to impose arbitrary rules on the users of software. ... We believe you should decide what to do with the software you use; however, that is not what today's law says. Current copyright law places us in the position of power over users of our code, whether we like it or not. The ethical response to this situation is to proclaim freedom for each user, just as the Bill of Rights was supposed to exercise government power by guaranteeing each citizen's freedoms. That is what the GNU General Public License is for: it puts you in control of your usage of the software while protecting you from others who would like to take control of your decisions."
https://www.gnu.org/philosophy/freedom-or-power.html