Why the use of GPL is declining
dirkriehle.com
dirkriehle.com
The GPL is great as it ensures that everyone who uses my code has to give their contributions back so I get to use and improve upon it, too. Individuals usually like this. Companies often do not.
The way I look at it, I'm doing work for free. The GPL ensures I get a return on that investment in the form of additional code and work that I can use in my own projects and that everyone can benefit from. MIT/BSD lets someone else profit from my work without giving anything back to anyone.
Is this from anecdotal evidence, or have you run some sort of valid study? Because my anecdotal evidence says the opposite.
MIT licensed software gets more power from being used by companies, especially modern startups and software companies, and consultancies. I've had more attention and source contributions from medium-sized companies than from any individual. The usefulness of my library to these larger companies almost ensures its continued survival.
It appears that the rare exception is when companies or individuals don't contribute back.
If it's GPL, then yes, they simply wouldn't use it in the first place. And if your experience is mainly with GPL and not MIT/BSD, then you wouldn't have much experience with companies in the first place, because they rightfully won't touch it.
And as an employee of a company myself, we use MIT-licensed projects only. We're thankful that most these days are. It enables us to use, modify, and always contribute back to the community. In song form: "You get what you give."
The GPL doesn't ensure you get a return on an investment—it ensures that you get only a small sliver of a much larger pie of possible contributions. It's nothing but a roadblock. In short, I really think your assumptions about this are invalid, and based on an idealistic sense of fairness, rather than real-world results which might contradict it.
Edit: furthermore, the original linked study also reaches this same conclusion, albeit in more professional terms. It's a changing ecosystem certainly, but the trend is toward more permissive licenses.
As for LLVM, the only companies selling commercial compilers specialize in HPC, embedded or other narrow markets and they have no reason to fork LLVM because in their niches they are better. Apple and Google contribute to LLVM because they use it and it benetifts them. And BTW, LLVM wasn't the project which killed commercial general purpose C compilers.
The importance of GPL lies in its ability to "open-source" whole software domains and put them in the hands of their users, at which point the choice of license becomes less important.
But there are simply many people here who think of themselves as hotshot entrepreneurs and take plenty of code without contributing back. I know I know ... they released their implementation of the x hundred nodejs logging library under MIT license. What a huge contribution to society! ...
To me, that says we need more pressure, not less.
That balding middle manager needs to make sure that that license is acceptable by his boss, by the people in the legal department, etc. For example, an innocuous throwaway line of a program that can only be used for "good, not evil," ends up needing to get the lawyers involved for clarification and special waivers ( http://dev.hasenj.org/post/3272592502/ibm-and-its-minions ). If the internal costs of using an encumbered program are too great, then chances are, it just won't get used; the company will either write their own version, or use a commmercial variant.
Argument through unattractive stereotype?
> To me, that says we need more pressure, not less.
Because more pressure makes us more free, I guess.
I mean that in the most genuine way possible - companies are made of people, and people make those choices. Those choices may be "good" or "bad" for the organization.
MIT/BSD give people in those companies the freedom, the respect, to make their own choices, good or bad. That freedom is more free, in spirit, than any of the more restrictive licenses.
There is nobody being bent to your will with GPL; someone who wants to use the code either uses it quietly against the terms of the license, or simply doesn't use it.
Restrictive licenses only close doors, they don't open them.
Exactly. The MIT/BSD/Apache 2.0 licenses are about trust and cooperation, not force.
> There is nobody being bent to your will with GPL; someone who wants to use the code either uses it quietly against the terms of the license, or simply doesn't use it.
I've always found it strange that GPL proponents think the GPL "forces" people to do certain things. They don't discuss the option of simply not using the software. Likewise, no one seems to mention the fact that the GPL, as a license, does not (and cannot) "force" anyone to adhere to it's terms; only a court can enforce the terms, and then only if you bring a suit against a violator.
This is the best description of both the purpose and the result of the license I've yet seen!
To me, it really aligns well with humanity. It matches the way people naturally work with each other. If you have a friend, for example, who always demands fairness with every situation, it can be a true trust mindfuck. For example, people who exactly split the bill at a restaurant down to the penny and the tax percentage based on what you ate. Or, people who will spot you $10 for a movie, but will force you to write an IOU first. I don't enjoy dealing with these sorts of people, since they make the assumption that I am untrustworthy. This is a type of negative reinforcement for your humanity. They make you feel bad simply for doing normal things. This is the GPL in a nutshell.
However, some people are the opposite: generous, giving, and the picture of unselfishness themselves. For example, picking up the entire check at a restaurant, or just splitting it evenly even though they had a smaller dish. Or spotting you $10 and saying "don't sweat it, I know it'll come back around." They make the assumption that you are trustworthy, and understand that you're human and fallible, but have good intentions. They make you feel good about yourself and about them, and you want to be friends with them; it's a positive relationship. This is what MIT/BSD/Apache feels like.
The second person might get burned sometimes by their unselfish generosity, but in the end, they make a lot more friends, and those friends like them and want to give back. Overwhelmingly, they receive more than they give because of the sheer multitude of positive relationships they build.
In the software world, I can absolutely feel this effect. When I see a project that's been GPL'd, I actually consciously and willingly resent them for it. I perceive they're being selfish with their work, they don't trust me to contribute back naturally, and thus they're making a bunch of pre-judgements and demands on me before they hand over the code. It's bullshit. I might use it if I have to, and I'll contribute back because I have to, but you know what? I won't enjoy it. I love open-source, but I can't shake that feeling of ill will.
MIT/BSD/Apache licensed software is the model of unselfishness. It's software being nice to me. It's software that trusts me and gives me the benefit of a doubt. It's software that I want to contribute back to, and I do, all the time. It's software that I choose to use over any alternative, because it's so much lower maintenance. It's software that's fundamentally cool. And furthermore, it's software that's likely to be higher quality, since it's more likely to be used by more companies with real large-scale projects. It's overwhelmingly better in all respects, and I recognize that in no small way.
If you're arguing for the GPL because you don't trust people who use your code to "give back fairly," then you don't get it.
You might recall this recent thread: "GNU sed 4.2.2 released, maintainer resigns" https://news.ycombinator.com/item?id=4956899
It cites http://lwn.net/Articles/529522/, which is a living proof of what you're saying. Two main developers of GnuTLS, that had written 10,600 commits out of 11,000 wanted to respectfully part ways with FSF. This is Stallman's reaction:
> Nikos, when you volunteered to maintain GNUTLS, the GNU Project entrusted its development to you. Your contributions so far are appreciated. However, the project GNUTLS does not belong to you.
> If you want to stop doing this job, you can. If you want to develop a fork of GNUTLS under another name, you can, since it is free software.
> But you cannot take GNUTLS out of the GNU Project. You cannot designate a non-GNU program as a replacement for a GNU package. We will continue the development of GNUTLS.
This really ought to boosts the morale of GNU contributers to know that even if they had contributed more than 96% of the codebase, they're still not trusted, and are deemed completely replaceable.
I see it rather the opposite. With the GPL, you make a piece of software free precisely because you trust anyone downstream, in perpetuity, whether you've met them or not, to make modifications (or not) to the code, to forked versions of the code, to branches of forked version of the code, whatever. The assumption is that each person can decide for themselves whether the software should be modified, and if so, in which ways. They can check with you or with someone else if they'd like, but they don't have to check with anyone before making modifications.
Companies that insist on MIT/BSD seem to be at least contemplating the idea that they don't trust downstream users, and don't want them to be allowed to further modify the software that was originally open source, at least not without separate permission. Hence they appreciate that the MIT/BSD licenses reserve them the right to use copyright law to keep downstream users from making modifications.
Or, they don't want to be forced to trust everyone, in perpetuity.
Where it doesn't make sense is for overall applications or something within your core competency. In that case, you're enabling your competitor to take your business. Unless you're a software as a service company in which case in doesn't apply as much.
Let's take an example. If you're a company that makes a word processor and sells it, it makes zero sense for you to license your work under a permissive license. But, your word processor needs to work with zip files (the open document formats) and security (encryption/decryption). For those pieces, it absolutely makes sense to use a publicly available (and tested/proven) component for zip files and security and to contribute back to said component. This is a place where permissive licenses make a lot of sense.
As for Free licenses, they make sense in certain circumstances as well. Do you think Linux would be where it is today if it weren't for the GPL? Or Webkit (Safari, Chrome, Chromium, soon Opera, etc)? Where you have a whole product and you don't want someone to be able to take the whole thing, add a few minor bits, slap their name on it, and then sell it as if they built it. Or a competitor to have full access to it and be able to improve it without sharing the improvements with you. In this case, having these projects be GPLed helped all of mobile computing (and desktop and server computing as well).
As others have pointed out, I am aware that companies are made of people and will contribute back to software when they don't have to. But, as a general rule, they will only do this when it benefits them, as it does in the above-mentioned scenario around specific components. They generally won't do this when it does not benefit them.
As for my experience, I founded and am lead developer of one of the all-time top projects on SourceForge (millions of users around the world, etc) and we use the GPL license on our core competency stuff (platform and tools). At the same time, we use MIT/BSD/zlib licensed code from other projects for specific components and contribute back our changes under the same license the source project uses.
As for dealing with companies, we have had 2 fortune 500 companies take our software and use it in violation of the GPL and our copyright (that we know of) and use it in commercial projects in an attempt to compete against us as well as dozens of smaller companies and individuals doing the same. None of them had any intention of ever giving back. As a general rule, smaller companies and companies within software that have a reputation to uphold (Apple, Google, Microsoft) are much better at bother understanding and obeying licenses as well as being good open source citizens and giving back.
Perhaps the reasons behind this could be studied more, but I think it comes down to something about how generic the software is, whether it can be extended/used effectively in commercial realms without being unnaturally restricted by the license, and what level/type of contributions are required for the continued success of the project. Both licenses work extremely well for their respective projects.
Similarly, I run a GPL project, and I couldn't imagine using a more permissive license, but the product is standalone and the GPL just works well for the situation. This is all making more sense to me now, thanks for your continued thoughts.
I license under MIT and BSD because I don't want to force people to give back. Often they even do without being forced.
Think of it this way: with the GPL you have 10 individuals and 3 open-source projects that might use your code. They have to contribute all their work back. Great.
With MIT/BSD, you have 10 individuals and 3 open-source projects; plus 1000 more individuals, and 500 companies, plus 50 city governments and 16 universities. Of those, let's assume that 25% are benevolent and would consider contributing back (extremely conservative if you ask me) and of those, let's say 60% actually do. So you get 15% of your contributions back, or 236 people who will contribute, which is 18 times more than the alternative. Yeah I made up the numbers, but even if you only reach a slightly higher audience—the people who would have used your software when it was GPL'd are probably still going to contribute back, so you've likely not changed your overall contribution rate, only increased it, and the only thing you'll have to deal with is some obscure emotional sense that "someone might be using my code and not contributing back", which is an absolutely useless idealism that doesn't produce code, fix bugs, or make your project more popular.
As in social contexts, having expectations of people you deal with only serves as a barrier-to-entry, and doesn't actually change the outcome. It turns our people will contribute back even if you don't force them to. And it turns out that sometimes, being selfish is a good thing. It ain't black and white, and you can swim in the grey area without melting or becoming a bad person. Somewhere in the middle, it works really well, and that's what MIT/BSD captures, in my humble opinion.
I think open source as a concept is successful. Open source encourages community development, giving back to the community, creating things for fun, working on interesting projects, and making things people can use for free. These are all good things that lead to successful projects.
My argument is not that the GPL is unsuccessful—that would be absurd. I'm saying, for a given market, would a project me more successful with a more permissive licence, and thus a broader audience, regardless of whether the majority of users contribute changes back?
It's a complex question and it might vary quite a bit depending on a lot of factors. In my example, you have a largely company-dominated market with few users interested individually. The Rails ecosystem is very similar to this: lots of companies use rails, and the GPL would change that market enormously, in my opinion for the worse. In fact, I'd venture to say that the rise of Ruby and Rails have accelerated our current software boom more than any other projects, if only for setting an example of how open-source and corporate worlds can coexist and reinforce each-other positively. This specific result was almost entirely due to the choice of the MIT license.
In that sense, you could say that the huge success of MIT-licensed software (in many other measures, such as the extremely fast rate that the community grew, the rate of software improvement, the use of the software to create real economic value, and the driving of the growth of the software economy) proves you wrong, also.
Using the GPL because you want to "get a return on your investment" is also selfish.
Instead of thinking of "selfish" as the thing you were scolded for as child (i.e., a bad thing), think of it as "self-interested". In and of itself, self-interest is neither "good" nor "bad".
Using your example, the person selling you bread is selfish -- the price you pay probably covers their production costs, plus some additional profit for their take-home pay. If they just started giving the bread away for free (i.e., they're no longer self-interested), you may see that as a good thing -- but what happens when the bakery closes down because it can't pay the bills any longer? Now, you're forced to bake your own bread, at least until a new bakery opens (if ever).
So, to re-iterate my earlier point with this new definition of selfish:
Taking somebodies code and not contributing back is self-interested. Some manager may see this as an easy way to get ahead, without realizing that they may actually be _worse off_ by not contributing back to the project (e.g., the project stalls out and now they're stuck using stale code and trying to maintain things themselves).
Using the GPL because you want to "get a return on your investment" is also self-interested. The self-interest there should be obvious, but for bonus points compare it to the definition of a cartel:
If you have some time, watch this video on self-interest: http://www.youtube.com/watch?v=URTFDijUEY8
- The Apache Foundation
- LLVM/Clang
- FreeBSD
- Google
The story could be different if they were in the business of selling closed-source compilers or OS's. Unix was a legal mess because companies sold their customized forks and fought each other. Linux started as a poor man's clone of Unix but it took off because due to GPL there was no business in fragmenting and killing it.
SQLite project (public domain, which is pretty much equivalent to permissive open source) gets lots of support from people selling closed source work incorporating it. So does BSD-licensed PostgreSQL.
There's actually a lot more incentive for commercial downstream players to contribute to a permissive open source project than a GPL one -- particularly a GPL one that is run by a commercial player and has a copyright assignment requirement.
> Linux started as a poor man's clone of Unix but it took off because due to GPL there was no business in fragmenting and killing it.
I thin the GPL was more important when Linux was first taking off than it is now, because the viability of F/OSS and its utility to commercial players had to be proven, so a license which compelled people distributing work to make it available under similar terms was necessary.
But that's been done now. The case has been made.
I think the BSD's are not a good example here in general. Most commercial Unices use bits and pieces from BSD without contributing much back. Just look at Linux where companies are forced to contribute back and thus the momentum it gained.
Certainly there are big projects under BSD-style licenses which get plenty of contributions back. But I think it's far more interesting how smaller projects do. For a big project it's in many cases better to contribute back because then upstream has to maintain your changes. Small libraries and tools however are quickly copied and dumped into the code base and nobody even bothers trying to send anything upstream. YMMV
That story about falling short of their fundraising goal -- I submitted it both here and on Slashdot, not realizing that most people/companies who donate money to the FreeBSD Foundation do so in the last two weeks of the year (for tax reasons or whatever). As it turned out, thanks to the huge amount of traffic they received from those stories, they raised 50% more than their goal and are now funding project proposals, sponsoring conferences, and much more:
http://freebsdfoundation.blogspot.com/2013/04/raise-million-...
I agree that small libraries and tools could be quickly copied into the codebase and forgotten about, but I question whether this is as much of an issue for any languages/platforms where you can dynamically link/load binaries (e.g., JVM, .NET) and you have decent package managers available (e.g., NuGet). In those cases, I think it's so simple to pull in outside libraries and use them that it's just easier for companies to contribute any fixes upstream instead of doing the work to maintain their own separate forks.
I am saying: don't be naive.
This is true in the same sense that a right to privacy and the 5th amendment is good for criminals or that freedom of speech is good for people who promulgate hateful ideologies. Just because a freedom can be abused, it does not follow that it should be abridged.
Not the contraversy which surrounded it, but the fact that GPL v2 is incompatable with GPL v3, and the suggested fix was "make your licence GPL v2+ and trust us for all time to never make a licence you disagree with". I am aware of several projects which will probably never get off GPL v2, and now can't merge in GPL v3-only code (as while the FSF seem to encourage people to make the code forward-licence compatible, they don't seem to encourage backward-licence compatability).
For me (and several minor projects I work on), that was the point at which we just threw our hands in the air -- we didn't have the time or motivation to pick our way out of this situation.
The FSF drives a hard line sometimes, frankly I think more ire should be directed at TiVo than FSF. The uppity jerks.
In the first place, IMO, "Tivoization" is an overblown problem ; in the second place, I think the anti-tivoization (and, insofar as they limit the use cases of Free Software, anti-software freedom) provisions of the GPLv3 have done more to prevent GPL usage than to prevent tivoization.
I think it dramatically highlighted the problem with the GPL approach: that, now that the value of open source software is demonstrated, while some people will take and not give back with the opportunity, lots will, and you end up getting more growth of usable F/OSS software if you don't burden the people downstream, and if you try to use compulsion, you get locked in a cycle of increasing the complications and restrictions for downstream users in a way that just gets more people to throw up their hands and not bother with your code at all. While the bad actors find new and creative ways of complying with your most recent license while subverting its intent, leading to yet more complicated licenses, with more burdens, etc.
I think the GPL was a legal solution to a social problem: companies were hoarding software and trying to patent it. But software patents are still illegal in most of the world, and the best way to ensure software cannot be patented is to publish it under a permissive license, and demonstrate prior art. Regardless of intent, licensing something under GPL is a kiss of death in certain cases, so it acts a bit like a patent anyway: it scares away commercial competitors.
Tivoization is also interesting, because we sort of have a modern day Tivo: Netflix. It's so convenient and affordable, people don't care how the video is being delivered. Instead of Tivo hacking, there's the Netflix API. (http://developer.netflix.com)
The fact is, software- and content-as-a-service have largely made the GPLv3 irrelevant, because the goals it's meant to enable, i.e. freedom and accessibility of software, have been realized in different ways. Society at large simply does not care about a Grand GPL future. It does care about privacy, and being able to export their data from the services they sign up for.
The GPL was created to help free software, which is more about freedom of speech, not open-source. It should be used only when your code is intended as a contribution to the free software movement, not when it is intended to simply be open-source.
Because no commercial venture uses Linux or BusyBox.
> The GPL was created to help free software, which is more about freedom of speech, not open-source.
FSF is actually more about making sure that as much software as possible is "open source" than about freedom of speech. Maybe you confused them with EFF.
I thought they were two heads of the same hydra.
I'm inclined to think that most (if not all) commercial offerings are going to use the second option, because there won't be much difference to the end-user and it means the company won't have to open-source their code. If Git was permissively-licensed, perhaps those companies would choose to link with the binary (or incorporate the code directly into their products) and contribute patches and bug-fixes back to the project.
When I find GPL licensed code, I feel like a kid whose grandmother has given him underpants for his birthday.
The non-playground stuff is MIT (something I did for work) or ISC, which is mostly harmless to anyone who wants to actually use it. People who use GPL are too hung up on controlling the distribution mode of derivatives; I understand the reason GPL exists, but I think it's a faulty premise to begin with.
Kinda like Peace Through Superior Fire Power.
Also, the preamble to the GPL reads a lot like religious/political rhetoric.
And I believe you're right, the GPL is (and was designed to be) a political statement.
http://eksith.wordpress.com/2008/11/24/gpl-vs-bsd/
On three separate occasions so far, I've come across a situation where someone has rejected a GPL piece (with basically nothing wrong technically; which is a damn shame) only to go with BSD the first time, ISC the second and, to my surprise, a closed source solution the third. Now 3 may not seem like a statistically significant number, but from the type of projects these were, my feeling is that the GPL seems to actively repel adoption to the point where even a closed source binary is more preferable.
The premise is to ensure quality code gets returned to the community, and I understand that, but quality code isn't what we usually get back. When the issue is forced, by and large, I feel people reject participation entirely, return the bare minimum necessary to comply (let's say an API which is GPL licensed while the rest of the library/application is under a different one) or, of course, non-compliance.
It's hard not to be a cynic these days, but I do think most people are basically good. And if you give good people the choice of doing good, they will not only do it, but also do it more earnestly. This earnestness in turn will produce, I believe, code of the best quality.
You live in a society of laws, that guarantees your freedom. BSD and MIT do not guarantee your freedom. They are free in a purely anarchist sense. This is not a good thing™.
I am not saying that GPL is bad, I am arguing that in complex scenarios this is not the right choice.
That feeling of wanting to use a GPL library, but not being able to open source your code feels awful, I know, but that feeling is there to get you to ask "Why cant I open source my code?" not "Why is the GPL restricting me?"
What I really dislike about that feeling you describe is when I think of a good project I'd like to build, but which would require the use of a GPL'd library -- therefore requiring me to license my code under the GPL. Every time that's come up, I've just opted not to create the project; in my mind, I just can't justify writing open-source code that's "free" instead of free.
| The GPL and it's code base exist to push
| the world towards the correct state of
| being.
You mean a particular point of view on "The correct state of being." What if I don't necessarily agree. Am I not free because my POV is not "correct?"
In any case, the public domain is free in an anarchist sense; BSD and MIT certainly are not.
Neither does any license, because licenses aren't laws -- they bind only those people who choose to be bound by them. And that's the big problem with the GPL, it really wants to be a set of laws for how software is licensed (and, from GPLv3, what features hardware is allowed to have, etc.), rather than just a software license, and that doesn't work unless you actually get something adopted by a legislature, rather than sticking it in a license.
BSD/MIT, however, are better at making the software I distribute usable to people downstream, including those who would also share their own work under similar terms. Sure, that also includes those who wouldn't, so with BSD/MIT, the public ends up with potentially a smaller share of a much larger pie than with GPL, but still more given back in total often.
?
Democracy = freedom to do what you want, as long as you don't infringe on other people's rights/freedoms.
So I think he wants to say GPL is more like democracy from this point of view, while MIT is more like anarchy, where everyone can do whatever they want with it (both good and bad).
The GPL certainly is more authoritarian and less like anarchy, but I don't recall public open-to-all-citizens elections for either FSF leadership or the specific content of the GPL, so its not very much like direct or representative democracy.
More like ideological autocracy, which is great if you agree 100% with both the ideology and strategy of the revolutionary vanguard, not so much otherwise.
I respect both use cases but ultimately I consider GPL code more like teasing to me, because as great as this code is, I know there is some limitations with this code and I won't be able to use it as freely as I'd want now or in the future.
So now, to spare me the mental pain of knowing there is a great GPL project I know I can't use, the first thing I do when I discover a new project is to check its license and if it's GPL I stop reading, plain and simple. I highly respect people releasing GPL code, I highly respect their motivations and somehow their political engagement but I treat it like if this code didn't exist or is a binary.
And for my own code I use the MIT License when I choose to share it with the world.
Until I can find a more "free" license I will stick to MIT as well.
Most people told me it's just not possible from a legal stance, unfortunately. Because honestly I would release most of my works as public domain for people to use as they see fit. Maybe copyright laws will change in the future, but MIT is a close 2nd. Plus it's easy to read and known well among developers(as others have mentioned).
If however, your project is a complete application (say a code editor, browser, or a game), whose primary audience consists of non-developers, then a GPL can be a good license, as it maximizes reach to your intended audience, while still allowing developers to contribute the project, and most importantly preventing free-riding by potential competitors.
Considering market size, # of active developers, and general amount of funding (corporate or otherwise), which is the best/most advanced, a major Linux distro or FreeBSD?
The answer to this question will tell you which license has better results.
Correlation does not imply causation.
https://en.wikipedia.org/wiki/Correlation_does_not_imply_cau...
I do, however, think many HN readers have a strong libertarian streak. In this case, when I say "libertarian", I mean true libertarianism (not the "tea party"-ish faction of the Republican party).
In this respect, I imagine most HN'ers prefer the BSD/MIT/Apache 2.0 licenses not because they want to make money off of free software in the future, but because they value personal freedom and extend those beliefs to their own software development. In other words, they want to use free/open software to avoid being trampled on by some company, but they're also not OK with being pushed around by any other "free" software developers.
Read a bit of this article and you'll see what I mean:
Talking about "true libertarianism" is no different than talking about "true conservatism," "true feminism," "true Marxism" or anything else -- these terms are all historically fluid, and accusing one another of not being "true" is one of the main activities among communities who unite under the supposed unity of an ideological stance.
Richard Stallman, it should be noted, has also been called a libertarian (http://actonline.org/act-blog/archives/1147).
But yes, you're probably right in the main about their not liking to be pushed around by others. Still, that describes a vast cross-section of human society.
HN may be predominantly politically conservative, but it seems a lot more neoliberal than neoconservative.
> So anyways, I make the conscious decision to use GPL, because it protects my work from exploitation by others (corporations are people too my friend, right?)
That is the basic difference between GPL and permissive licenses. GPL is for stopping people from doing things with your work, BSD/MIT/etc. is for permitting people to do what they will.
That would be like saying that you're "evil" for playing any kind of ball game without a helmet. This could be a highly beneficial and pragmatic thing in one context (professional baseball) but just silly and obnoxious in another. (Sandlot game with a wiffle ball.)
Stallman and the FSF make the claim that there is a new set of human rights concerning software that we weren't aware of before. That is the crux of the matter. Is it enough to let everything play out "in the marketplace" and let people vote with their dollars and their feet, or is there a new set of rights that should be enshrined in law?
I do think Stallman has a point, and that much good has come of copyleft and activism by the FSF, but does this give someone a right to declare what is absolutely good and evil? I don't think so.
To even try and restrict what others can do with code that I send to their browser to have it work in the first place, feels dumb.