We've heard a lot about how inflexible or even terrible GNU/GPL is lately. Whether you agree or not, I think it is important to remember that we would probably be living in a very different world technology-wise if it wasn't for GNU & GPL.
In other words, open source in general, even including popularity of other licenses, would not have spread and become so popular if GNU and GPL wasn't there as an extreme, far out example. For those younger here, sharing software by big companies (Microsoft, Google, Facebook etc) was pretty radical and unheard of back in the day. Now they all share so much of their code which is great.
Honestly, I don't understand the hate for GPL. Someone spends time and energy making something, and releases it for free, and for everyone to use. That person has every right to decide how their software will be distributed. The GPL only ensures that anyone who uses and modifies the software has to give back to the community that spawned it in the first place.
Here's an attempt, although before I start, I don't hate the GPL at all. I think it's a clever hack, and a good license for some situations. Sometimes, as a practical matter, it is annoying:
Sometimes, you work on proprietary code (as to why this is, here's one thing I wrote a few years back: http://journal.dedasys.com/2007/02/03/in-thrall-to-scarcity/ but it's a long, involved discussion in and of itself!) and would like to integrate some small library that would make your life easier. If you can't use it, it's not really that big a deal, but if you can, great. Someone like myself, who greatly enjoys open source software will also be sure to be a 'good citizen', giving back any changes to that little library, even if we're not forced to.
But if it's GPL, you just can't use it. If this is the genuine intent of the author, fair is fair and you move on. Sometimes though, people just slap the GPL on stuff without particularly considering the consequences.
In some circumstances, BSD licensed code can attract more users, because they are able to use it in proprietary applications. If they 'get' open source, they'll still contribute back, causing the code to actually be more used and useful than if it were GPL and excluded from use by a company creating something it wants to make money with. (Ok, yes, you can make money with GPL stuff, but it's a lot more difficult than making money by simply selling something directly, and even that is not easy, as anyone who has tried to start a software business knows).
> If they 'get' open source, they'll still contribute back, causing the code to actually be more used and useful than if it were GPL and excluded from use by a company creating something it wants to make money with.
It depends on the size of the contribution. If they only fix a small bug then there is no real reason not to contribute the fix.
The trouble comes when a company makes any kind of nontrivial improvement at all. In that case the proprietary version is significantly better than the BSD licensed version and any improvements made to the BSD licensed version can still be incorporated into the proprietary version but not vice versa, so the proprietary version will always be better and continue to gain users at the expense of the BSD licensed version.
Probably the most extreme example of this is iOS. Apple put a slick UI on BSD and now it runs on a billion zero-freedom devices while BSD is slowly dying. Compare this with Linux, which is much more popular in its own right and even more so if you include Android, which itself is much freer than iOS in no small part because the kernel is GPL'd.
The same thing can happen with any BSD licensed software. Anyone can do 25% of the work to create a proprietary version which is 25% better than the original and use it to cart off with most of the original's user base.
Ironically this is one of the things the BSD people complain about: Anyone can take software released under a GPL-compatible version of the BSD license, make some nontrivial improvements to it and release it under the GPL.
> Probably the most extreme example of this is iOS. Apple put a slick UI on BSD and now it runs on a billion zero-freedom devices while BSD is slowly dying.
This is a very incorrect association to make, as the existence of iOS has very little effect on the relevance of BSD. (Besides, Netcraft confirmed *BSD was dying long before iOS came out. :)
Sure, from the perspective of 20-30 years ago, there were dozens of proprietary forks of BSD Unix (including NextStep), and BSD looked like a lousy choice for open source distribution.
However that doesn't acknowledge the profound change internet distribution has had on how developers consume open source code. There is now a massive ecosystem of BSD/MIT/Apache licensed code and very few evil corporations sucking it up and turning it proprietary. (Much of this 'framework' code which was always problematic under GPL.) So we should acknowledge that BSD-style licenses are successful in their own right, and not keep relying on outdated FUD about Microsoft or Apple "stealing" code twenty-five years ago, because it largely is no longer happening.
> This is a very incorrect association to make, as the existence of iOS has very little effect on the relevance of BSD.
Certainly Mac OS X has more relevance to the traditional BSD userbase than iOS, but that's because iOS preempted the existence of a mobile BSD userbase. Linux has not only Android but also a slew of smaller players like FirefoxOS and Tizen. BSD has nothing. It's hard to have less relevance than non-existence.
> (Besides, Netcraft confirmed * BSD was dying long before iOS came out. :)
Of course it was -- it has been under the BSD license the whole time and before Apple it was Sun et al as you note.
> However that doesn't acknowledge the profound change internet distribution has had on how developers consume open source code. There is now a massive ecosystem of BSD/MIT/Apache licensed code and very few evil corporations sucking it up and turning it proprietary.
That is almost a self-refuting statement. The primary reason to want a permissive license over the GPL is to use the code in proprietary software. In some cases that does result in the proprietary software dominating the open source equivalent in the market (as with OS X or Safari/Chrome), and the remaining cases (the framework code you mentioned) are the exact use case for the LGPL, which allows the framework to be used in proprietary software without allowing the framework itself to be supplanted by a proprietary fork.
> iOS preempted the existence of a mobile BSD userbase
It's completely ridiculous to claim there anything like a "mobile BSD userbase", and zero arguments beyond that were given. There's no real reason why Android or any other mobile OS couldn't be based on a BSD. Given the IP constraints of mobile phones, it probably would be a better choice than a bastardized Linux.
Oh, and "*BSD is dying" is a troll. HAND.
> The primary reason to want a permissive license over the GPL is to use the code in proprietary software.
The facts are that other than primordial forks of BSD Unix (e.g. iOS), 99% of the permissive ecosystem remains non-proprietary.
It's not like people are coding against "Ruby on Rails Professional" or "Angular.js Enterprise-Edition", all of this software is open and commoditized and free, and always will be.
> exact use case for the LGPL
I don't understand why BSD-style is much more popular than LGPL for 'frameworks'. Perhaps because it's because it's the "Lesser" GPL and the first link on the page is "Why you shouldn't use [this]".[1]
In the software industry, the FSF actually has a lot of moral authority. My guess is that if it doesn't look like they'll stand behind the LGPL, why bother?
That Apple has a huge amount of mindshare but nobody realizes how much of OSX is based on BSD/FreeBSD is a problem.
The license is a success in the sense that the code is being used, but it's failed to protect the project/brand from a situation where their code is being used worldwide without anybody realizing it.
Somebody should tell Apple to change their docs then:
> Darwin 1.4.1 is the UNIX-based, open-source foundation of Mac OS X. It is based on FreeBSD and Mach 3.0 technologies and provides protected memory and pre-emptive multitasking. This release corresponds to the release of Mac OS X 10.1.https://support.apple.com/kb/TA25634?locale=en_US
Perhaps it depends on how you distribute "vanilla" across the "or"? I read it as "(vanilla BSD) or FreeBSD" but perhaps you meant "vanilla BSD or vanilla FreeBSD"
I don't agree that 'the people that matter know' is necessarily accurate, I also don't think it's sufficient. FreeBSD depends on donations and people donate for a mix of reasons. For example you can successfully brag about donating to "Linux" because even in non-tech circles people know Linux is cool. But even in tech circles people don't know much about FreeBSD.
Not that donations as a from of conspicuous social responsibility makes sense from a rational point of view, but we're humans and there are many situations where we spend money just so people see us do it.
No, I'm really just talking about common dumb statements you see on tech sites like "Mac OS X is just *BSD with a pretty GUI". When in reality they've been maintaining their own fork for almost 20 years now, for serious technical reasons.
Keep in mind that both BSD Unix and CMU/Mach were funded by the government in order to advance the state of the domestic computer industry. In terms of successful government research projects, these two would have near top of the list!
That being said, it would be great if "FreeBSD" had a bigger brand (and perhaps wasn't seen as Apple's vassal.) But I think that has more to do with the fact that Linux effectively beat them to market versus any license logic.
> The same thing can happen with any BSD licensed software. Anyone can do 25% of the work and create a proprietary version which is 25% better than the original and use it to cart off with most of the original's user base.
I'd actually use Sun and BSD as an example, but yeah, it is a possibility, which is why I am not some kind of anti-GPL zealot. I think it's less likely these days, because the effort required to really run away with a big project is considerable.
> I think it's less likely these days, because the effort required to really run away with a big project is considerable.
Is it? Obviously the proprietary version has to be enough better to make a difference, but it still actually happens. Look at Konquerer. KHTML was LGPL, so Apple and Google have to release their changes to the engine itself, but not GPL, so Safari and Chrome are proprietary and nobody has even heard of Konquerer.
"KTHL is not GPL, so Safari and Chrome are proprietary" gets the consequent wrong. Apple did not decide to fork KHTML and then pick a license. If KHTML were GPLed, Apple would have forked a different project, or perhaps even started from scratch. The end result would have been the same.
> Apple did not decide to fork KHTML and then pick a license. If KHTML were GPLed, Apple would have forked a different project, or perhaps even started from scratch. The end result would have been the same.
You're making a baseless assertion. Apple ships an enormous amount of GPL software with OS X. It makes no sense for them to write an entire browser from scratch just to avoid the GPL when they're perfectly happy shipping bash, emacs, samba, etc.
> Compare this with Linux, which is much more popular in its own right and even more so if you include Android, which itself is much freer than iOS in no small part because the kernel is GPL'd.
Is it? The Android userland isn't GPL'd at all -- I think the last GPL bit left when they switched from BlueZ to BlueDroid. I don't see any evidence as to why the GPL code in the kernel compels Google to release the Android userland in the Apache license, rather than keeping it closed-source.
I don't imagine it does. The userland is a whole different thing. But that doesn't mean that I (or Samsung or Amazon or Mozilla) can't make changes to the kernel in ways that aren't possible with iOS, or benefit from Google's improvements to e.g. Linux power management regardless of whether or not my device runs the Android userland.
I'm not sure this is due to the GPL either. Google distributes its patches to MySQL, for instance, despite them running MySQL on their own servers rather than distributing it in such a way that the GPL would force them to.
They didn't for a while, then maintaining their fork got to be enough of a pain in the backside that they realised that keeping with upstream was probably a good idea.
Pretty much this. GPL or no GPL, there's a maintenance burden when you maintain patches on software when upstream is releasing new code you want that doesn't contain your patches.
It seems like that is due to the GPL. If they could distribute a version of MySQL with sufficiently useful improvements under their own license then they could charge money for it and go into competition with Oracle. Since they can't do that they no longer derive that possible benefit from denying the improvements to others, so they have a greater incentive to contribute them even if not required to.
I do find it disappointing when someone intentionally makes work GPL without knowing the implications. The intention of GPL is very much to prevent use in proprietary software, and to make life more difficult for proprietary software users, while creating an ecosystem of software only usable by other Free Software. However, even RMS and the Free Software Foundation have explicitly acknowledged that there are cases where an all-permissive license like MIT or (2-clause or 3-clause) BSD makes sense; for instance, when implementing a free format to replace a proprietary one, such as Ogg Vorbis or WebM. See https://www.gnu.org/licenses/license-recommendations.html for instance: "For these projects, widespread use of the code is vital for advancing the cause of free software, and does more good than a copyleft on the project's code would do." (That page actually recommends Apache 2.0 now, which is GPLv3 but not GPLv2 compatible; it used to recommend GPLv2-compatible licenses, and personally I still do recommend using MIT when trying to promote the widest possible use.)
Apache 2 is important to avoid things like the situation with LLVM where aggressive patent holders like Apple and Qualcomm feed the project with patent encumbered contributions, so that sorting out what parts of it that you're patent exposed on or not is basically impossible (meaning, you'll take a blanket license at your expense if you depend on it).
If you're not using a more modern license with an explicit patent grant you should at least have some agreement from contributors to make any of their own patents required for their contributions available to all other users of the software and its derivatives. Otherwise you may find that your permissive licensing isn't.
> If you or your employer own the rights to a patent and would like to contribute code to LLVM that relies on it, we require that the copyright owner sign an agreement that allows any other user of LLVM to freely use your patent.
A copyright license that includes an explicit patent license would allow non-LLVM users to use the patents as well, as they would need to be able to in order to exercise their rights under the LLVM copyright license and use LLVM code in something that is not LLVM.
This is a fantastic example, from both perspectives.
To strictly play devil's advocate for a moment; why do developers think it is appropriate to benefit from the free/open source library, yet not provide that same benefit back to others (in the form of using it in the proprietary software)? To me, this was the exact type of situation in which the GPL was crafted to avoid, and part of why rms didn't just declare his software to be in the public domain. I'd also imagine rms' response to this complaint would be along the lines of, informing the developer in question to work on a free, non-proprietary version of the software, so they could in fact, use the library (totally disregarding the fact it is due to external pressures, such as the employer, that they're developing proprietary software in the first place).
This is, of course, assuming the original developer licensed the library under GPL on purpose and knowing the resulting implications, as you eluded to.
> why do developers think it is appropriate to benefit from the free/open source library, yet not provide that same benefit back to others (in the form of using it in the proprietary software)
In the case I'm talking about, the developer uses the BSD licensed library and contributes back to it because they do not want to maintain a bunch of diffs and because they're a developer who gets open source.
Sure, the overall program is closed, but the existence or not of one small part of it was never going to fundamentally alter that.
Most likely these decisions are not to be made by the developer but rather the employer who actually own the copyright of the code (assuming they're a standard employee). The question from here should actually be:
Can we rely on a proprietary software vendor to push even minor fixes upstream? From the companies perspective, this is giving away the developers time to competitors for free, basically paying for every competitor to be an a level playing field with you. A companies responsibility is to appease shareholders by making money, not to make good software or help software ecosystems.
I'd say that most likely, yes, developers would like to push all their changes back upstream. Also I think that companies/managers not understanding of OSS would definitely NOT want to.
Isn't this sort of scenario the reason the LGPL exists? That way one can use the library in proprietary projects if needed, but any modifications to the library itself must still be open sourced, under the same license.
The LGPL also imposes restrictions on the finished product, including (but not limited to) requiring the right to reverse-engineer the product so that a modified library can be incorporated.
Fair enough. Just pointing out there are three options:
- Let people do whatever they want with it (BSD).
- Let people use it as a library, but force them to release changes to the library itself (LGPL).
- Let people use the software, but force them to release all modifications (GPL).
Neither is good or bad, but depends on the intention of the developer. Also, as a matter of etiquette, contributing changes back even for BSD code should be the norm, whenever there is no reason not to do so. But (L)GPL puts some enforcement power behind that rule of etiquette (and arguably created the norm).
> Someone like myself, who greatly enjoys open source software will also be sure to be a 'good citizen', giving back any changes to that little library, even if we're not forced to.
And frequently they won't, leading to fragmentation. This happened a lot before the GPL became de rigeur.
The trick in this case is for the project to have enough momentum so that you want to try and stay in sync with it and not maintain a bunch of your own changes.
> And frequently they won't, leading to fragmentation. This happened a lot before the GPL became de rigeur.
What time frame are we talking about? My experience was that the GPL probably was at its most popular in the late 90ies, but has gradually declined since then. Most things these days - Rails, Node, Android, Go off the top of my head - seem to have more permissive license.
People are a lot more connected now than even 20 years ago, so contributing back is also much easier. Also, more people get open source, at least for infrastructure type projects.
I was thinking of quite a lot of the just-before-the-Internet academic software released under a permissive license, which splintered into a thousand fragments.
And Keith Packard frequently regretted X11 being under a permissive license, given how much company forked work the home project never saw code from.
Try now. Mac OS X is based off BSD and contributes little back (and what it contributes is patent-encumbered enough to be unusable). And that's only a high-profile example which is obvious: there are tons of examples we'll never hear about because we'll never see the code.
>The trick in this case is for the project to have enough momentum so that you want to try and stay in sync with it and not maintain a bunch of your own changes.
It's not that hard these days, particularly if you are a big company with plenty resources, Apple chose to fork Clang/LLVM so that they could keep their Swift implementation proprietary.
>Rails, Node, Android, Go
Haven't open source frameworks pretty much always been permissively licensed ?
My experience is that applications are typically GPL licensed, meanwhile frameworks and libraries are typically permissively licensed.
For me the problem with GPL is simpler. I see a nice little library that someone spent two weeks on. It's GPLd. I would like to use that for the project I'm doing at work, which has 40 person-years of effort in it. So I can never use that 2 week effort code (because I'll be fired). The world is a little worse off because I now have to waste two weeks of my life reinventing the wheel, and so does everyone else who's not doing open source.
I see this argument a lot: programmers working at for-profit companies writing proprietary software feel restricted because they can't use someone else's work to their advantage. Of course, these same programmers don't have a problem with proprietary software licensing. I don't understand this viewpoint. Copyleft software is bad but proprietary software is okay?
I have no objection to proprietary software, because that is how people make a living. That proprietary software license is what allowed the author to quit his job and bring it into existence. The alternative to making software proprietary is not making it GPLed. The alternative is not making it at all!
A hobby is not a substitute for a job.
I would never characterize copyleft software as "bad:" the author has donated time and energy, and I am grateful. But it is less useful than it could have been. If you're going to write some software and give it away, man, just give it away!
You bring up a good point. People like to point out that the GPL doesn't prohibit you from selling software, which is true. But it also means that you aren't the exclusive seller of your own software -- if I sell sofware for $1,000 a copy, nothing stops someone from paying me $1,000 and selling the exact same software for $500, $250, $100... even giving it away free. Techinically, you have to buy RHEL from Red Hat. But someone can buy a single copy of RHEL, get the sources, compile the sources (this step is admittedly a lot harder than those three words give it credit for) and give them away free. CentOS used to do this, until Red Hat bought them. (Which puts Red Hat in the weird position of paying people to give the software it charges for away for free.)
There are clearly people who pay Red Hat even though RHEL can be gotten for free from CentOS. Mostly what they're paying for isn't the software, clearly, because the software can be given away for free. What they're really buying is a lot of testing to make sure that, for instance, their enterprise copy of Oracle runs correctly, and someone to yell at if that enterprise copy of Oracle ISN'T running correctly.
Which swings round to what I think you were adressing in your essay -- most software is written by a programmer in exchange for compensation, paid for by people who want to use the software. This is even true, in roundabout ways, for most open source software. (I think it even holds true for Free Software.) Now, the most straightforward way to do this is to have the person who wants to use the software pay for the software. But the GPL makes this more difficult.
A lot of open source and Free Software gets written and paid for in spite of this. How? Because the money-maker is something else. As you say, "In one way or the other, to make money at something in the long run, you are going to have to find and sell a product that people cannot effortlessly get for free." The Linux kernel gets a lot of code paid for by Intel, because it's worth money to Intel to sell x86 processors that people run Linux on rather than buying a SPARC or Alpha or POWER chip (running some proprietary UNIX or Linux, to Intel there's little difference). Red Hat pays for a lot of development on Linux, both because Linux needs to be as good as or better competing *IX operating systems and Windows for its clients to buy it and because having people who write a lot of Linux code helps them when a customer comes to them and needs a custom patch for some part of the operating system. Google pays for open source development because it uses it to run services that it serves ads from and on.
And this has conspired to give the world a lot of software for free (and Free) where the developer still gets paid for their effort. But there are some problems:
1) Sometimes products can suffer from lack of attention until something goes NOTICEABLY wrong. I'm thinking of you, OpenSSL.
2) More broadly, this works better for some things than others. Low-level infrastructure? Plumbing that you can build a service on top of? This seems to work rather well in an open/Free model. As you get closer to user-facing stuff, especially user-facing stuff where your users are individuals and not enterprises, the model starts to work less well. (The notable exception here seems to be web browsers, which seem to be able to produce very good Free and open implementations for end users, so long as they're tied into a larger overall plan of selling those users laptops and smartphones or making money off the default search engine choice for the browser.)
3) There's perverse incentives when the people who use your software and the people who pay for your software aren't the same people. Some of these are actively malicious. Some of them are passive and harder to notice. Free to play mobile games are not open OR Free-as-in-libre, but they are an easy-to-understand example of the problem where your users and your customers are not the same people. In a more relevant example, Google, Facebook and Twitter are all examples of companies who use open software to build closed services, and then revenue is made off selling the users to advertisers. In those cases, there is a tension between doing what's best for the user and doing what's best for the client. Sometimes this is overstated, and I think the overstatement helps some brush off the concern -- you can't let the client win every time, because the client is paying for users and you need to cater to users enough to actually keep them around. But there are times when the tension between who uses your product and who pays for it causes you to make decisions that aren't in your users' best interests.
I think the GPL is useful. Hell, I think it's important. But I also think that there are some significant downsides to the GPL, that it's not a one-size-fits-all solution, that even open source isn't a one-side-fits-all solution, and that making Free versus open or Free versus proprietary into an ideological question has some very real harms associated with it.
If I take your literal meaning... I don't think you're right, unless you add the rather large caveat "except for video games." But yes, outside of video games for consoles, most software does not literally come wrapped in plastic anymore. There are still large amounts of programmers who work on software that is sold, though. Office and Photoshop switched from a retail to a subscription model, but it's still the same software being sold to the same customers. The Apple App Store alone made $10 billion last year in apps and IAP,[1] and Google Play is catching up to Apple there.[2] There's also B2B software sales -- Salesforce, Oracle, SAP... all of them sell software. Yes, they aren't shrinkwrapping it, and yes, they are offering SaaS these days, but if you call up Oracle and tell them you want a site license they will totally still sell it to you. So I don't know what you're trying to say here.
The ESA, which has an incentive to play up the importance of the video game industry, puts the total number of people (not just developers) employed "directly or indirectly" in the US by the video game industry at 146,000[1].
There are around 1.4 million people actually writing code professionally in the US[2][3], even if you limit yourself to the BLS's "computer programmer" and "software developer" categories.
I'd estimate no more than 1/3rd of the ESA's estimate could possibly be developers[0]. I would certainly consider less than 50,000 out of 1.4 million to be "almost nobody" for the purposes of this conversation.
[0] And I think that's a very, very high estimate, it's probably closer to 1/5th, or even lower. There are a lot of art, QA, and support people involved in the industry, before you even make it to usual corporate overhead of management, HR, payroll, etc..
The FSF has this bizarre belief that companies write some software, and right before it gets shipped, pick the license under which to distribute it [1]:
When we explain to the employer that it is illegal to distribute the improved version except as free software, the employer usually decides to release it as free software rather than throw it away.
Our hapless employer wrote some amazing software, but then found out that they had to give it away! Hah, joke's on them!
It takes away people's ability to say "what's mine is mine, and what's yours is mine." That's enough reason for those who care about freedom for themselves, but aren't really all that interested in freedom for others.
These people were deeply upset when the GPL consistently won every time it went to court.
I think it's important to separate the idea of the GPL (which IMO is awesome!), and it's key distinction between free as in not-paying and free as in freedom, from the zealous nature of its creator.
I believe that there are many benefits from GPL, and the entire idea of Free software. I don't really feel compelled by the idea that all the bits I write should be that way, or that I should restrict the bits I use to Free ones -- partly because I really like good graphics card drivers in linux. (I realize it's selfish, but it also feels pragmatic.)
I am profoundly grateful for RMS' insight and creations, even though I don't always agree with his opinions.
There's no reason that you cannot have really good open source drivers. In fact, most of the ones you use are.
The problem is that these corporations feel that providing insight to their competitors on how they're doing things is a bigger issue, and they keep them closed.
Not even give back to the community... just give back to the next person they decide to give their modified version to, paying it forward. They're not under any obligation to give their modifications to everyone.
Good point. That is often one of the most misunderstood aspects of GPL. You have to provide the source code to the user you are selling the product to. It doesn't mean you have to necessarily give it to the whole world or even the original writer of the code.
Not necessarily. The source code might only be of interest to their competitors, not of general interest. They might be at a disadvantage for redistributing some development that they paid for and is giving them an advantage.
Indeed. There's a roaring trade in WordPress themes, even though they're all GPL (or copyright violations). (These frequently license the assets proprietary and call the result an aggregation, but you can still take a theme with cool functions and release your own version with your own assets.)
Once upon a time, I was in the camp who disliked the GPL. Because I didn't understand it. Maybe I just wasn't far enough into development to appreciate the limitations of important tools and libraries being proprietary, or maybe I wasn't disillusioned enough with American capitalist ideals.
Anyway, I read "Free Software, Free Society," a collection of essays by Richard Stallman, and it completely changed my mind on the matter. (The book is available free in PDF form from GNU.)
We all build on the work of others' before us, and limiting those who come after, taking away the freedom of the end user and future developers who play by the same rules, is shitty.
This is the simple premise of the GPL: if those who develop proprietary software won't let end users and other developers benefit from their code, we don't let them benefit from our Free code. GPL is all about protecting the end user's freedom to use and modify the software.
I don't mind if other people use the GPL, but I think it's inappropriate for certain kinds of work, including most work sponsored by the government and universities.
Suppose the government sponsors a numerical software library. If that library is GPL licensed, that means that proprietary software like Matlab, cannot use it. Is this a good thing? If we think that there should be strong encouragement for all software to become open source, maybe yes. But I believe there is no reason to want most software to be open source. So releasing things like this under the GPL just means that less people can use it than otherwise, and so the effort has been less efficient.
I would choose a permissive license for everything except operating systems (which I think should be open source, for security reasons), and end user products (like emacs), which need to have the community protected from proprietary forks. Libraries should mostly be licensed with permissive licenses, because that maximizes the number of people who can use it.
It's not really about "giving back". There's no obligation to give anything back at all and neither should there be. Rather, the GPL is designed to globally maximise the freedom to use, modify and distribute a piece of software. The only freedom the GPL does not provide is the freedom to take these freedoms away from future users.
> The only freedom the GPL does not provide is the freedom to take these freedoms away from future users.
And that's the crux there. It's not always malicious (I want to make a proprietary extension and sell it), sometimes it's a fact of the environment (I have to link this against a proprietary library in order to deploy to this hardware). Some will say "find a new environment that isn't developer-hostile", and others will say "find code that doesn't impose those restrictions." It's not black-and-white.
I have the greatest respect for RMS and the FSF. I compromise on my freedom as a developer all the time; I know that. But thanks to the ideals that RMS puts forth, I know that I'm compromising. I know what the risks are to using BSD instead of GPL, and so I weigh those risks.
> not always malicious (I want to make a proprietary extension and sell it
You say its not malicious, but then I see the misery and harm proprietary copyright licenses do. People use it to sue 7-year old girls, send people to jail for years, and put others into debt for millions, all for the simple act of someone helping an other fellow human.
We could make a copyright license which only condition is that you can not sue someone, or that you can only sue companies and not people, or some other from of harm reduction. I doubt companies would prefer it, as without the threat and punishment from copyright lawsuits many argue that you can not earn money on making software. They argue that you must have the malicious aspects, or its not free enough to be useful.
A proprietary copyright license is a explicit statement of intent, in which you state that you are going to sue those who share the program. It is a government supported threat of violence directed to the public, and each new law that is passed seems to want to increase the number of years in prison.
Can you give an example how such threat can be non-abusive?
>A proprietary copyright license is a explicit statement of intent
Considering that copyright applies to your work automatically unless you take positive action otherwise, it is no such thing. Someone's work belongs to them, under whatever terms they wish, until they wish to modify those terms.
The term "proprietary license" is that kind of written license which company adds to their products which explicit state what users can and can not do, often with a explicit threat to underline it.
Works that do not have a license is normally refereed as orphan works. While you could call it proprietary, it is by definition not proprietary licensed.
> Works that do not have a license is normally refereed as orphan works.
No, that's just a copyrighted work with no published license (e.g., most dead tree books), for which you must contact the copyright holder if you want any kind of license.
An orphan work is a copyrighted work for which the rightsholders are unknown are uncontactable, and which it is therefore impossible to even attempt to negotiate a license.
It is kind of hard to contact the copyright holder if there is no copyright license with a notice in it which says who the author is.
Technically possible, unlikely in practice, and I doubt anyone could find a proprietary product being sold in a store that does not have a license. For all practical purposes, where would you find proprietary work used in a proprietary setting but without a proprietary license?
You're changing the subject a bit. First you were talking about "works that do not have a license" and now you're talking about specifically proprietary works.
As an example, there are any number of projects on github without any explicit license. That does not make them orphaned, nor make them freely available for use. We've come across a couple that we wanted to use and our first step was to work with the authors to get them licensed under some clear terms.
Just because it's "hard to contact the copyright holder" doesn't make it legal (or in my opinion, moral) to take their work and use it however you judge best.
Who said anything about "freely available for use"? The whole discussion here has been about proprietary licensed works. Karunamon said that proprietary licenses did not exist, because works are automatically copyrighted and I disagreed.
A project on github without a license is not proprietary licensed, but they are copyrighted. If such work ends up in the hand of someone which is not the author, then one would have to ask under what permission (license) that happened.
> A project on github without a license is not proprietary licensed, but they are copyrighted.
The content of a project on Github that is publicly viewable arguably also is minimally licensed as required by the Github terms of service, to wit, the Github project owner "agrees to allow others to view and fork" the project repository (see Github Terms of Service [0], F.3).
Hardcopy books would fall under the implied license doctrine.
It's clear from the conduct of the parties to the transaction that a limited license for reading is intended, and the parties just never bothered to make an explicit license to memorialize that agreement.
> Hardcopy books would fall under the implied license doctrine.
One might be able to craft a colorable argument that an implied license to some right that is exclusive under copyright is created in the usual sale of a hardcopy book -- but you certainly haven't yet done so.
> It's clear from the conduct of the parties to the transaction that a limited license for reading is intended,
"Reading" isn't -- in the US, at any rate -- an exclusive right under copyright [0], so no license is necessary.
> A proprietary copyright license is a explicit statement of intent, in which you state that you are going to sue those who share the program.
No, its not.
A proprietary copyright license is a explicit statement of intent, sure, just as a free software license is -- but any license, proprietary or free, is an explicit statement of intent not to prevent certain uses. It may also be an implicit statement of intent to take action, including lawsuits, against those who make use not permitted by the license to the extent that is within the licensors right -- and, again, this is just as true of free software licenses as proprietary licenses.
Even RMS has been saying that not all proprietary software is malware and it used to be less common for it to be so. Being unethical doesn't make it otherwise malicious, but the power it gives is today often abused and thus is indeed malicious.
"We could make a copyright license which only condition is that you can not sue someone, or that you can only sue companies and not people, or some other from of harm reduction."
Every company in the world will get around this.
"We could make a copyright license which only condition is that you can not sue someone"
So what would you do in the case of a copyright violation? If you can't sue to enforce the license, what's to stop anyone from violating it? And that includes the GPL and its provision on opening the source of things using it.
" They argue that you must have the malicious aspects, or its not free enough to be useful."
There needs to be some way of enforcing the contract. And that's how contracts are usually enforced: In the court system.
The author is never bound by the license, and it would basically become a eye-for-a-eye license. If you sue, you get sued.
It would of course not provide the benefits of GPL which has requirements on distributors to provide source code. It would be a completely different license, and if I made it, likely based on MIT just so it would be the least company friendly permissive license ever. I only bring it up as an example of a license requirement whose intent would align with many who uses GPL in order to prevent copyright abuse.
You are giving the FSF point of view, but that is not the only point of view. The post is correct that the practical effect of the GPL is to require giving back to the community.
Freedom is a loaded word, and I think most people don't share the FSF's definition of freedom. I would rephrase your statement as "the GPL is designed to globally maximise the ability to use, modify and distribute a piece of software. The only ability the GPL does not provide is the ability to take these abilities from future uses."
I personally think that this ability to modify software (and scrutinize its source code) is very important when it comes to the operating system. For javascript code sandboxed in the browser, it is much less important (sure, javascript can still do unexpected things, like tracking users, but this is still much much less than what could be done with full user level access, and these are things that can be fixed). So I support GPL for operating systems, encourage open source for other software, but don't object to closed source when the danger is low.
"the GPL is designed to globally maximise the ability to
use, modify and distribute a piece of software. The only
ability the GPL does not provide is the ability to take
these abilities from future uses."
I would summarize that as "the GPL is designed to globally maximize knowledge about the software, and the ability to use that knowledge".
The part about forcing published forks to release their source code is a consequence of that purpose: hiding the source would reduce the amount of knowledge, and thus it is forbidden.
I don't like this formulation. You can't take away any freedoms of something that is released freely. The only thing GPL guarantees is that derivatives are also free.
Also if you speak about "a piece of software" as in one piece of software, then the GPL doesn't maximize the freedoms.
What the GPL does, is set a few (people from the BSD crowd would say restricted) freedoms and try to spread them as far as possible by making people license their own source code they wrote under GPL if they want to work with a GPL licensed codebase.
> What the GPL does, is set a few (people from the BSD crowd would say restricted) freedoms and try to spread them as far as possible by making people license their own source code they wrote under GPL if they want to work with a GPL licensed codebase.
Not entirely true. You are only subject to GPL if you distribute the code you modify. If you keep it inside your company, or for yourself, or you run it on your servers, there nothing GPL will do to you.
> If I give my modified-GPL code to my coworker bob is that distribution?
If it is yours (and not your common employers, which then brings into some question as you being agents of the same actor) it would seem to be "conveying", which is the more relevant term under the GPLv3 (see below).
> If I upload to an EC2, is that distribution?
More relevant is probably that it is "conveying" as defined by the GPLv3:
To “convey” a work means any kind of propagation that enables other parties to make or receive copies. Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying.
(Uploading to EC2 enables -- requires, in fact, for normal operation -- Amazon to make or receive at least one copy of the software.)
Why would uploading code to EC2 be distribution? You are not giving your program to Amazon to use (unless their ToS have something foul in them), you are contracting Amazon to run your program on your behalf.
Put another way, if you take your GPLed code, burn it into a cd and mail it to yourself through DHL or Fedex, you are not "distributing" the code to Fedex.
> Why would uploading code to EC2 be distribution?
It might not be distribution, but the GPLv3 terms are mostly triggered by "conveying", and it is clearly "conveying" as defined in the GPLv3.
> You are not giving your program to Amazon to use
The GPLv3 definition of conveying keys on whether you enable another party to "make or receive copies" of the work, not whether it is for that other party's use. Even if the copies are for your use, if you enable another party to make or receive copies, you are conveying, and are covered by the GPLv3 provisions applicable to the form (verbatim, modified source, or non-source) you are conveying the copy in.
> Put another way, if you take your GPLed code, burn it into a cd and mail it to yourself through DHL or Fedex, you are not "distributing" the code to Fedex.
Mailing your GPLed code through DHL or FedEx does transfers physical media through their hands, it does not enable or require them to make or receive copies of the code. So, true, it is not conveying, and it is also unlike uploading to a third party, which always enables that third party to make or receive copies.
That still sounds fishy, how about uploading it to Dropbox/Google Drive? I am not talking about hosting the software in EC2 and then giving access to third party users, just running it there instead of in your own servers, for internal use. Are you "conveying" your software to your ISP whenever you upload a copy as well? (you are technically requiring multiple parties to copy parts of the software into the buffers of many intermediate routers...)
> That still sounds fishy, how about uploading it to Dropbox/Google Drive?
By the plain language of the GPLv3, that would seem to be conveying as well. I agree that that is an undesirable thing in a Free/Open license, and quite possibly not the drafters' intent (but the drafters' intent matters little, especially for GPLv3 licensed software where the FSF isn't the licensor.)
What you're missing is that the copies aren't being sent to Amazon, Dropbox, or Google. They're being sent to space you are renting from those companies. You are no more propagating (another important term defined in GPLv3, which conveying is defined in terms of) a work to those companies than you would be if you put a copy of the work in a storage locker, apartment, rented office space, or even a rented car.
The copy is not Amazon's, Dropbox's, or Google's, it is yours. It never legally left your control.
> What you're missing is that the copies aren't being sent to Amazon, Dropbox, or Google.
What you are missing is that the uploading to those services absolutely is a "kind of propagation that enables other parties to make or receive copies." [0] You are, in fact, sending the work to Amazon, Dropbox, or Google, and you are explicitly representing to them that you have, and are exercising, the right to give them permission to make copies of it (and, for some of those services, also to allow third parties to do so.) [1]
> You are no more propagating (another important term defined in GPLv3, which conveying is defined in terms of) a work to those companies than you would be if you put a copy of the work in a storage locker, apartment, rented office space, or even a rented car.
Propagating work is defined as "to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy." [0]
Copyright law (at least, in the US) does not make it an infringement to store physical objects containing a copy of the work in space controlled by a third party without permission of the copyright holder. It does, however, make making a copy (including, e.g., by uploading) without such permission, generally, an infringement [2]
So, no, from a legal perspective, the analogy you draw is not valid.
[0] GPLv3, Sec. 0
[1] Consider, e.g., the Dropbox terms of service [3], under "Your Stuff and Permissions": When you use our Services, you provide us with things like your files, content, email messages, contacts and so on ("Your Stuff"). [...] We need your permission to do things like hosting Your Stuff, backing it up, and sharing it when you ask us to. [...] You give us permission to do those things, and this permission extends to trusted third parties we work with.
You're right, that would be propagating, since it's making a copy. In fact, it's also conveyance.
But you forgot to keep reading GPLv3.
2. Basic Permissions.
[...]
You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force. You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright. Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you.
You might still argue about dropbox, since it's neither modifying nor running the works, but certainly using the work on EC2 falls under this provision.
On review, I think you may be correct with something that is solely an execution service like EC2 (depending on the exact terms in the ToS of that service, though I only see one minor potential problem area -- in terms of the GPL terms under discussion -- related to government requests with the AWS terms that would apply to EC2); but a service of the general type of Drive/Dropbox is still problematic.
> government requests with the AWS terms that would apply to EC2
Are you talking about search warrants? I think any interpretation that makes one liable for copyright infringement for the government forcibly making a copy is likely to be laughed out of court.
> a service of the general type of Drive/Dropbox is still problematic
There is an exceedingly easy workaround if it is a problem: Encrypt it. That way you do not "enable" them to make copies (in any sense a court would care about).
> "You can't take away any freedoms of something that is released freely"
Sure you can. If you release a animal to run freely in the wild, I can take away its freedom by shooting it. The only way to maintain its freedom is by also restricting my and others freedom to hunt it down. The way we describe this is liberty, ie everyone can live in freedom under common restrictions; restrictions which purpose is to maintain the freedom of everyone.
I want to share my code with everyone. That includes:
* (1st-order capitalists) People who want to make a buck
* (2nd-order capitalists) People who don't mind if 1st-order capitalists use their work
* (3rd-order capitalists) People who don't mind if 2nd-order capitalists use their work
* (Etc., nth-order capitalists for all n)
That makes me an ωth-order capitalist. Unfortunately, GPL is anti-ωth-order capitalist (Proof: Induction). I can't ever use it unless I'm willing to kick people under the bus who I'd rather allow to use my code.
Thinking of it as "kicking people under the bus" a little reductive. There are 2 classes of people using your work: developers who want to make a derivative work based off your code and end users who want to use either your code or the derivative work.
Who exactly are you kicking under the bus? The developers, or the end users?
The GPL optimizes for end-users, "kicking developers under the bus", and the BSD/MIT licenses optimize for developers and "kick the users under the bus".
Which group do you optimize for? Arguably, if you want "maximum freedom" in the world, you'd optimize for the end users, since there are going to be more of them than the developers.
> Arguably, if you want "maximum freedom" in the world, you'd optimize for the end users, since there are going to be more of them than the developers.
Not to mention the developers are 1) normally end users and 2) couldn't be developers of said software if you didn't release your software the way you did.
Nothing prevents you from licensing your code BSD while using GPL-licensed software. You can use what ever library or software out there which is GPL and if you always use BSD or MIT license, you can share your code that you wrote with whoever and for whatever purpose. People who receive it can then use your code for what ever, and only need to follow the GPL if that also use the code which you have not written.
That doesn't make any sense. If people could take GPL code and switch it to MIT license then GPL would be meaningless:
1. Take the GPL project you want
2. Add a comment somewhere, publish the resulting derivative under MIT
3. Use it however you want, while flipping off Gnu
Sure, I can (and do) use GPL software, personally. But I can't use GPL sourcecode in projects I publicly release. If I did, that part of my sourcecode would have to be GPLed.
* Which means it couldn't be used by anyone (set A) who can't use GPL.
* Which means it couldn't be used by anyone (set B) who wants to share with people in set A.
* Which means it couldn't be used by anyone (set C) who wants to share with people in set B.
>That doesn't make any sense. If people could take GPL code and switch it to MIT license then GPL would be meaningless
He never said that, he said you can you can combine your permissively licensed code with GPL licensed code and _your_ code will still be available as permissive.
You stated that you wanted to share _your_ code with 'everyone', nothing prevents you from doing that.
Someone else's GPL licensed code is NOT _your_ code just because you decide to use it.
Those people in Set A and so on have made their own choice, that they do not wish to share with their users. The only people preventing them from using GPL software is themselves.
Unfortunate or not, my point was that it did help proliferate the idea of open source software, even of different licenses.
Of course it is a "what would have happened if" kind of argument. But that is just my opinion.
In other words, I am saying, BSD/MIT/etc type licensed software would not have proliferated as much if GNU/GPL wasn't there from the start. From RMS's point of view, it was probably not an intended consequence, I agree.
As much as RMS rubs many people the wrong way (including myself), the GNU project has brought an amazing amount of good to the world, and done much to enable and inspire the various other forms of open source software we enjoy today, which in many ways has driven the development of the Internet in a direction that would have been basically impossible without the software foundation laid by RMS and others who took up the GPL.
I'm glad to see the New Yorker covering a massively influential, but often invisible, force behind today's Internet.
I fear that you, as well as a large portion of the HN community, are prematurely marking GPL software and the GNU movement as an outdated idea that has less of a place moving forward. You look at society today and say, "well, tech has moved so much in the past 25 years, and it's far too developed to become closed now. The point has been made."
That's bullshit.
We live in a far more closed world than we ever have before. Most people (eg: those not on this website) use their phone as their primary computing device. They access software primarily through closed source app stores. They give their information to servers which are almost certainly closed source.
This industry is far too young; the war on general computing is far too powerful, to be able to have this opinion and think it does no harm. We have seen all the good that the GPL has done for us, and we've seen the damage that BSD licensing can do. I'm not saying that BSD licensing doesn't have a place, (I actually use OpenBSD on a daily basis, and I'm aware of many of the difficulties that they face with regards to GPL'd stuff [1]), I'm only saying that it is not superior to the GPL in all cases.
The way I think of it is that it's important to have a backup plan. Few people are prepared to give up commercial software today, but we can support the efforts of the activists who do try to live purely, in case we ever need it. Releasing software under GPL-compatible licenses is a way of contributing, even if it's not as strong support as some people would like.
Freedom is an old idea. But somehow it never seems outdated. So, put down the iPhone and pick up the GNU Manifesto and enjoy software freedom -- as good as it is gnu
Not at all. I agree with you that Free Software is more important than ever and that current trends in computing are dangerous in many more ways than they were when RMS founded GNU.
But I reserve the right to find him personally irritating, despite my general support of his cause.
It's nice to see GNU Manifesto get some love. I have a hard time seeing the ideals of RMS and Free software get run over in conversation so easily, even on HN, while almost every experience I have reinforces the idea that GPLv3 is the future.
For example, I made a bad purchase and bought a Samsung SmartTV. Now I have a TV with a quad core ARM in it but I can't put my own distro on it because even though they are running Linux and hence GPLv2, Samsung has made recent patches likely to brick the TV with any attempts to install your own OS...
I think too many people have bought into the idea that GPL code makes for complicated legal issues that isn't worth the trouble, but I don't think that's the case at all. Neither is it the case that you can't profit from GPL code. All you have to do is provide source!
Anyway, I'm just saying I think RMS is a man ahead of his time even today, and as corporations and governments extend their tentacles of power into the digital world the last bastion of freedom for hackers is going to be GPLv3+ and not BSD (which enables putting users in prisons, eg Apple).
Not his call. Every individual kernel developer owns their own contributions.
Even if Linus were to move his own contributions to GPLv3 and require GPLv3 for all new contributions, he'd still have to get permission from every single individual who ever contributed code from the kernel. Some of these people are dead, so he'd have to deal with their next of kin (or more likely, their lawyers), who might be even more difficult to deal with.
Yep, one of those... which is why I wanted to put something I could control on it, but alas I have updated too recently and am afraid of bricking a $3k tv...
Always take software ownership of your devices as soon as you buy them, so you're well within the return period if it doesn't work out. You have a much better opportunity to assert your modification rights during the return period rather than having to beg the manufacturer to honor the warranty.
(I know this doesn't help you now, and your next chance is when the device is old enough that you're comfortable losing it. I'm posting this so others don't make the same mistake. I'd personally just forget about the computer in your TV, and setup a proper HTPC).
Thank you for this information, I wish I had thought about it in that manner at the time of purchase, and it is something I think more modern techlectuals should consider.
> Please be aware that if your spoken words include personal or other sensitive information, that information will be among the data captured and transmitted to a third party.
was removed from a context which says that this data is only transmitted to a third party when the voice control feature is explicitly activated (e.g. by holding down a button on a remote control, or by saying a command word).
I'd bet $20 against $10 that regardless of whether the privacy policy says that, that's what actually happens. (I.e. I'm assigning significant weight to the possibility that the privacy policy does not explicitly rule out them doing it, but they still don't do it.) But that seems harder to pin down. E.g. I'm not going to say that no Samsung Smart TV has ever transmitted any speech outside of that situation.
What I find most interesting is that I'm quite eager and happy to believe that Samsung is spying on us, while you seem to be eager and happy to assert that they wouldn't do such an evil thing.
What's different about you and me? Why do you want to trust Samsung, but I don't?
Just to be clear: I think that currently, these TVs do not record audio and send it over the internet except when voice control is specifically activated (and not just enabled). I'm not saying they don't have that ability, or that they never will do that, or that they're not spying on people in other ways.
To answer your question: If they were, I'm pretty sure we'd have found out by now. I don't think they'd be able to hide the fact that they're sending audio data over the internet. If you connect your TV to a wireless router that you control, you hopefully can't tell exactly what data they're sending to the internet, but you can probably distinguish between "currently sending audio data" and "not currently sending audio data".
(Also, are capped internet plans still a thing? Someone who gets a smart TV and then finds their entire data quota used up in a week would probably notice.)
And it's somewhat plausible to me that this kind of news would break and I'd miss it. But then I'd expect you to be posting articles about how it actually does happen, instead of one which says that they probably aren't listening in on things you say when you're not using the remote, but here are some things you can do just in case.
Good article, fair, factual. Proper use of the word 'hacker'. Balanced with comments from Tim O'Reilly and accurate distinction made between GPL and BSD/MIT. Good job Maria Bustillos.
Can't believe I just wrote that about an article in The New Yorker. :)
There is one small terminological mistake which I'll write to the author about: the use of "open source" to mean "non-copyleft (permissively licensed)" as contrasted with "free software" to mean "copyleft (reciprocally licensed)".
I see this all the time, but it's historically unfounded. The Free Software Foundation accepts both copyleft licenses like GPL and noncopyleft licenses like BSD as "free software" and the Open Source Initiative accepts both as "open source". This has always been true, because the Open Source Definition was derived directly from the Debian Free Software Guidelines and "open source is a marketing campaign for free software".
The terms were always intended to have the same denotation and a different connotation (although there are somewhere around 2 non-widely-used licenses whose acceptability FSF and OSI came to different conclusions on).
The distinction that the author was quite accurately getting at, but ended up missing, is that people who prefer to say "free software" are much more likely to think that copyleft is often preferable to permissive licensing, while people who prefer to say "open source" are less likely to think that. When RMS says "that companies that tout open-source principles often 'seduce our community to release free software without copyleft'" the causal relationships at work are much subtler (since many of those companies release primarily copylefted software, even when they are the copyright holders!).
I think I need to write the canonical Open Source and Free Software Refer to the Same Software page...
I don't disagree with you, but the term "open source" predates the OSI by quite some time and was in common usage to mean "source code you could read" rather than binaries.
OSI may (and have) redefine it, but it is historically founded that it meant readable code delivered with the binaries rather than binaries only.
I've sometimes heard that, but I don't have a personal recollection of hearing the term used that way before. Do you happen to know of particular examples of people using "open source" that way before 1998?
My earliest memory of it was circa 1990 when we had problems getting source code out of escrow for a system, and we were advised to make sure the next system was open source.
Edit: Check this 1993 document by NASA: "National security and national competitiveness: Open source solutions; NASA requirements and capabilities"
OK, maybe, it was the first one I came across. Well, you can claim they invented the term in 1998 and I guess I can't convince you otherwise unless I dig up some old documents, which is unlikely.
Anyway, FWIW, we used the terms "open source" and "open source code" way before that and it was widely understood. I don't have any reason to make that up.
> Anyway, FWIW, we used the terms "open source" and "open source code" way before that and it was widely understood. I don't have any reason to make that up.
Perhaps it was your personal jargon. I don't see any evidence that it was widespread before 1998.
I think it's more likely that your memory is failing, and OSI's campaign was so successful that they really convinced you that you always called it "open source". It has been close to two decades, after all. We can forget.
That's what you would interpret if you heard someone say "open source" but that would have been two words put together, not a term. The OSI people invented the term.
You are mistaken. The term was not used with reference to available software source code before February 3, 1998; it had a mostly unrelated meaning in espionage.
Honestly, The New Yorker is one of the best journalism organizations operating today. Not only are they one of the few that still has a real fact-checking department, but they've been at the cutting edge of adopting serious encryption technology to protect sources.[0]
You and me both. I was prepared for an upper crusty profile making fun of his mannerisms or idealism. Instead I got a clear, concise summary of Stallman and the landscape of software licencing. This will be an excellent introduction for the average person.
The New Yorker is an amazingly humane publication. Not snarky, not haughty, not what many people (who do not read it) think it is. This piece is a representative sample of their journalism.
The New Yorker is like Burning Man - people who've never experienced it have strongly held, fiercely incorrect assumptions about what it is.
@matthewn (can't reply directly to you) - hah! You're right, Anthony Lane is hilarious. And the opera reviews can be boring if you (like me) are not into opera. But you know what I mean =)
You must not read the New Yorker very often. I don't think I've seen an article that I would describe as "making fun" of anyone in ~25 years of reading.
True... and to be fair, I also don't watch television, use any of the popular social networks other than Github, I don't have a cell phone, and my default position on anything uttered by a politician is that it is a lie.
My comment was more an indictment of mainstream news at large, so if I inappropriately cast aspersions on a good publication, I apologize.
Maria Bustillos is great. A nerd with good politics and great skill at the craft of writing. She is also one of my favorite people to follow on Twitter for calling attention to other good writers.
You don't think that Thelema's "Do what thou wilt" and the BSD licenses' "Permission to use...this software for any purpose with or without fee is hereby granted" are very similar?
Also, if you're referring to the K2 summit attempt in 1902 led by Eckenstein, I was under the impression that no one died despite the fact that they failed to summit:
However, Crowley's 1905 trip to Kanchenjunga was an unmitigated disaster. Crowley, who insisted on leading the climb, behaved extremely badly, going so far as to decline assisting in the rescue of fellow climbers and porters caught in an avalanche as well as later stealing money from the expedition. I'm under the impression that Crowley was only interested in setting a high altitude record. Four people ended up dying:
Crowley did go on some kind of climbing holiday in New York State later in life, but I doubt that was anything like his earlier trips to the Alps, Mexico, or the Himalayas.
If you disagree with the GPL then you disagree with copyright law. The GPL is only as powerful as current copyright law allows it to be.
Don't hate on the GPL, it's satire. Hate on the last century of corporate-lobbied legislation that has granted unprecedented levels of power to copyright: http://en.wikipedia.org/wiki/Copyright_law_of_the_United_Sta.... E.g. Mickey Mouse still isn't in the public domain!
> If you disagree with the GPL then you disagree with copyright law.
Its quite possible to believe that existing copyright law represents exactly what government should do to manage IP in that domain and not believe that the GPL represents a choice people should make about how to use the rights provided under copyright law. (Note: I am not saying, in this post that I hold either part of that opinion, only that it is not inconsistent.) So I disagree with your claim "If you disagree with the GPL then you disagree with copyright law."
Believing that government should permit something is different than supporting the choice to actually use that permission in any particular way.
If one supports the level of power that current copyright law provides for authors, then you must support the fact that any particular author wields it. If you think the author is abusing power, then that means the current copyright law is too broad, and if it's too broad you ultimately don't agree with the law.
> It's possible but it's not logical!
If one supports the level of power that current copyright law provides for authors, then you must support the fact that any particular author wields it.
No, if one supports the level of power that current copyright law provides for authors, then you must support the fact that it is legal for any particular author to wield that power within those bounds.
That doesn't mean you have to support every particular choice about how it is wielded, just as one's support for the freedom of speech from government censorship doesn't mean one supports every utterance that is outside the scope of what government may prohibit given that freedom.
If one's support for the government policy is on a utilitarian basis (as one example of a framework of support that might apply), one can support the government policy while opposing an action it allows simply because one believes any policy which would effectively constrain the action which one does not prefer would have other harms which outweigh the benefits of preventing the action at issue.
> That doesn't mean you have to support every particular choice about how it is wielded
I never wrote you have to support how it's wielded but that it is wielded. Your freedom of speech analogy doesn't apply to what I wrote.
I agree with your last point, but I think that's exactly the job of lawmakers. Once you've found an abuse of the law, you refine the law. You don't just throw your hands up and say "well the pros outweigh the cons." Legislation isn't futile. In this specific case, copyright law has only grown more powerful without any significant negative feedback.
All I'm saying is, if you feel there is something wrong with the GPL, well it's not the only instance of copyright abuse and maybe you should focus on copyright law itself, not the GPL.
Suppose for whatever reason (employer legal department, etc.) you can't use GPLd sourcecode.
You'll quickly find that GPL sourcecode is not just neutral to you, it's outright harmful. Why? Because if there's a strong project that's GPL'd, that disincentivizes anyone from working on a less restrictive open-source version of same. So now that funny "satire", as you put it above, is forcing you to reinvent wheels, when you could be using that effort to further improve the world.
when you could be using that effort to further improve the world.
Except that by "improve the world", you actually mean "make a quick(er) buck for ourselves".
By the same logic, your company charging for their software (or not open-sourcing it) is "outright harmful" to people who want to use your company's software to make themselves a quick buck for themselves.
Except that you can at least read and learn from the GPL code when making your own implementation. Somehow I doubt your GPL-hostile employer is taking even that small step toward improving the world.
Then you should convince your employer that they're wrong with that ban. If they don't wish to pay the fee for using the work of others, then they need to make their own, just like anything else in the world.
Or rather, it's forcing your closed-minded employer to reinvent wheels. Is it possible to improve the world while working for an employer that cannot embrace GPL? Opinions on this subject differ.
That's not true. Using Mickey Mouse or Mario would allow you to profit from an enormous amount of brand name marketing.
It's more like you start a new pizza company and you're not allowed to use Stallman's Pizza Cookbook, which has some recipes you like. You can still hash out the recipes by yourself, with much annoying time and effort (and wasted food). Stallman's just not letting you benefit from his cookbook, because he thinks all pizza should be free.
In this pizza recipe metaphor, are the recipes or the pizzas supposed to be the analogue to software?
If recipes, then the metaphor makes no sense. You can use the "recipe" that is LibreOffice to produce "pizza" that is work products that people would pay for (such as a lawyer drafting contracts, a consultant making spreadsheets, etc). Nothing in the GPL stops someone from profiting from the output of a GPL'd program.
If pizza, then I can only assume the "recipes" would be programs that produce programs, such as compilers or parser-generators. In that case the metaphor also falls apart, since GNU programs of that type have license exceptions that make the output of those programs (and the additional compilation files needed to run like libc and bison include files) usable without following the GPL.
>>It's more like you start a new pizza company and you're not allowed to use Stallman's Pizza Cookbook, which has some recipes you like. You can still hash out the recipes by yourself, with much annoying time and effort (and wasted food). Stallman's just not letting you benefit from his cookbook, because he thinks all pizza should be free.
No, you'd just have to share your recipes whenever you sold the pizza. You can still charge for the pizza (or not) if you want - and the guy who buys it from you can sell it or give it away or whatever.
I went to hear him at UIUC last night. For as much as I've read his articles and listened to recordings of him online, it was still a very fun and insightful experience to be there in person. Highly recommended if you can make it.
> he found himself unable to adapt a new Xerox printer with a program he’d created to alert users to paper jams
And still I can't go to an average computer store, buy a printer which is powered by free software so I could customize it like this. We have a long way to go. First to mind: the respects your freedom campaign needs to grow to more hardware.
As others have mentioned, I'm surprised you'd associate him with Top Gear of all things. He's better known as the host of the british quiz/comedy show QI (Quite Interesting) [1], and before that one half of the comedy duo behind "A Bit of Fry and Laurie" [2], the other half better known in the US as the actor who played Dr House. Fry also played Jeeves in a television adaptation of P.G. Wodehouse's Jeeves & Wooster series, and dare I say incarnated the perfect humble and effective butler, again alongside Laurie as Wooster. [3]
He's one of the top living british comedians, which is why him outing himself as a geek and explaining the importance of the GPL has so much weight.
I feel like Philangist is probably showing his US roots here: the most popular of Fry's works on this side of the pond is Top Gear. As an American, the only reason I ever came across A Bit of Fry and Laurie is because of a British friend, and I hadn't heard of QI or Jeeves and Wooster. And I've some exposure to British culture (I've watched Doctor Who, Allo Allo, Black Adder, Black Books, Orphan Black, Black Mirror (you guys like your black names!), Monty Python, and others that don't immediately spring to mind).
I'm somewhat surprised to find what didn't make it over to the UK from here, though. Someone recently asked me why Americans call her "Willis" and ask what she's talking about, for example.
>I think the irony is that open source is empowering developers, not users.
And that's why copyleft is still important! We, as developers, have an abundance of awesome free software to build applications with, but rarely do those freedoms make it all the way to the user. Open Source gives developers freedom. Free Software gives users freedom, too.
Consider using the (A)GPLv3 for your next project.
"Richard's sort of like an Old Testament prophet, with lots of 'Thou shalt not,' and BSD is a more Christian approach, saying, 'Love your neighbor; make value for the world. Let the people do with it what they will!'"
Such a dud on O'Reilly's part. The analogy is totally confused from a theological and sociopolitical perspective, in its treatment of the Old Testament and New Testament as being mutually exclusive/opposed sets in the Christian religion, and the implicit assumption that most interpretations of Christianity are from a libertarian/anarchist perspective.
> in its treatment of the Old Testament and New Testament as being mutually exclusive/opposed sets in the Christian religion
It doesn't treat them as being mutually exclusive or essentially opposed, it treats them as different areas of potential focus within the same overarching tradition where focus on one vs. focus on the other produces a very different "feel" even when the overall values aren't all that different.
> and the implicit assumption that most interpretations of Christianity are from a libertarian/anarchist perspective.
I would agree that it is an error to present "more Christian" as an alternative to "Old Testament", but its clear from your preceding complaint that you got the intent, which was that "Christian" here stood in for "New Testament" and that both alternatives were, in your words, "in the Christian religion". So your first criticism makes your second seem disingenuous, as the two criticisms require different readings of the text.
FWIW, as a lifelong Christian, I've seen this kind of "New Testament" vs. "Old Testament" focus distinction -- one that aligns with detailed proscription based vs. a more personal and situational approach -- made frequently by Christians, and by Christians whose personal preference is on either side (ones who criticize the other side of the relative focus divide for focusing too much on the NT without critical OT context, and those who criticize others for focusing too much on the OT without attention to how the NT should inform the application of the OT.) So I don't think that analogy is inappropriate or poorly chosen, even if the precise wording ("Christian" vs. "New Testament") is less than ideal.
> The analogy is totally confused from a theological and sociopolitical perspective, in its treatment of the Old Testament and New Testament as being mutually exclusive/opposed sets in the Christian religion, and the implicit assumption that most interpretations of Christianity are from a libertarian/anarchist perspective.
When you find yourself writing phrases like "a theological and sociopolitical perspective" it's time to walk away from the keyboard. That's such a broad phrase you might have just said "a perspective".
In other words, open source in general, even including popularity of other licenses, would not have spread and become so popular if GNU and GPL wasn't there as an extreme, far out example. For those younger here, sharing software by big companies (Microsoft, Google, Facebook etc) was pretty radical and unheard of back in the day. Now they all share so much of their code which is great.