My Personal Journey from MIT to GPL
drewdevault.com
drewdevault.com
If this means that they are going to repackage and sell the work, that is their prerogative. If that means a professor wants to put the work into their course and help to instruct a class with it, that is great too. It is nice to attempt to force people to play by the rules I like in order to try to enforce the actions that I see as best for the world, like sharing, etc. But at a certain point you just have to realize that there are differing points of view, that is just the way things go, and "progress" includes all of them.
This is really insightful, to me. Worth keeping in mind in today’s world.
Nazism is a viewpoint. Does progress include that?
I know I'm triggering Godwin's law here, but if you're literally saying that progress includes ALL viewpoints, you're really opening yourself up to including some really ridiculously outlandish ideals.
https://www.thestranger.com/slog/2018/06/19/27874178/godwins...
Flat-Earther-ism is a viewpoint.
Anti-vaxxer-ism is a viewpoint.
The GPL has that political nature : it makes you think about your own point of view and hence, the point of view of others. Figuring out if you want or need it by actually reading it is a super useful exercise.
That's definitely a valid PoV, but you just have to realize/accept that it may empower people who have power over you. I'm mostly talking about economic power here, but with the absurd expansion of lobbying, etc., this may extend to political power, cf. Turbotax[1].
Again: It's ultimately up to you, but for me... I don't want to give big conglomerates an inch if I can avoid it. Both as an individual and as a software-development business owner. (We do bespoke software, so "overly-permissive" licensing isn't really much of threat in that space -- from either perspective: There's no software that does what we provide, nor would what we provide do much for anyone else except our clients.)
I'm not sure if this is too controversial, but I think BSD (permissive for developers, maybe restrictive for users) vs. GPL (restrictive for developers, permissive for users) is very similar to the Paradox of Tolerance in a way.
[1] Who knows if they're using MIT/BSD licensed code, but I think it serves as a good example of the power of lobbying at least.
EDIT: I don't grammar so good.
Disprove that.
As a bonus point, leverage is exactly what you may be giving them by licensing with the BSD/MIT/... There's no guarantee that they'll gain leverage, but if they see and seize the opportunity then that's what they'll get.
EDIT: The APL 2.0 is kind of interesting here because it doesn't really do that much over BSD/MIT/... except for the patent grant thing. The patent thing actually brings it much closer to 'acceptable' for me, personally, because a lot of instances of conglomerates exercising their power has been through software patents.
Why did cockroach decide on their new business license?
[0] https://www.cockroachlabs.com/cockroachdb-community-license/
That's obviously bs, and that's what I was responding to.
Newtons Equations has also empowered the powerful for a while now but I think we are still happy that they are available for free for everyone without any limitations.
Create a better version? Sure. Make the better version closed? Sure.
But close it? No.
Same with math: once discovered and publish anyone can do anything with it.
Are you saying that Gravity is somehow biased toward powerful people?
Are you saying that refraction is somehow biased toward powerful people?
I'm left so confused by your comment. It's amazing -- hopefully in a good way!)
This is such a great positive way to reply, kudos
Even your framing of your market space projects a sense of power.
GPL actually doesn't protect you from your fear. The AGPL does, but I don't know much that uses that.
Corporate interests rarely align completely with your own, and this small difference can be very damaging to your interests. The GPL, while not perfect, alleviates some of the damage caused by this misalignment by ensuring that users remain in a position to address it.
I think "there isn't enough software under the GPL" is not a criticism of the GPL's effectiveness. If anything it supports the GPL as a method for ensuring user freedom.
This isn't about not wanting to "give back" to the community, companies using permissive licensed software are contributing back. It is about that the GPL is incompatible with the business model of all companies which are licensing (selling) the software they produce.
It very much boils down to tolerance, yeah. I've made the experience that in the communities where permissive licenses are common, there is much larger tolerance for proprietary software and services than in communities that revolve around GPL. I personally don't care much about GPL vs permissive per se, but I do care about the four freedoms and see copyleft as neccessary evil that's needed in some instances to prevent proprietary takeovers.
But the GPL itself is compatible with a capitalist society. In fact, GPL can be the basis for making money with FLOSS software, by offering non-GPL'd commercial licenses. All the GPL ensures that if you want to make a proprietary fork of the software, its original author has to be made part of the equation. Some people see it as a tool to achieve communism and I think they are misguided in the view that the goal is desireable. The open source software they create is nevertheless a valuable and worthy contribution to mankind. You can't just reject someone's work because of idiotic ideology. As long as they share this view and allow me to have a productive working relationship with them on the open source component, I'm fine.
No, not all. I don't even know why you'd assume so. I don't even see how you connect what I've said remotely to the left-right oversimplification of political opinions, let alone with one of those sides.
In my comment I was talking about communities and you replied with a comment about types of societies. For me a community is focused to one thing like idk a specific game or fan community of a book author, while a society encompasses all aspects of life for its members. So for me, a "type of society" is about a general way of living together, be it capitalism, feudalism, socialism, etc. I've thought you meant that but apparently you haven't so my comment doesn't apply to you, sorry :)
The idea is that the GPL empowers users to modify and distribute software rather than enforcing a particular structure of developers and users.
Of course the GPL is not a system of government, so these comparisons are mostly "in spirit". In reality, it's a clever hack to give power to users by abusing the capitalist copyright system (which has historically morphed into a tool for corporations to oppress users).
But the GPL is definitely not communist nor socialist because it has no relationship to government intervention at all (other than relying on copyright laws for its strength). Marx had no interest in governments.
Strawman. MIT/BSD is not restrictive for users.
When someone derives from my permissively-licensed code and doesn't share back with me? Not my problem, but theirs. They now have a legacy fork to refresh every so often at some non-trivial cost. If I'm maintaining a codebase for them to contribute, then they might be better off contributing. If my codebase is their secret sauce, well, good for them -- perhaps they should consider paying me to help them, and they are welcome to try, but it's not a requirement. It's all good.
Now, if I'm building a project to monetize, I might not open source the secret sauce. The GPL wouldn't help me there anymore than BSD/MIT. So, what good is the GPL to me?
But it is also in user's interests to look out for derivative works because that means users of those derivative programs get software that respects their software freedom. Proprietary derivatives of non-copylefted free software means software that doesn't respect a user's software freedom.
The main thing you're granting in choosing a permissive license is the right to deny others the right to enjoy future improvements to the code.
This is why in practice permissively licensed code is more successful in industry. Industries like to exercise the right to make proprietary improvements to open source code.
Can you give me some detail about how/when this happens? I was under the impression that you can sell support(or other ancillary services) for GPL'd code, but not for the code itself.
Of course, today you're probably not going to have a lot of luck selling something that your potential customer can just download from elsewhere for free. So, in practice, you're going to have to provide other services/benefits that go into a commercial product.
But there's nothing in the GPL that prohibits you from just selling a bunch of bits subject to the requirements of the license and calling it a day.
The FSF started out selling copies of tapes with Emacs on them, and then later whole CD collections of free software, including a mixture of GPL and non-GPL code. They even had a service for a number of years where for $5000 they would compile up a whole ton of software for whatever platform you were using, and send it to your business with t-shirts and manuals for the software.
Theoretically you can give away a copy of the code. In practice, people don't.
(Usually includd assets, i.e. images, are kept proprietary, and the thing is sold as an aggregation.)
The thing they're really selling is security updates and maintenance.
In the past, when the internet was slower and fewer people had access to it, it made more sense to sell CDs of GPL'd code.
Why is that a “right”?
Here's an example: you buy some embedded hardware for a personal project, but you find out that the toolchain for that chipset is a pile of proprietary blobs built on Clang and it only runs on Windows. If it were built on GCC, then the GPL would force them to make the source available and people could adapt/update/rebuild it as needed.
Making something MIT/public domain is free for one hop, from you to the next person. After that it can become even more restrictive and demanding than the GPL (i.e. proprietary binaries).
Keith Packard on this in 2015:
https://list.waikato.ac.nz/pipermail/wlug/2015-September/013...
> Keith made it clear he prefers GPL-style (copyleft/sharealike) licences to MIT/BSD style ones. Net contributors of code tend to prefer the former, while net consumers of code (those who don’t want to give back to the community) tend to favour the latter. In other words, freeloaders.
I think this is a really unfair statement - "net consumers of code ... freeloaders".
While there are surely plenty of users of code who are not contributing at all, and they would be freeloaders, the phrasing "net consumers" means that some of the consumers are contributing back code, just not as much as they consume.
I would wager that most end users are freeloaders (they never commit code back).
I would further wager that most developers are closer to end-users.
Finally, I would wager that the vast majority of developers who contribute code are net consumers, not producers.
To me, it's not so surprising that a few people who put in the most public effort sometimes feel bitter that others don't carry their weight.
This assumes that if the only option available to the embedded hardware company were the GPL, that they'd go with that option. (more likely, the product would never come to market)
In reality, releasing something under the GPL typically just ensures that it won't be used by businesses. This is a real bummer, because it means it is off-limits to me during my day-job.
I would love to try and convince my coworkers to write some Scheme, but the majority of that community uses the GPL, which makes it a bit of a non-starter.
Just to be very clear, neither the MIT nor GPL licenses prevent this.
I've never come across this with GPL code, but I've been a bit uncomfortable about reading Numerical Recipes too closely because their code is restrictively licensed.
This interpretation is very surprising to me. Could you point out what language in the GPL you're interpreting in this way?
What makes you believe otherwise?
I thought because you were responding to my post saying using GPL code in a class, that you were claiming professors couldn't use GPL code in classes (they can). But you weren't saying that--I misread.
(Small snippets are obviously not covered by copyright.)
Is this correct at all? Like if Microsoft accidentally included some gpl code in Windows, could they theoretically be required to open source it? Or would just have to stop distributing?
If it is a normal textbook with non-GPL code in it (which includes code taken from an MIT/BSD licenced source), then that's copyrighted, and using that code for anything else, commercial or not, would be copyright infringement.
If the code is taken from a GPL source, though, then at least the code in that book would have to be licenced under GPL as well, in which case you would be free to use it for commercial software, as long as it is licenced under GPL. The GPL does not forbid use in commercial software, it only forbids use in non-GPL software.
I don't think this is right. The copyright of the BSD/MIT licensed code remains with the original authors who should be attributed in the textbook (as per the license). Since these authors have permissively licensed their code you're free to use it in your own project (as long as you also include the original attribution). Copying other parts of the text book may be a copyright violation, however.
Some big company wants to use the silly little structured logging wrapper I wrote for SLF4J though? What do I care, go for it, it's a tool and your use of it has no ability to damage any use the community at large has for it.
This is untrue. It might appear obvious that it does, because in the first instance, everyone can take and use it however they want. But as soon as anyone relicenses the work, everyone else loses out.
There are also more complicated benefits to the programmer-users of GPL software that get lost in the process.
I don't think the situation is clear-cut, and too many factors are hard to quantify, but I don't think you can safely say that non-copyleft "enriches everyone."
That is the purpose of the GPL as well.
The GPL doesn't say that you have to be a free love hippie to use the software, in fact it says that everyone can use whatever.
What it does prescribe is that if you extract value from selling FOOS (not using, but distributing) you must play by the rules of FOOS. You can not sit on the sidelines and extract value without providing anything.
Nowhere does it say that you have to share my values. But if you sell my software you have to play by my rules, and that means contributing back.
Well, except the users.
Say EvilCompany takes the code, puts in in their buggy operating system, distributes it under a commercial license, and then you end up being prevented from fixing the code that you wrote.
Because that’s what happened to RMS, and that’s why we have the GPL.
It’s freedom; not for the author, and it’s not freedom for the developers or the vendors, it’s freedom for the users.
The FSF warns against using CC0 for software (see https://www.gnu.org/licenses/license-list.html#CC0 for the full comments): "For works of software it [CC0] is not recommended, as CC0 has a term expressly stating it does not grant you any patent licenses."
If you really want people to be free to use the software as they wish, you can't ignore software idea patents. That naivety actually works against the users as they would be lured into dealing with the software believing it to be free but then trapped by a patent infringement lawsuit.
> But at a certain point you just have to realize that there are > differing points of view, that is just the way things go, and > "progress" includes all of them.
No, this is too broadly accepting and not carefully discerning as reality requires to make sage judgments nor will it help us understand the ethical underpinnings of the software freedom movement (very much related to one of the major problems in the essay -- the author frames the issue around "open source", a developmental methodology which eschews ethics and is therefore of great use to proprietors. See https://digitalcitizen.info/2019/05/10/how-free-software-and... for more on this). Proprietary software is a "differing point of view" and your statement tries to get us to accept that it is merely another acceptable alternative among many. Seeing proprietary software as some form of social progress means accepting the inherent harm of proprietary software, the very reason why the free software movement was founded in the first place. I will call proprietary software harmful and in no way progress for anything worth defending. The goal isn't to maximize one's ability to have power over someone else, it's to ensure specific and well-identified freedoms for all. Strongly copylefted free software where license terms are defended does this.
I personally prefer the GPL way, but I have yet to use either license on code I've written.
Copyleft licenses grant freedom to the users of software: a developer cannot restrict a user.
It's also the freedom to make zero changes to the free code you were given, reuse it in your closed source software, and pass it off as your own.
In a way, I feel like I should be a big enough person to be okay with this, but I'm not. The possibility bothers me.
Yes, because of the GPL, they have to give RHEL customers the source to all their patches, but what difference does this make in practice?
they have to give RHEL customers the source to all their patches, and allow them to share it with the entire world.
In practice, that means everyone gets better software, and RedHat gets compensation for their hard work.
CentOS is the difference; it is one of the most widely used distributions has the same stability and longevity characteristics and gets security fixes just as fast as RHEL.
No, the MIT license requires attribution by including the original copyright notice with any distribution of the software. You can claim credit for the parts you build around it, but you can't claim to have written the MIT-licensed part.
One of the distinctions I like to draw strongly is between "nice" and "good". They are not the same, and at times, are actively at odds with each other.
It is certainly nice to give away your software to everybody, unconditionally, and not be bothered if your code does happen to end up being a fundamental component of some multi-billion-dollar company that gives you nothing.
But I'm less convinced that's necessarily good. In a world where you must live under the assumption there are bad actors, I think it's OK to put into your license that they can't necessarily do that. It is good to prevent the exploitation of anybody, and that goodness extends to preventing the exploitation of yourself, even if you also clearly have direct personal interests of your own.
I don't think "being comfortable with being exploited" is a component of "being a big person".
On the other hand, we often bring to mind mental examples of software where we slaved away for years and years to bring some unique new product to the world, only for it to be stolen by the big bad corporation for no compensation. My verbiage above about "exploitation" probably brought that to the reader's mind as the topic of discussion. If that happens, yeah, it's bad. On the other hand, that's not really the dominant case for software. There's a lot of open source put out there that's just a few day's work, which is still plenty valuable at scale, but if someone took one of these little things and incorporated it into their product, it's not really that big a deal.
I have several such small little things and they're all BSD. If a big corporation did somehow walk off with one of them, I'd legitimately be flattered, because I know that while it may have saved them a bit of time, it certainly isn't a core component of their product and had they needed to implement something themselves it would have been a trivial fraction of their time. I know I can say I'd be flattered because to some small extent, this really has happened, and I really was flattered and appreciative, so I'm not just hypothesizing about my future emotional states. I'm well aware on all levels that my ~two weeks total effort on the project in question, which I mostly did for my own purposes and for which the open source effort was essentially a bonus, doesn't entitle me to significant compensation for a product whose size is measured in person-decades.
In the context of the types of projects I was imagining, a company would likely just rewrite any code that wasn't available via MIT or similar. If I'm not getting anything in return either way, am I being exploited?
Logically, if the outcome is the same for me, there's no reason to make others redo work.
But as rare as it may be, there have been many cases where an open source code base really was "exploited" by any reasonable sense of the term, with corporations slapping their logos on it and reselling significant works in violation of the license, and those cases are significant because of their size, even if they are rare.
As a simplified example, consider Corporation G and Corporation P. One will eventually lose market share to the other, go bankrupt, and be replaced by Corporation R that bases its business practices on the more successful one (then the cycle repeats).
Both are evil, as corporations are wont to be, and in particular will never release anything under a less restrictive licence than they have to (so they will never release software under a MIT licence). However, G will release software under the GPL if this allows it to save work, whereas P will always release software under a proprietary licence, even if this forces it to expend more resources rewriting GPL functionality.
Releasing code under the GPL exerts a selection effect that favors G over P, and in the long run results in corporations that release somewhat more software period - and significantly more software under FOSS licences - than if P was not forced to redo work.
If you are a lawyer can you maybe be more clear about "more free" , more free relative to what? AFAIK GPL protects the user freedom and I think you are referring at the programmers freedom, GPL is a license that respects the users/society as a group, most people here are developers sothey will say that this is less free for them as an individual, less free to take freedom from others(the freedom to study,modify and distribute).
It’s fundamentally programmer freedom in either case. Any user freedom is an indirect side effect.
You need to think at the larger picture, compare Linux kernel and BSD and how the licenses affect the projects and all of the users. With Linux GPL prevents parasitic use, like you get Linux, put your proprietary thing on top, close it off and give it to some users, this users will have no freedom to know what the code they run does, no freedom to change it and distribute it. The fact that a user does not code is irrelevant because they ca always pay for others to modify things.
Maybe a bad analogy, GPL - I make knives and if you want to use my knives you have to agree not to use them to injure/kill people because this taking their freedom
BSD - you can do whatever you want with my knives, you can kill people I am fine with it because I care only about you my customer freedoms but not about any other people freedoms(lives). Just don't remove my name from the knife.
From what I can tell, the user's freedoms (assuming no changes) are pretty much the same. They can use the software without worry.
That is not the case with MIT, where any developer downstream may choose to re-license as they see fit.
From a user's perspective, the rights are very, very different. When you choose a copyleft license, you are making a specific choice that downstream users should have their rights protected, even if that comes at the expense of the "freedom" of downstream developers--who are now prevented from doing anything which restricts user freedom.
One tidbit on the GPLs: They require you to share alike if you share the software with others, but do not require you to share the software with others. You can make changes and larger programs entirely for your own or your company's internal use, and not share anything.
The GPLs mention this explicitly, and implement it using concepts like "distribute" and "convey". Your obligation to share alike doesn't kick in unless you distribute or convey.
That got GPL into trouble later on, when it turned out folks often ran software for others to use over networks, rather than sharing with users in copies for them to install locally. That led eventually to AGPL, a kind of fork of GPL, but outside FSF, also to licenses that simply require sharing back whether you distribute your work or not.
Software Licenses in Plain English https://tldrlegal.com/
(GP is the author - it contains some very good explanations on the subject of licenses, imho of course)
Yes.
> but outside FSF
Initially. The current version was published by the FSF in 2007.
aka the SaaS/cloud loophole
To me, GPL feels more like holding a legal gun to your head and say "You used my code, now play fair". It's not your Mum asking you nicely to share your toys with your brother. But then MIT is too far the other way where it's your Mum saying that if you don't want to give any toys to your brother even though he gave you a bunch then that's your ethical code and you have to live with it.
I wish there was a license that did feel like the "it's the right thing to do" argument without the threat, but I just don't know how you'd achieve that. Even something where you license the core as GPL and then the majority supporting libraries as MIT doesn't feel right to me.
As a lawyer, do you have any ideas along these lines?
It's more like "hi there, if you want to use my code, these are the terms under which I've made it available" than "you used my code, now play fair".
It kind of is antagonistic: GPL started when RMS wanted to fix his printer and Xerox said, "No." IIRC the printer software in question drew on or was based on his own prior work.
The GPL is a weapon to pre-emptively undermine sort of venal mentality RMS had already encountered. Free Software is a reaction to a kind of enclosure of the commons.
https://fsf.org/licensing/enforcement-principles https://sfconservancy.org/copyleft-compliance/principles.htm...
13. Remote Network Interaction; Use with the GNU General Public License.
Notwithstanding any other provision of this License, if you modify the Program, your modified version must prominently offer all users interacting with it remotely through a computer network (if your version supports such interaction) an opportunity to receive the Corresponding Source of your version by providing access to the Corresponding Source from a network server at no charge, through some standard or customary means of facilitating copying of software. This Corresponding Source shall include the Corresponding Source for any work covered by version 3 of the GNU General Public License that is incorporated pursuant to the following paragraph.
> That led eventually to AGPL, a kind of fork of GPL, but outside FSF, also to licenses that simply require sharing back whether you distribute your work or not.
...because I read it as "the AGPL requires sharing back whether you distribute your work or not", and felt like splitting hairs for the case where you expose the work, but only internally to a group.
Are there licenses that say if you run an altered copy, you have to contribute back sources, no matter who interacts with it?
That's true, insofar as providing as a service isn't "distributing", or in (A)GPLv3-speak, "conveying". See section 13 of AGPLv3: https://www.gnu.org/licenses/agpl-3.0.en.html#section13
Compare how the Open Software License handles network services: by requiring they be treated as "distribution". https://zoo.kemitchell.com/OSL-3.0#5
> Are there licenses that say if you run an altered copy, you have to contribute back sources, no matter who interacts with it?
For an older license of this type, have a look at RPL-1.5. For a newer one, which I led, have a look at Parity.
edit: it seems obvious that a doctor's obligations should be to the patient, then to medicine, then to the particular institution they work for. A lawyer should protect the client, protect the legal profession, then protect whatever firm they happen to work for.
Programmers should make sure that users have access to inspect the code that affects their lives; that other programmers can work with, learn from, and help the users to interpret that code; and that their company makes money. The only way that companies can accept being pushed to the third priority is by a united front of programmers who unambiguously swear to uphold the first two without compromise, and making what you do GPL is attaching an oath to that effect to everything you write.
What determines what's out there in the world, the decision to release source versus simply doesn't come down to "well I can use this GPL code as part of my project if I also GPL it, so I guess I'll share my code too." The decisions about whether to release code are made entirely independently of what libraries or code to reuse, and there's basically no code out there that's so special and unique that it could flip people one way or the other.
The decision to release code along with the software is made due to other considerations, so claiming that GPL results in more code access seems impossible to defend, to me.
There are many types of software project where the license doesn't matter at all - what matters is that the software exists. Someone is willing to pay to get it made, and they don't really give a hoot about "licensing". I believe this actually constitutes the majority of software - it's just invisible because no one really has much incentive to release it. But I don't really see how, say, a festival's business model is undermined by making their lineup app open source.
Next, there really is GPL code that's simply too special to ignore. One obvious example is the Linux operating system. Designing an embedded device? You're almost certainly using Linux. Maybe Linux doesn't do quite what you want - say, support for a given bit of hardware. Guess what, you can't ship your patch without publishing it - and now every Linux user gets to use that hardware, if someone's motivated enough to merge it into mainline. This is a real thing that happens all the time.
We're not there yet (and we may never get there if people stop believing in the GPL), but you can imagine that if we get a world where all the important software is GPL, the sheer mass of it will overwhelm any other licensing considerations. "You can either participate in our ecosystem, or you can rebuild modern computing from scratch. Your call."
Your hardware driver example is pretty much the only example I can find where somebody is actually incentivized to release code, and willing to go against other concerns; so I appreciate that example! However it's certainly not universal for all hardware, there's plenty of binary blob drivers out there on Linux unfortunately. GPL doesn't need to universally make all software open source for it to be more successful, so I think it's important to look for the concrete overall results.
Let's contrast GCC and Clang here. For years, advancements in open source tooling was hindered by GCC's refusal to make improvements that could potentially be used by closed source software. Clang comes along, and all of a sudden an entire open source, tinkerable compiler/tooling/editing environment opens up, precisely because both open source and not GPL. People are willing to pay to improve it because they have the freedom to do what they want with their improvements, including the freedom to hold them back.
Despite not having the stick of the GPL, MIT-style license resulted in a better ability to tinker with the code, expand it to more areas, and improve software.
I don't see GPL as a crucial aspect for getting to that world where we have access to the important bits.
My goal is to enable as much as can be done with software that also has source available. There's a different optimization goal, that says "let's make sure that all software out there has the source available." This is a drastically different goal, however, because it can be achieved by creating less software capability overall, and just eliminating all the growth in capability that originates first in proprietary software but then gets reimplemented as code-available software. IMHO, the GPL seems to be aiming for the "any software out there also has source available" goal.
There's a reason gcc became the best of breed compiler before llvm came along.
Take a look at imake and autoconf if you need convincing that the GPL is valuable.
Most people started with the BSD distribution (because networking), many later incorporated System V things from Bell. They then added their own changes and released the result under their own proprietary license. "They" being Sun Microsystems, IBM, HP, Silicon Graphics, and a host of smaller organizations including NeXT. Each of these had some really neat feature, like IBM's Journaled File System, SiliG's graphics, and Sun's hardware and the fact that they hired Berkeley's CSRG people. But they were all as incompatible as they could be made to be and still be Unixy. They were also business rivals and fought each other constantly. (I was part of IBM's effort with the "Open Software Foundation"'s DCE (https://en.wikipedia.org/wiki/Distributed_Computing_Environm...), which attempted to fight off Sun's lead with NFS.) This was at a time when Microsoft was pushing Windows on smaller machines and those smaller machines were getting powerful enough to be a threat in the Unix "workstation" market. As a result, Microsoft won the Unix wars.
Linux, in contrast, is under the GPL, as are most of its basic user-space programs. You can modify the code to add some feature, but you have to distribute the changes if you distribute the whole thing. As a result, your feature gets incorporated into the mainline kernel, or you fork Linux. Forked Linuxes don't get a lot of traction, though, in part because nobody has a serious hardware advantage, but mostly because the mainline quickly grows a corresponding feature. It's very hard to lock your customers in to your own distribution.
But unions generally exist to make their members rich. GPL has the opposite effect, it means you can't sell your code so you become poor.
It's like the opposite of a union; a collective agreement among a group of professionals whereby they mutually agree to prevent each other from making money.
Whether programmers sell their code or their time doesn't seem that important to me. (I've seen it work out both ways.) What is more important to me is what they're paid in. Personally, I like to get paid in money, because I can easily turn money into things like food and shelter. Because I like that, it's hard for me to hate on my employers - or anyone else's employers - for wanting money in exchange for software or SAAS or whatever.
From that perspective, a really devoted adherence to copyleft has always seemed kind of petulant to me. I don't want to begrudge anyone for the simple fact of trying to make a living any more than I want others begrudging me for the simple fact of trying to make a living.
I also don't begrudge people preferring to share their code under Free software licenses, mind. It's more that I take umbrage with thinking that choosing a license like MIT or BSD makes you some sort of capitalist patsy.
Also, point of pedantry: Simply owning exclusive rights to a particular piece of software does not give you a monopoly, and framing things in such hyperbolic terms does not do anything to advance the conversation.
The comment I replied to talked about programmers, and I was also talking about programmers, so ... where did I supposedly do that?
> Personally, I like to get paid in money, because I can easily turn money into things like food and shelter.
And how is that relevant to the question of licences? Do people who hire you to work on GPL software not pay you for your work?! What difference does it make to you in that situation whether the result of the hour of work that you are paid for is licenced under GPL or under a proprietary licencse?
> Also, point of pedantry: Simply owning exclusive rights to a particular piece of software does not give you a monopoly, and framing things in such hyperbolic terms does not do anything to advance the conversation.
OK, so, suppose you have worked for a few years on a proprietary code base, you know your way around it, you are an expert on that code base and how to extend and modify it. If your claim is true that the owner of that software does not have a monopoly on work on that software, please explain how you can use your expertise on that code base to earn money without working for or with the permission of the owner of that software?
Directly, not at all. But most companies find it very difficult to turn a profit on GPL-licensed software without resorting to things that render the whole thing moot, like being SAAS vendors who never "distribute" the software in the first place. The whole "derivative works" angle on the GPL, then, makes it hard for commercial vendors to make distributable software that relies on GPL packages without putting their own revenue stream at great peril.
So commercial software shops tend to build on MIT, BSD or Apache licensed stuff. Which is typically NBD. My experience has been that fears about "not contributing back" are typically unfounded. Everyone submits pull requests for their bugfixes and enhancements, because nobody wants to deal with maintaining some special snowflake private version of cURL or whatever.
Consequently, I think that the elephant in the room is that, typically, when people complain that there's something akin to a moral obligation to use GPL, what it's really about is fears that someone might make more money than they think is seemly by shipping closed-source software that relies on open-source components. Which, fine, if you don't like that, you do you and license the software however you want. But don't begrudge the rest of us for not being quite so worried about that.
As far as the whole ownership thing goes, I'd say it was pretty clearly implied in your first sentence:
> The programmer doesn't sell code, the programmer sells time writing software. With proprietary software, the owner of that software has a monopoly on the work on that software
That statement tacitly denies the existence of freelance software developers, by implying that all programmers are working for another company for some sort of salary or wage, and don't ever individually own code themselves. Which isn't quite true, and subtly frames things in a way that strips developers of their moral agency.
That's just not true in this generality. If you do custom commercial software for a customer's own use, using GPL code can work perfectly fine. The customer pays for the development work and gets the code under GPL. The customer in such cases often will get the source anyway, and it really doesn't matter whether it's GPL or proprietary.
> Consequently, I think that the elephant in the room is that, typically, when people complain that there's something akin to a moral obligation to use GPL, what it's really about is fears that someone might make more money than they think is seemly by shipping closed-source software that relies on open-source components.
As for myself, that is just not correct, and I don't really think it's a common sentiment. I care about my own and others' freedom to control their own computers and data. If you use my GPL code to make money, good for you.
> That statement tacitly denies the existence of freelance software developers, by implying that all programmers are working for another company for some sort of salary or wage, and don't ever individually own code themselves. Which isn't quite true, and subtly frames things in a way that strips developers of their moral agency.
Well, yeah, it's not quite true, but largely, it is, including for freelance developers. If you work on a customer's proprietary software project as a consultant or whatever, you normally don't get to keep the copyright either. You get paid whatever price was agreed upon and the customer gets to own the code.
Yes, if you do independent software development and you only licence your proprietary software to your customers, then the above does not apply to you.
This definitely isn't true.
If you're a doctor or a lawyer and you do something unethical, you go to a hearing of your peers, and they can punish you up to and including banning you from practice with some legal force. All we can do as programmers is attach what some of us feel are ethical standards to the works we personally create, and make adhering to those standards with regards to that software the price of using that software. The GPL gives that legal force.
That's also why I'm sympathetic to weird licenses that ban the military, or the evil. But personally, as a programmer, I'm more concerned about the harm that programmers do than harm in general, and I think it's long been clear that Stallman targeted the particular exploitation that programmers can profit from like a laser.
Unions also do that, but their primary purpose is to make their members rich, like you said. It's sad that in many jurisdictions in the US, unions bargained away (or legislators signed away) their right to strike on behalf of their customers, over objectionable externalities, or anything that wasn't a direct financial benefit to union members.
This is only sane if you think making money is unethical.
Choose the tool that accomplishes the job. Do you want to avoid commercial exploitation without repayment-in-kind in the form of contributing back? Use GPL or similar (although this is getting creaky in the case of SaaS deployments). Do you want total world domination for your new protocol? Release a reference implementation under MIT or similar.
License debates go off the rails because too often people try to compress a two-dimensional discussion (ideology and distribution rights) onto a single dimension and talk past each other.
So this blog post seems to say: "I have changed my religion." To which I say: "Consider choosing licenses more strategically."
When I look at RMS, I see someone who has thought deeply about the implications of various licenses, and has decided firmly what kind of projects are worthy of his time. He has an agenda, and acts upon it thoughtfully. Some of his followers are not nearly so thoughtful.
All I am saying here is this: before choosing a license, be clear in your own mind about your agenda.
GPL/AGPL + fee for exceptions seems like a reasonable model to promote freedom and fairness.
But your claim of what people should do is itself an ideological argument. Software creators have just as much right to choose their licenses for principled reasons as utilitarian ones. Heck, they could pick a license based on the number of contractions in the license text if they wanted. It's their software and their right to determine which reasons they care about most.
We are pretty much in agreement here. All I ask is that people think for themselves, rather than farming out that decision to that persuasive sloganeer they recently met.
Not sure this would be the right strategy in this case (assuming by world domination you mean your protocol gets maximal use). Because your protocol/impl could be forked into a closed variant with proprietary extensions, defeating the purpose of an open protocol. At which point you might be stuck maintaining the mundane, laborious base code, and others do the exciting stuff and take over your project (aka embrace-extend-extinguish). As has happened multiple times back in the last decade when we still saw value in using standardized protocols such as WebDav, XMPP, etc.
For these cases, FSF recommends LGPL instead.
Control over the evolution of a protocol isn't easy to bake into a license. It is probably better to look at tools like trademark where you can require passing compliance tests to fly a logo, for instance.
Again, be clear about your goals. Controlling the evolution of a protocol forever is different from launching and declaring victory once it takes on a life of its own. Both are legit, but require different tool kits.
I agree that the world would be better if all software was public domain and that the GPL is an inferior option.
In a world where proprietary software is the norm though, GPL is a way to fight back this trend.
I think GPL makes a lot of sense on software that make computers easier to use or that have privacy implications: browsers for instance.
Some other times, you just want to help the whole world, including the software industry, stop reinventing the wheel. Typically with a lib that solves a specific problem once and for all. There public domain or MIT/BSD make sense.
BTW even Richard Stallman agrees with you with respect to e.g. ogg vorbis libraries...
When I have published stuff in GPL, I would have had someone from (say) the Netherlands opening an issue asking "hey, can I use this library for doing so-and-so?". And I had to go and check so-and-so and check the again library and re-read the license and after I was not sure because I am not a lawyer and GPL text is fairly dense. Even if I was a lawyer, I would not be familiar with the legal requirements for someone from Netherlands.
One of the reasons I spend my free time doing open source is that I have fun. Reading legal text is the opposite of fun to me. So I moved to MIT. I did not have more of those legal questions.
Just tell them politely that the GPL is available for them to read and well documented, and to ask their lawyer if it's really important to them.
For a library, an MIT license is much more likely to get it adopted in a finished product that is accessible and maintained. A GPLed library can only get adopted in a GPLed project, which means there may be a ton of economic constraints that make the library's functionality inaccessible to anyone who doesn't have the time or expertise to build an entire application around it.
Also worth noting: to most ordinary people, GPL on a library is like a Post-It that says, "Free—take one!" on the door of a safe. It's nice to have permission, but it doesn't do much good if you don't know anyone who has the combination. The GPL-everywhere philosophy seems to assume a magical utopia where everyone is a skilled programmer fluent in multiple languages.
For finished products, though, an MIT license doesn't necessarily make sense, for the reasons lots of folks here have pointed out; namely, any big corp could compile the code unmodified, brand it, and sell it. If you want to make a complete application free and permissive for end users, GPL seems like the best way to guarantee that.
My observations are that:
* MIT license increases adoption of OS projects, increasing pool of potential contributors and derivative works
* People like sharing what they create, hence derivative works are likely to be shared with the world as well.
I know there are companies that utilize tons of free code without contributing enough back.
Overall to me the difference:
* MIT license increases throughput, hence increases participation in absolute terms
* GPL licenses limit throughout, but improves overall quality of participation
I believe in FOSS so much that I'm confident anyone smart enough will end up using it and contributing to it to some level. It might take a lot of time, but it'll happen. Companies not doing FOSS have a competing disadvantage in the long run.
Sure, not everything will be contributed back. And so what? It wouldn't have been anyway if the license terms had discouraged the use of FOSS in the first place. What matters to me it that /more/ is being contributed back.
Short version: part of much more > everything of much less.
So, I'm very fine with any non-FOSS reuse of FOSS projects. It directly increases the likehood of improvements to these projects and indirectly increases the likehood of improvements of FOSS in general, by making it more and more relevant in still-non-FOSS environments (the long tail of small FOSS projects is what makes it ubiquitous). Just don't ask me to use non-FOSS derivatives :)
Well said. A net win for FOSS.
The meme that the GPL is "less free" sounds very Orwellian.
What it really means is that I cannot freely use someone else's creation without restriction, and that I have to respect the wishes of the original author about how their work should be used.
That is because GPL was intended to be a hack on the copyright system (hence "copyleft"), but it always respected the idea of copyright - it does not call for the abolition of copyright.
This talk of GPL being "not free" smells of propaganda so that people (big corporations?) can reuse and repackage others' valuable work for free without any kind of compensation or acknowledgement. (TFA says the same thing)
Feel free not to use GPL'ed code if you find it too restrictive, but please don't contribute to spreading propaganda against it (and get off my lawn while you're at it)
[For the record, I work on proprietary software myself and haven't written any FOSS code, but I use GPL software daily - Linux, gcc, emacs etc]
When we have enough free software
At our call, hackers, at our call,
We'll kick out those dirty licenses
Ever more, hackers, ever more.I'm a fan of Drew's work, and also hope to help GPL projects such as Inkscape (I met many such developers at Libre Graphics Meeting). Choose the license that works best for you, and if you can articulate the reasons for your choice, as Drew has done here, even better.
If you understand freedom as the removal of social constraints, you won't understand the value of something like GPL software or Wikipedia.
If, on the other side, you think of freedom as the capability to do things, the accumulation of knowledge in copyleft projects creates possibilities that are less likely in a permissive project, where anyone can capture a version under a proprietary license at any time and evolve it as closed source (compare the ecosystems of Linux and Android for a practical example).
I don't think this analogy is strictly wrong, but the tone is insensitive enough that it is unlikely to be persuasive to the people you are trying to persuade. (Also, some will feel that it diminishes the gravity of actual slavery.)
I agree with your point, but I think you would be better off stating it in a different way.
I copied it here to deliver the basic idea as fast as I could, but it certainly is out of context as the starter of a calm conversation with more time to expose ideas and ponder them, as is the style of this forum.
Otherwise, the main effects of using the GPL are:
1) Projects that are actually open source but want to be available for closed source use will not use your code (maybe some people want this)
2) Lots of people who would contribute changes anyway will spend time figuring out what the GPL means in detail (it is not short)
3) Quite a few comanies will still use your code without releasing changes since they know that few projects try to enforce the GPL (or any other open source license)
4) It could potentially be helpful in a BSD lawsuit type situation, where companies that sue over copyright (or patents) will themselves violate the license of code that they use
I'm just saying keep in mind that a license does not automatically make people follow it and if you aren't willing to attempt to enfoce it legally then at least consider using a very short license.
https://fsf.org/licensing/enforcement-principles https://sfconservancy.org/copyleft-compliance/principles.htm...
You still see this usage restriction thread of licensing in Creative Commons for example with non-commercial and no-derivatives being common--even though CC has basically been unable to come up with a workable definition of NC in a decade of trying and ND runs completely counter to the whole idea of remixing that partly drove CC in the first place.
If your job is managing business risk, it's just not worth it.
Purpose of GPL is not to avoid profiting from other people's work. It's to give user's freedom to inspect, modify and re-use the software.
I now have a mental blacklist of GPL violators, that I bought or were given the HW of, that is useless, bugged, or otherwise crippled, and can't be updated and fixed, or used for new innovative things, because they failed to meet their obligations under the GPL.
The GPL is this, but I believe it is something else, too.
I believe that when you make your code GPL, you are saying to others who want to use your code, or especially to extend it and publish those changes, that you want to be paid. How?
In code.
You are basically saying "Yes, go ahead and have fun with this work, but - if you want to change it and pass it on to others, you need to put those changes out there for me and others to use."
Pay me for my work in code. Don't want to pay me in code? Then you don't get to use my code.
I think that's a completely fair bargain, and it also ensures that a company can't fork your code, go their own way, market it as a better solution to your users while they continue to extend it - to the point where their stuff no longer works with your stuff, even if it still looks identical.
Embrace, Extend, Extinguish?
Those words are often forgotten nowadays. And, while I give kudos to Microsoft's open source offerings and other recent gestures of similar merit, I cannot and will not forget their past, and I keep a wary eye on them just the same...
(I can, of course, take code and modify it for internal use and I don't have obligations under the GPL.)
Of course there is some ambiguity as there always is.
Obviously our clients (who got the sources) could have published them. But they have no incentive to do so.
In a way, it's similar to the paradox of tolerance, and a tolerant society needing to be intolerant of those that are intolerant.
Or to quote Team America: freedom isn't free.
I may be re-thinking my own use of BSD licensing in favour of something more copyleft in future too.
Political freedom I define as not being subject to violence unless you're attacking someone or stealing (material objects) from someone.
Metaphorical (software) freedom is being in control of your computer, that means: you run free software (you know what you're running) and you can use and distribute it freely. There is nothing inherently violent in closed source programs.
But that's not a very useful perspective; a well-functioning society filters violence so that it is only applied when things go seriously awry, and most of us should only ever threatened by minor inconveniences. To focus on violence is to be reductive; it is like trying to talk about programming in terms of electromagnetic laws -- yes, computers ultimately run on electricity, and social powers are ultimately enforced through violence, but the abstractions we've built atop those facts are actually very relevant and useful.
Political freedom is not simply about establishing when violence is appropriate. It's broader than that -- it's about the functional ways we can convert violence into something softer without abdicating our ability to govern ourselves effectively.
More to the point, closed source software doesn't need to be 'inherently violent' for it to cause problems. Nothing is inherently violent, and political freedoms are not defined by violence any more than computer programming is defined by electricity use.
If you care about “free software” as an ideological movement and only want to give your software to people who are, in exchange, willing to help advance it, then use copyleft.
I am sure that some copyleft fans will have different interpretations or motivations. I’m just giving mine :)
(This all applies to contributions done in an individual’s free time. Companies contributing to open source for strategic reasons might think about these decisions in different terms).
I want to live in a world where software, which plays an increasingly important role in our lives, can be modified by anyone. Imagine if only google could fix your plumbing
I've found that programmers tend to frame licenses in they way you have, placing emphasis on how the GPL affects them and describing the GPL as a way to enforce tit-for-tat but software is such an important part of everyone's life now that it's worth considering how licenses affect non-developers too.
That's the point people keep forgetting. GPL wasn't created to benefit developers, it was created to benefit end users.
Sure it does. Without open-source software to base their work on, Apple would have had to start from scratch and possibly never get the project into a usable state. (In fact, they did actually try several multiple times to replace Mac OS 9 with an in-house-developed OS, before eventually buying NeXT, whose OS was rebranded as OS X and ultimately became iOS).
It's really not about advancing ideologies but advancing your software. For software under with a Free license, the source code to any improvements someone else made to your software would have to be distributed along with it. Without it, they could keep any improvements they made to themselves.
So using a Free license provides a tangible, non-ideological benefit to your software, in so far as the source to any improvements will be distributed and can be integrated back in to it to make it better.
The one wrinkle is that the traditional GPL was not designed for situations where the software is never actually distributed -- ie. "web services"/SAAS and the like. In that case, even software under the traditional GPL that companies like, say, Google uses could be improved by them without having to distribute the source, as the software only runs on their servers and is never distributed anywhere.
This is where the AGPL comes in, and why Google forbids using AGPL software inhouse.
This is also why I license all my own software under the AGPL.
The political argument that gave birth to GNU/FSF seems to have lost it's bite in this day and age (perhaps due to a feeling that now open source is the de facto default, it will always be this way?)
The political goal was to give users absolute control over their computational environments. In reality, we have less and less control, because computations moved to the cloud (corporation-controlled servers) and the most used devices regressed to a non-hackable state (mobile gadgets).
Even if you use a Linux desktop with 100% open source software, you will still probably do a good part (and the most sensitive part) of your computations on someone else's computer, that you do not control. Open Source ended up making it easier for companies to build this new world, because it provided them with perhaps billions of man-hours of free effort.
The strategy of Open Source as a political movements made sense in the 1990s, but we need something new for 2019...
I'm a copyright abolitionist, so I think when you write a book, you can only "own" that physical copy. When someone reads that book, the words in the sequence that they read them are now part of their memory and autonomy of thought. And so on.
No, that was Free Software. Open Source was created as a reaction to that, with the goal of removing the ethical implications and making it "business friendly". And it succeeded, unfortunately.
See: "Why Open Source misses the point of Free Software"
https://www.gnu.org/philosophy/open-source-misses-the-point....
Since many are so uneducated about the difference, it is especially important to highlight this difference wherever one can.
Sort of. It's a bit more like a golden pact with teeth. You can get excommunicated for not following the pact you agreed to. I suppose that's fine. But I prefer not to tempt others to agree -- let them find their own way. Contributing helps the contributor by avoiding having to have local patches, and by getting them reputation and good will points. Sure, a big company might fork an MIT codebase forever and keep it closed, but that's OK with me.
I want everyone to get cryptographic code right, ideally with one implementation that is correct, and then that's the end of it for everyone. Because if commerical vendors do their own thing because of copyleft on a piece of cryptographic code, the one that really ends up suffering is all the users that didn't have a choice in the matter of using said commercial software.
As long as the company publishes any modifications to the library itself, they are free to use it, whether or not they open source their project.
I work on an open source system which is over 20 years old. For a long time it was GPL v2. We had to either go GPL v2+, which assumes the FSF will never go crazy, or stick with GPL v2, which is incompatible with v3, which causes various problems.
The GPL v2 and v3 are really strict compared to most other licenses, they don't really "play nice" with anything, including each other.
This is a rather common common misconception. If you use the "Version 2 of the GPL or any later version"-clause in your specific GPL licensing lingo, then any re-distributor may CHOOSE to distribute under GPLv3, or GPLv4 (if it ever exists), or, for that matter, also GPLv2. You're not bound to re-distribute under GPLv${latest} because of that phrase - so it is, in my pov, completely safe to go with the "or later"-clause. (But that also may be because I do trust the FSF to not "go crazy" in the forseeable future :))
The FSF is a tax-exempt 501(c)(3) charity; if it would institute policies to benefit a single for-profit entity, the inevitable IRS audit would be excruciatingly painful and likely result in jail time for directors.
Even once I started using Linux as my daily driver, however, it took a while still for the importance of free software to set in
I'd love to see hard metrics on enterprise Linux tech stacks; I would hazard to guess most business-critical FOSS is Apache/BSD, the latest Javascript framework is probably MIT, and most UNIX-philosophy FOSS (those with a "done" point) is GPL.
For "download and run" software, having it be GPL IMO doesn't limit too much who will ultimately be using your software. But if you are writing a programming library that would be used to create new software, GPL and even the LGPL will scare away a lot of commercial users, as well as projects that themselves hope to attract commercial users. If you don't care about commerical users, then it doesn't matter. But I think most people that write programming libraries care a lot about this.
I like others to have the same opportunity, so GPL it is, even for libraries.
BSD tends to fracture the community, and the community is generally even more important than the code, per se.
Funny. For me, the Golden Rule still leads me to the opposite conclusion: I want people to share their work with me open-handedly, without telling me what I can do with it or what other software I am allowed to combine it with. The more strings are attached, the less it feels like it's really sharing. The most annoying example of this is when companies open-source their works under a copyleft license in an obvious attempt to get free labor from the community while reserving the ability to actually profit from that work for themselves.
And therefore, when I share the software I work on, I prefer to share it open-handedly.
Similar to this, Qt has a LGPL license option, but when using it for a proprietary product, they really push you to buy their commercial license, and have basically no info on how to actually do LGPL compliance in the specific case of Qt's libs.
I get that it's not their responsibility to make it easy for me to use an open source lib in a closed source product, but it just feels like they're using LGPL compliance as a threat if you don't pay their license.
They also are providing a lot of value to the open-source communities building on Qt, so I don't think they are a great example for what GP mentioned.
[1] https://www.zdnet.com/article/its-mongodbs-turn-to-change-it...
There's a simpler way to address the problem outlined by OP: just refuse to consider binding software dependencies whose source you can't read. (It doesn't necessarily mean FOSS, as in I'm OK with paying to get the software; but I do want to be able to read the source code.) To me using such a dependency whose source code I can't read is just a non-starter.
That is restrictive on developers, but that's just the cost of doing business here. If you don't share those ideals, that you should be able to inspect and alter the source of the code you run, you will likely never "understand" GPL.
When I find some interesting looking project on github or elsewhere, I am always tempted to look at the code. However, if I notice that the code is licensed under GPL, I refrain to do so as I do not want to have to worry about finding some "cool trick" but not being able to use it later in my own code without fear of violating the license.
I do get why some people swear by the GPL license, and I respect their choice and commitment to what they see as the greater good. However, I see it as a barrier to those that simply desire to learn.
Now there are grey areas for sure, but my problem with the GPL is knowledge should be a commons, not a field day for lawyers and a creator of 'thought crimes'. Maybe I have misunderstood that regarding derivative works but it still seems by enforcing obligations GPL doesn't meet my personal definition of free.
But if you're just looking at some code and get some ideas and use them in a totally different kind of program, you're definitely not violating the spirit of copyright, and as far as I know no court has ever decided that you're violating the letter of copyright in such a case either.
But that's patents, we're talking about copyright here. You absolutely can't copyright an algorithm. And "not looking" doesn't protect you from a patent anyway, so go ahead and look at the code unless you want to write a functional clone and claim that it's in no way a derivative work.
In all the cases, where I not intend to include GPL code in my project, I consider it unethical and legally improper to look at it and then write my own version of such a functionality.
"Fun fact: the first time I used Linux was as a teenager, in order to get around the internet filtering software my parents had installed on our Windows PC at home. ↩"
I spend a lot of time and effort on my code, and I don't mind sharing it for free. I would prefer if other people tuned into that mindset rather than greedily raping the world for profit.
But adding more rules never seem to help, it always causes more division.
My current perspective is that its simply not my responsibility to push others into doing what I believe is the right thing.
Which is why g-fu [0] is released as MIT.
In the end, it will depend on the goals one wishes to accomplish. I tend to avoid certain licenses and scenarios. Most of the time I will favor MIT or ISC, but have been considering how to apply some things I've been working on.
This is a great article that's focused on just explaining why GPL is good. But I'm wondering what people think about enforcing this part of the GPL.
I was very disheartened to see the Linux community's and other GPL projects' attitude to enforcement actions brought by individuals.
If you ask people to contribute under the terms of the GPL, I think that it is fair for those contributions to be enforced. And unless a project has some kind of CLA that excludes it, the individual contributor should be able to hold violators to the copyleft portions of the license.
Can you share some examples of what's happened that's disheartening? I'm assuming based on context that the reaction to individuals enforcing GPL violations have been negative, which I would agree is disheartening. If you don't enforce the terms, the terms are valueless, and you might as well just use a more permissive license.
But setting the money aside, even the enforcement part was flamed by Torvalds and Greg KH [1]. The gist was that they're able to bring more people into compliance by working with companies behind the scenes. And lawsuits shut down all that backroom handholding. So ultimately, the lawsuits result in less compliance and less Linux adoption.
Linus mentions BusyBox specifically, where attempting to bring companies into compliance just led to fewer users and a shitty closed source alternative that these companies started using instead.
From Linus' perspective that's lose-lose: fewer users and more closed source software. But from people interested in GPL enforcement, they are more interested in not having their contributions abused by companies for profit. So if they won't give up their bad attitude, that's not the GPL projects' problem.
[0] https://lwn.net/Articles/635290/
[1] https://lists.linuxfoundation.org/pipermail/ksummit-discuss/...
If you're goal is to minimize the number of people using your work without following the agreed terms, it is worth it to shoo away non-compliant companies or companies that don't share the values of open source.
Like another poster said, why use GPL if you don't actually care that companies are violating the terms.
>Like another poster said, why use GPL if you don't actually care that companies are violating the terms.
Both of these are wrong according to Linux/GregKH. They both very deeply care about both those things and argue very convincingly that you get more of both of them by their strategy than with lawsuits. They cite very specific cases of that both in the kernel and in BusyBox, and the fact that the lawsuit was lost is further support of their argument.
And it's not even true that there's no downside to losing. You may get a precedent settled that actually invalidates enforcing the license. Then you've screwed up your own enforcement and everyone else's.
Which means the license is unenforcible and a new legally enforceable license is needed.
> Then you've screwed up your own enforcement and everyone else's
Nope, they would have been screwed already, they just didn’t know it yet. And fewer future people would end up screwed as new licenses would be created in the aftermath.
Untested enforceability is not better than tested and confirmed un-enforceability.
Or to use an absurd example in an even more absurd context, it’s better to open the box and know your cat is dead than to leave the box closed and believe it might still be alive.
(EDIT: I was wrong)
This is addressed by Linus directly and it's simply not true. That the license can be enforced without testing in court is evidenced by the fact that they are being able to enforce it without lawsuits. If you get a legal precedent that somehow says the opposite you are now deeply screwed. Courts are fickle beasts. You now get to spend a bunch of time/money trying to reverse that, or even worse, launch the worlds largest open-source relicensing effort. For the kernel that's basically impossible. You'd basically destroy copyleft completely.
https://sfconservancy.org/copyleft-compliance/vmware-lawsuit...
Some years earlier, there were lawsuits brought by Patrick McHardy, who contributed a non-trivial amount of networking code, that asked for monetary damages; these lawsuits were not supported by any organization.
https://sfconservancy.org/blog/2016/jul/19/patrick-mchardy-g...
From the perspective of the author of a piece of software wanting downstream changes contributed back, I think GPL makes total sense.
From the deontological perspective of a consumer that considers closed source code immoral (aka Stallman's view if I understand it correctly), it doesn't make much sense to me.
Consider the example where you go to a bakery and ask for a cake. Most people, I think, would agree that it would be unreasonable for a buyer of the cake to consider it immoral that the baker doesn't release the recipe to the cake. What makes software special?
Is all capitalism bad? I bought Alfred, Fantastical, Little Snitch and Better Touch Tool. I certainly feel my life has been enriched because of those tools. Does all enrichment have to be direct and linked, by say, bartering code or work? Such a binary representation of ideologies very conveniently forgets that humans operate on shades of gray. Crony capitalists need to be dealt with but that doesn't imply the system itself is shit. Even in a socialist system, the power gets concentrated somewhere and if you try to implement a flat organisation, a lot of projects slow to a crawl because everyone has different needs and expectations. And if I'm enriched, isn't the society also enriched? If paid software improves my productivity so that I can focus on more important tasks that help improve society, isn't that an indirect benefit? Does all "enrichment" have to be direct, linkable and traceable?
What license should I choose and why? I thought GPL or AGPL, but I really don't want to scare away individuals and small teams (who this software would help the most).
>The license must not restrict anyone from making use of the program in a specific field of endeavor. For example, it may not restrict the program from being used in a business, or from being used for genetic research.
From the FSF's "What is free software?" page[1]:
>A free program must be available for commercial use, commercial development, and commercial distribution.
Licenses like CockroachDB's with restrictions on commercial use are "source available", which is a form of proprietary software.
The dominant mode of commercial software development is closed. Many commercial firms forbid the use of copyleft software components that might compel licensing choices about company work.
Copyleft means the license leaves the right-to-copy for the user. But copyleft (AGPL, GPL, LGPL) means that you can't remove the copyleft itself even from the new parts, whereas permissive (Apache, MIT) means that you can.
edit: I mixed up weak copyleft and permissive :o
weak copyleft would be things like MPL, that limit the modifications you have to share to only parts of the program.
CockroachDBs new license isn't even Open Source following the common OSI definition of the term.
The term you're looking for is "permissive license". [1]
[1] https://en.wikipedia.org/wiki/Permissive_software_license
Let's put licenses for public software projects into three general categories: permissive, copyleft, and noncommercial. MIT is a classic permissive license. GPLv2 is a classic copyleft license. Prosperity (https://licensezero.com/licenses/prosperity) is a recent noncommercial license.
Heavily simplifying, and ignoring a lot of details and variations:
Permissive licenses allow you to do more or less whatever you please with the software, as long as you make sure that copies of the software you share with others come along with copies of the permissive license terms and the developer's copyright notices.
Copyleft licenses are permissive licenses plus one extra rule: In at least some circumstances, you have to share and license your own software work the same way. When you have to share, and what code you have to share, varies by specific copyleft license.
Noncommercial licenses are permissive licenses plus a different rule: You may not use the software for commercial purposes.
So what's the deal with developers releasing code under copyleft licenses, and then charging individual customers for "commercial licenses"? To understand that, we have to read the licenses in context. It's not just about what the licenses say, but about how that fits into the broader picture of the software industry.
Most companies producing software insist on keeping their software closed, rather than releasing it in the open. That way they can sell access and permission to use it. These companies will not share their work alike. So they intentionally avoid and reject software under copyleft licenses that would require them to do otherwise.
However, sometimes these firms really want to use software under a copyleft license in their products. If possible, they'll often try to buy a license from the developer that allows them to ignore the copyleft rule, so they can have it both ways.
Meanwhile, these firms often use tons and tons of permissively licensed software. They're free to do that, without paying anyone, so long as they follow the rules about copies of license terms and copyright notices.
Hopefully that gives you a broad picture to work from. Good luck with your project.
Writing a library and want maximum adoption? Use MIT.
Worried about patents? Use Apache.
Want to ensure the code stays open-source? Use GPL for an application or MPL for a library.
Obviously these are grossly oversimplified examples to make my point. But I wouldn't write a web application in C or a device driver in JavaScript. So why use the same license for all of your code?
The intuition that helped me understand this was noticing that the GPL is trying to maximize societal freedom, and in contrast the BSD is trying to maximize individual freedom. So, is the GPL less free than BSD? Answer: For whom? Single individuals or everyone together?
An analogy: a society would have more individual liberty if dogs were allowed to poop on the sidewalk, because fining dog owners who don't clean up after their dog is reducing the individual liberty of those dog owners.
But the society with this individual liberty curtailed is a better society.
The same distinction holds across politics in general -- we might approximately map GPL vs. BSD onto, say, socialist vs. libertarian.
This is the society I want to live in, and I think if you look at it pragmatically this is a society in which a lot of us already live (I have heard of very few cases where someone has actually been fined for not picking up their dog poop and I also see relatively little dog poop lying around).
e.g. https://slatestarcodex.com/2017/02/22/repost-the-non-liberta...
My argument was that these massive social structures are already the result of unprecedented levels of cooperation and their global influence and homogenization appear to be expanding. Are we at peak cooperation yet? Apparently not, some companies abuse the GPL and I still occasionally have to clean up other people's dog shit. And realistically there will probably always be a few "Mikes" somewhere polluting the lake for their personal profit, but I believe we are moving in the right direction and we will be able to reduce the freeloaders to a tolerable level as long as we continue to produce way more than we can possibly use. In the meantime I prefer to walk the walk, I'll continue to gift my extra time and energy to help others achieve their goals and I absolutely will spend an extra $50 on widgets if I find out Wanda is up to something shady.
I'm not against people who choose to use the GPL, I think it's an extremely clever legal hack, but I look forward to a world where people don't feel like they have to.
There are obviously some cases where humans work together really well -- times of conflict or disaster are probably a good example. But as society contains less scarcity, it seems like we move farther away from that massive cooperation, because there's no overriding need for it anymore.
Amusing point of view, when you realize that the largest GPL (or FOSS) projects (like the Linux Kernel for example) are developed and maintained by capitalistic corporations more than anything else - GNOME is developed/maintained by RedHat/IBM, Confluent develops Kafka, Facebook develops React, Google develops Android and Chromium, Dart, Go, Kubernetes, Tensorflow... the list goes on and on.
https://www.zdnet.com/article/minixs-creator-would-have-like...
I won't ever be GPL-ing anything going forward; two-clause BSD all the way.
> Generated by openring
https://git.sr.ht/~sircmpwn/openring
Nice.
We like to talk in favor of abstract ideals and moral arguments, but I think a lot of our underlying motivations come from our feelings towards (and relationships with) other people. If you see the world in this way (good socialist free software utopians vs. greedy capitalists) then all of the rest of the argument basically falls into place.
I'm not even saying that's right or wrong. I'm saying that no amount of abstract argument will convince someone out of their position if their underlying feeling towards other people is already firmly held. I'm including myself in this.
GPL needs enforcement which requires the force of law and loss of personal freedom. Perhaps I actually do agree with you after all then, but there's a second axis, Libertarian vs Authoritarian, where I think GPL requires Authoritarian enforcement?
Code is free vs orgs that make use of code in their products are free
What if someone doesn't want payment in labor, but instead wants some carrots? If they make a license that says, use my code, but send me carrots, is that worse than OP's insistence that he should get paid in the code of his users? And if asking for carrots is okay, then why not asking for cash, which is more fungible?
This isn't about morality. Everyone is seeking something ... even those that use BSD or MIT are seeking something. They are seeking recognition, or adoption of their protocol so they can build a symbiotic business, etc. True altruism exists, but it doesn't have a widespread impact. If altruism really did work like that, without a care for personal well being and on a large scale, then we would all be immigrating to a thriving Soviet Block right now, while the USA would be collapsing ... instead of the other way around.
No. You're not obligated to pay me back, you're obligated to share the code with the public. You can't exclude me, because I'm part of the public, but you don't have to have any contact with me at all.
Not with the general public, nor with you as the original author, but only with users of your GPL-derived software. This might be a technicality, since users can re-publish to the general public; but then I'm not sure since they aren't required to.
And while I'm incredibly sympathetic to companies who see Amazon and others (and disclosure, I work for Microsoft but my opinions are my own and I don't represent my employer) using their work to sell hosted versions of their products that directly compete/undercut/undermine their core businesses, that's also just a natural side-effect of using an OSS license in the first place. If you, as a business, are unable or unwilling to account for that possibility, perhaps you shouldn't have used that license to begin with. It seems unfair and wrong to attempt to relicense or reframe the rules after you have already benefited from the source used by others, which is why I look at things like Common Clause with disdain. Own that you are proprietary or GTFO, don't try to do this bullshit middle-ground approach, which doesn't do anything.
So in a SaaS situation, MIT vs GPL is irrelevant, and yet many of the renewal of licensing discussions are around those ideas.
My personal philosophy around open source has also shifted over the last decade or so, but it has largely cemented why I personally prefer BSD/MIT licenses. Having said that, although I prefer BSD/MIT licenses, I'm also of the opinion that in many cases, it is beneficial to everyone to contribute changes back to the main projects. Period.
I used to be much more in favor of proprietary software -- or, at least the right for a developer to choose to make some or all of their software proprietary. I still believe that -- because even though I would argue that open source is often a better development model, I'm not in favor of the FSF POV that deems all software must be free. True freedom means the ability to do things that are not in the interest of the public or maybe, even ultimately, the developer herself.
My position has changed insofar as I now think that the business case (and not just the moral/ethical case) for FOSS or OSS is stronger -- but I still feel strongly that aspects of the GPL make it overly cumbersome when releasing software. My feeling has always been, if I choose to make my code available, I'm making that choice -- I would like you to choose to contribute any changes back. It would probably be better for everyone if you did that -- but I don't want or need reciprocal access to any code you use alongside what I wrote, and I don't feel you're obligated to share any specific changes back with me. If I wanted to enforce that someone has to pay me for my work in order to potentially profit from it, I would need to make my work proprietary and sell it that way.
Look, if you want to contribute to the commons of programming, use a permissive license. If you want to cut out certain people who can't or don't want to use copyleft, use the GPL. If you can't stand the fact that someone might profit off of your work while you get nothing, don't publish anything.
Another good but seldomly given piece of advice: don't publish all your half-assed crap on Github. This is software pollution. Nobody wants to read the source code to such garbage as "stfupy3.org", but it will show up on search results regardless. No employer or potential client wants to sift through a list of trash to find the one good thing that you did that one time, that actually shows you know how to finish a program. Less is more!
How do you know? It could be exactly what I need for some esoteric reason!
Within the past year, I've found several useful projects on Github that their authors who appeared to consider them worthless.
---
Edit: As an example, I really wanted a simplistic dictionary app for my iPhone, which used the definitions built into iOS so it could work offline without taking up lots of storage space. Apps like this are explicitly against App Store guidelines.
After a chance search on Github, I came across this. Licensed under the WTFPL. https://github.com/forresty-archive/Dictionary
I'm not really a developer of any kind—I know basic Javascript—but I was able to figure out enough to get the app working on modern iOS, with modern fonts and such. The result was https://github.com/Wowfunhappy/Dictionary
Here's what really surprised me—I posted this to the /r/Jailbreak subreddit and I still get PM's once every other week thanking me for the app (which, I think I made quite clear, I didn't write). Apparently english language learners in particular find it very helpful.
Suffice to say, I'm really happy that "forresty", whoever they are, posted their rejected iOS app to Github.
No true scotsman wants to read that garbage.
> Within the past year, I've found several useful projects on Github that their authors who appeared to consider them worthless.
If the authors truly believed it was worthless, they wouldn't have expended the energy to publish it.
But that's not the point anyway. If you drown out your good work with all the crap you may have written over the years, your overall portfolio becomes weaker. In the arts, pretty much everyone knows this. In programming, apparently only the people that are hiring know this.
I would have thought my barely-tweaked fork was worthless to, and almost didn't share it, but I'm glad I did.
Also, since you're not even a professional developer, I'm not directing that advice at you.
I think your implicit assumption that most Github projects are created as a form of resumé building is incorrect.
If that doesn't apply or matter to you, that's fine. You can move right along.
In both cases there is competition from other solutions.
People can and do migrate away from Oracle all the time, and that does constrain the price.
Your other example is obviously not a monopoly since the supplier has no pricing power.
A monopoly occurs when competition is actively prevented, in spite of its ample competitive ability. The monopolist uses its power to block the entry of new competition, even if that competition has the product, know-how and so forth. In some cases monopolies are geographical, like utility companies. Another utility company is just as capable, but it and its wiring/plumbing is in another district.
The mere difficulty of mustering a viable competitive effort (e.g. it being difficult to write a replacement program that those 20 people are willing to use instead) is not a monopolistic entry barrier.
There's a slight but important difference between providing people what they want/need in exchange for money, vs. trying to make people give you maximum amount of money for minimum value provided. A lot of the problems attributed to capitalism are consequences of companies doing the latter rather than former. Instead of serving customers, they mine them. The current euphemism for that is "monetizing".
Of course there are good and bad parts, of course there are good and bad implementations/representations/manifestations of such big concepts.
For example using a price system and voluntary exchange is usually a great way to get clear signals about what people want and value. But if the market is in a pathological state (monopoly, oligopoly, or monopsony, high barriers to entry, etc.), then the market becomes exploitative. Is this the systems's fault? Well, maybe, but it's not because people can own equity/machines, it's because that particular system/market is fucked due to various reasons. (Either due to historic reasons, eg. enormous income inequality led to a small clique of people owning all/most of capital coupled with a political system that wasn't able to represent the capitally-disadvantaged; or due to other failure of politics - eg. a group consolidated power into a totalitarian system which then dismantled competition.)
What is the essence of capitalism? That private property protection extends to capital goods, they can be legally bundled up and sold and bought.
Does this have any inherent dynamic about concentration?
I don't see it.
Throughout our history we always had inequality. Maybe capitalism mirrors that. (Does it exacerbate it? I don't know. It usually allows for competition, which should force inefficient markets to turn into efficient ones - which would provide a niche for everybody, but of course there is nothing inherently there to guarantee this.)
So I have to agree with you, basic bitch capitalism is too vague and as such most of its implementations are bound to fail due to human nature.
http://www.decisionsciencenews.com/2017/06/19/counterintuiti...
Now, in capitalism, where exchanges can be influenced more by those who have more wealth to begin with, it's pretty obvious that it will naturally lead to extreme concentration of wealth. So I don't believe this question "screams for some quantitative analysis" but there you have it anyway.
The essence of capitalism is indeed the protection of private property and the resulting dynamics will lead to the aforementioned results. I don't know how you cannot see it.
As for inequality throughout history, it is actually a pretty recent phenomenon. Considering humans have been around for 100k+ years, and that we were all pretty equal up until around 6k years ago, inequality is very much an exception in history rather than a norm. And you can make a strong argument that inequality only really took place once humans became sedentary and started to implement a practice of private property.
This is also how I think about human nature. The "nature" of hoarding and greedily taking everything and leaving your fellow humans with barely enough to scrape by is not something we have always done. In fact, we only became so successful in nature originally due to our innate capacity for co-operation and our social behaviour and language. The fact that our "nature" for over 90% of our existence was very different to the brutality of capitalism that we see today goes to show that there is no fundamental "nature" that explains inequality. It is clearly a function of the current system rather than an inevitability resulting from the nature of its participants.
Capitalism is not about enriching anyone, it's about being free to do whatever you want with your resources.
Free software developers use their resources to enrich society (and I applaud their work). Mark Zuckerberg uses his resources to enrich himself. Both are being capitalistic, as long as they don't steal or kill (I'm sorry, Hans Reiser). They freely decide who to work for.
"Capitalism is an economic system based on the private ownership of the means of production and their operation for profit."
Classically free software works more like a gift economy: https://en.wikipedia.org/wiki/Gift_economy
No capitalist society ever worked without a state that enforces rules and social constructs (such as private property or contracts).
Simple example of how simply talking about (some abstract notion of) freedom misses this: A gift based (ideas) economy could work without a state enforcing copyright. A capitalist (ideas) economy requires a state enforcing copyright.
No. Copyright has nothing to do with capitalism. In a completely capitalistic system, there would be no intellectual "property".
If you read the founders of right libertarian (pure capitalist) thought, the whole system is based around freedom. And property is justified based on the fact that it's necessary for freedom. Intellectual "property" doesn't enhance freedom in any way, to the contrary.
Granted, Marx created the term 'capitalism' to refer to the private ownership, and he conveniently bonded that private ownership to for-profit operation. But there can be ownership that's not for profit, and libertarian theory considers owning things without operating them for profit a perfectly acceptable stance.
Marx doesn't say anything about copyright or intellectual property, as far as I know.
Some schools of thought use some weird notion of freedom to derive some abstract structure that has never been tried anywhere and claim it has some hypothetical properties. You want to call that "true capitalism".
I like theory, I do theory, but the post was talking about existing social systems within which we operate. Your private definition of "true capitalism" has nothing to do with that system.
Nor does it have anything to do with the accepted use of the term capitalism. E.g. in state capitalism [1]. Therefore it is a bad definition that hinders clear communication, and you have failed to convince me to use it.
Even though Wikipedia copyright is nominally owned by the respective writer of each individual edit, the fact that it's licensed as copyleft allow anyone to treat it as a public good an benefit from something that you don't own.
See a framework like the Universal Basic Assets (UBA)[1] manifesto: it distinguishes between Private assets, Public assets, and Open assets - each having different roles and expectations in relation to society and how each resource can be exploited.
Trying to reduce everything to XIX century economical and political concepts is limiting in terms of discourse; we have acquired much better understanding of society-wide dynamics since then.
Conflating real (material) property with false, intellectual "property" is one of the biggest lies that have been fed upon our society.
I approve the efforts of Creative Commons and other initiatives to get around the sick copyright system. But I don't believe in their premise of "commons" because it implies a dependence in a political system or society at large deeming things as commons.
IMHO the biggest lie of our society is not property about physical vs intellectual goods, but the ideology that applies the same concept of "property" to the gadgets you can keep in your pocket and you can keep control personaly, and equate it to the large multinational company encompassing the work of thousands of people on several continents. They simply don't have the same behavior nor expectations, and yet somehow we're supposed to apply the same legal framework - in order to uphold the decisions made by the few people who are in control of the large organisation.
How does he pay his rent? Where does the money come from? Is he a software professional?
If so, then this is what people mean when they say the GPL is a "general public virus".
And I "starve to death and die" because yes, in this world you can't just take things that other people have made and use them in whatever way you like -- if you can't obey the terms that someone else has given for the use of their creative work, then don't use their work.
Yes I agree, but the conclusion to this is that you probably should never use the GPL.
If you want other people to be able to use your code, use the MIT license.
If you want to monetize your code/keep it secret/sell it, then don't try to open-source it.
The GPL makes code radioactive and useless to everyone.
I get the intent in the OP that people should obey the golden rule and only build open source on open source. But what actually happens in my limited experience is that when a company comes across GPL code, the boss asks you to find equivalent code with an MIT license and ditch the GPL code.
If no such MIT code exists, the boss asks you to find another way, or to rewrite the GPL code yourself and keep it secret, or maybe even release it as MIT code.
GPL code is a dead end because it poisons other code.
And the fundamental reason for this is that programmers have to get money somehow, which almost always means being able to have some of the code they write as closed-source.
MIT allows closed and open source to exist side-by-side. You can write some code that does something, release it under the MIT license on GitHub, and also use it as a component of your company's proprietary product which ultimately pays for you to eat and live.
And this problem recurses. If I am not in a corporate setting and I am choosing between a GPL library or an equivalent MIT library to use in my own open source application, I should choose the MIT one because otherwise my open source code becomes "infected" with GPL, meaning that people in a corporate setting can't use it. If I'm deciding which library to learn as a hobby I should choose the MIT one because that will be useful for getting a job. Etc.
GPL will IMO be radioactive for as long as we insist that most programmers have to sell something in order to have a house to live in and food on the table. If the rest of society sets up a big fund to hand out money to programmers who make useful software, then we can talk about GPL.
But actually even if such a fund existed I still think MIT would be better.
As a user, I prefer GPL's activist stance, rather than MIT license's non-activist approach which essentially translates to an ethics of "might is right".
OK, that's nice but can these people explain to me how I should pay rent?
So yes, I agree with you that you need to obey the terms someone else has used for their work, or else you shouldn't use the work -- but your analogy with regards to a film or a book isn't accurate.
I have seen this in real life a few times. Usually something gets released under the GPL and then the authors ask for $ to hand it out with a commercial license on a case-by-case basis.
But in practice it is difficult to negotiate a truly fair price if the market is somewhat thin and the size of the code is relatively small. I've seen this for ML datasets for example, collected using taxpayers' money and the author wants $50k per license to allow a company to use it. But that $50k represents what the author thinks they can get away with, not the true value of the dataset to your algorithm. In reality companies (in my experience) stay away from this, and for good reason.
In cases like this I definitely wish GPL didn't exist, because if the academics who made the dataset had to choose between MIT or secret/proprietary, they would not be able to get away with Keeping their taxpayer funded dataset secret. (Because then taxpayers would be like "yo, wtf are we paying you for?").
One reason open source is good is that code markets just don't seem to work very well. But the good kind of open source is MIT licensed code.
That is how the market works, right? The price of something is set not by the "value" but by what the seller can get. Researchers "get away" with keeping their data proprietary all the time.
NO. GPL mentions no where about 10 being the minimum # of lines. All it says is that if your work is a "derivative" of the GPL code, then it must be GPL'd. Courts will determine whether including 10 lines of GPL code make your product derivative or not. The assumption is that a reasonable criteria will be evolved to determine when is something derivative and when it isn't.
OK but in reality that means the cost of including those 10 lines is that you are exposing yourself to an unknown amount of legal risk, and our legal system has a highly nonlinear penalty system, so it's basically as if the 10 lines infect your whole codebase with GPL.
To reduce the risk, you can go through how courts have interpreted and applied the definition of what a "derivative" work is.
Right, so the correct conclusion is to never use, never contribute to and never write GPL-licensed software. Then you comply 100% with GPL, you have no legal risk and you also have money to pay for your Gatorade.
In fact the best solution would just be to completely rid ourselves of GPL?
If you copy anyone's work you need permission because copyright is automatically assigned and without it you are violating the law.
Copyrighted code is fairly simple to understand - you make something, you own it. Alice makes something, Alice owns it.
I don't really have a problem with this kind of code existing, and I think that we have very clearly seen that open source with a permissive license is capable of "beating" secret or copyrighted code.
It depends on how you "use" GPL'd software. You _can_ run proprietary software on Linux. Clearly, using GPL'd and proprietary software together is legally possible.
> never contribute to
If simply contributing to projects licensed under GPL were such a huge problem, we would have industry-wide blacklists for employment. Contributing to _some_ projects can be a problem for _some_ positions but generally you are in the clear.
> never write GPL-licensed software
You, as the author, have the right to relicense code you have written yourself. GPL'ing your own code doesn't increase your legal risks.
So no, the correct conclusion is not "to never use, never contribute to and never write GPL-licensed software" and the best solution is not to "completely rid ourselves of GPL". I'm not even sure what the problem you are trying to solve is. People can and do profit off GPL'd code. It is not an instant death sentence like you seem to imply.
how?
Of course, then there's patents. You might want to avoid having any ideas at all.
What's supposed to be the difference here?
The difference is that GPL is claiming to not be proprietary...
No. The 9990 lines remain under whatever license you desire. The 10 lines remain GPL. You can't distribute the whole work.
> And then the whole 10,000 becomes public property according to the GPL
The GPL doesn't make software "public property", whatever you think that entails.
> so the person who wrote the 9,990 lines of proprietary code starves to death and dies because you can't monetize public property,
No capable programmers starve to death, or even earn poorly because of the GPL. Approximately 90% of programming work is in-house development.
> because you can't monetize public property,
I don't know what this means; the GPL isn't about commercial software but proprietary software.
>and our food system only accepts money in exchange for food, not "good deeds" or whatever?
Again, I don't know what this means or what money (or even food), have to do with anything.
>If so, then this is what people mean when they say the GPL is a "general public virus".
If so, they are woefully misinformed and shouldn't be writing any sort of detraction lightly disguised as a very poor analysis online when the GPL is being discussed.
> No. The 9990 lines remain under whatever license you desire. The 10 lines remain GPL. You can't distribute the whole work.
It would be more accurate to say that if you distribute a combined / derivative work that incorporates those 10 lines of GPL code, you have to do so under the terms of the GPL. To do otherwise is copyright infringement of the GPL code.