Open source developers tend to be more left-leaning.
I haven't seen any statistics on that, so I don't know which way devs tend to lean. I personally
suspect that the age-related distribution (youngsters tending to lean more to left, older more to right, as their personal situations and experiences change) is stronger than developer licensing choices.
Writing software so it can be shared with everyone, to benefit society is a socialist principle.
Only on a surface level –– but that is definitely not the reason I ever choose to apply a "copyleft" license.
The core of socialism is social ownership of the means of production, as opposed to private ownership. Those who respect copyrights, know that the only one who can choose to distribute software under a different license than the original, is the author. (In cases where there are multiple authors, they all must agree.) Therefore, the very core of copyright licenses is based on copyright law and private ownership.
True socialists would never respect copyright! They would consider software to 'belong to the people' anyway.
Consider the
Free Software movement championed by RMS. It is not about the software having zero price, or that it is available to all. It is about the end users that have obtained the software to have the liberty to run and modify the software, to have full control over their hardware. At its very core, it is not social or socialist, it is really
libertarian instead.
(In political terms, you have a big difference between GPL and BSD licenses. GPL allows distributing derivatives under the same license –– share-alike; sources must be available to those you distribute the derivative to ––, but BSD licenses typically do not require sources to be distributed as well. Thus, one could argue that GPL is viral and capitalistic because it emphasizes the rights of the original author and end users, but not other developers; whereas BSD emphasizes the rights of other developers.)
I use a number of different licenses all the time:
- CC0-1.0: No copyright.
I use this for all my examples (although I sometimes forget to explicitly mark them so), because I want others to use that or similar code to solve specific problems. I don't do it because I think it will make the world a better place; I use it in the hopes of having less buggy software at my fingertips. Pure enlightened self-interest. - BSD Licenses: Permissive licensing.
I use these for device drivers, in the hopes that I can in the future use that device (which I obviously already own) on different operating systems also. The driver is required but not commercializable: it is not feasible to charge separately for both the device and the driver. - LGPL: Share-alike, but dynamically linkable to proprietary software.
I use this for libraries. I maintain the copyright and can sell individual licenses (other than LGPL) for commercial purposes, but others can use the unmodified sources, or by providing also the modified sources of the library to those they distribute the modified libraries to. As shown by the Qt Company (a Finnish one, BTW), this can be a working business model.
The reasons for doing this vary. I am quite self-centered, so I usually do this because I believe that applications that use my library will be less buggy, and therefore more comfortable and nice for me to use. - GPL: Share-alike.
I use this for applications I do not charge money for. There are two main reasons for this: one is when I get paid by someone to create the application or tool. (That makes sense the same way co-operatives work: the client is assured that they can continue to develop and modify the tools to fit perfectly to their needs. I do and must provide sufficient documentation for this, though.) The other is when I believe the tool or application can make things better for me somehow. Not necessarily directly; it can for example open up completely new avenues for me to be paid to create such tools. - Proprietary licenses, for COTS and other paid software.
Even with these, I really like giving more liberty to the end users (but not to re-distribute the software). This is why I currently favour using e.g. Python 3 and Qt 5 for the user interface –– it being an interpreted language, an end user can make any changes to the user interface they want ––, and keep the important business logic and number crunching in native compiled code libraries. A major reason for this is that if one provides user support in some sort of a forum, one can also collect and evaluate the changes end users ask for and have provided. Instead of paying expensive consultants to hopefully come up with an user interface that end users like, you can make it a continuous process the users themselves help direct. Not only it can be cheaper, but depending on your initial user base, it can significantly increase the lifespan of the product.
However, the most important point is how 'copyleft' developer
communities work.
They are nothing like a socialist commune
at all. One could argue that they're extremely capitalistic, except that the exchange medium is not money, but time, effort, and knowledge. (This is a very important point, because it is also the reason why so many people new to such communities get so frustrated with them. People are used to
customer support, and naturally initially try to treat developers the same way; and that will backfire. Hell, we see the same here at EEVblog forums, whenever someone demands anything!
And properly so.)
The advice I often give is perfect illustration of such communities. I always tell people to provide maximum amount of information, and show that they have tried to find the cause of the problem themselves, and are willing to spend the time and effort to diagnose, test, and fix the problem. The developers will ignore you otherwise, because time and effort is the 'money', and they don't want to waste theirs. Now, if there is a bug to be fixed or an enhancement to be implemented, it will help
everyone; true. But the developers are not interested in
everyone, they're interested in what they themselves use, and what their users (in the same organization, or otherwise the people paying for the developer for their time and efforts) use. Essentially, they're only concerned about the subset of
everyone that directly implicates themselves. Being somewhat logical –– kinda-sorta requirement for an efficient developer! –– they know that
everyone includes
myself and
those who pay me, and is the impetus for doing the work.
The fact that
others in
everyone benefits, is just an ancillary reason, and is related to the secondary feature of such developer communities; the co-operativeness. Basically, because the cost of a copy is zero (but the cost of having an end-user is
negative, as they usually need some sort of support but do not contribute anything themselves), having other developers contribute is a net
positive for each individual developer. It is a very commercial/capitalistic/individualist approach, that just happens to look like 'socialism' on the surface.
(The difference between
co-operatives and actually socialist organizations like
sovkhozes or
kolkhozes or even the socialist
kibbutzim in Israel (1927-1991), is that the latter do not work long-term, whereas the former, working on capitalistic principles –– being an
enterprise –– reducing the costs of production by sharing amongst the participants, do.)
(I think I explained all this poorly, but that's only because of my not-so-good language skills, not because there is anything hazy about the stuff I'm describing. I'm just so used to it, having integrated this into my operations profile almost two decades ago, it's like breathing to me.)