The Open Source movement, as championed by the OSI, prizes absolute openness above all other concerns. Openness, they claim, is an absolute good, from which all other virtues flow, not to be questioned or criticized. It doesn’t matter if that openness enables evil in the world, without openness we cannot have truly collaborative software development communities. So the claim goes.
I want to question this claim. Openness seems like a good thing, but I think there's plenty of room for disagreement. I am going to argue that there is nothing absolute about openness, that openness is not an end in itself, but a tool that we can use for good or ill. It turns out to be a pretty good tool when used to build and empower communities. But it can also be an effective tool for exacerbating existing injustices, and creating new ones.
Maybe we’re valuing the wrong thing. What if we look at Open Source values through the lens of moral philosophy, by applying Scanlon’s contractualist theory of morality? When we do that, I think it becomes pretty clear that we ought to discard openness as an axiom, and start thinking about other ways to build software collaboratively that do not make us accessory to horrors. We can create open communities, better communities, more inclusive communities, without Open Source.
The Open Source movement has always been focused on code. The result is a system that sadly neglects people. Many maintainers find themselves in a curious place. On one hand, we have people who regret seeing their code used for unethical purposes, but, because of the Open Source values they previously embraced, are unable to do anything except watch their code become weaponized. Others, perhaps not grasping that the gift economy has been usurped by more powerful forces, struggle to figure out how to make ends meet even as their labor creates immense value for others. We find ourselves in this position because the key Open Source values exacerbate an existing injustice: Because the OSI definition of Open Sources values the consumers of code over creators, Open Source helps concentrate power in the hands of already powerful actors at the expense of maintainers. I feel that not only could we do better, we have a moral imperative to find better development models.
In short, Open Source doesn’t provide the democratization that proponents think it does. Instead it creates opportunities and incentives for the privileged to unjustly exploit maintainers. Moreover, insofar as we want (and we do want) to make community-driven software development a more inclusive place for everyone, then it is particularly important that we are not inviting the already disadvantaged into a system designed to exploit them.
Instead, I’d like to replace ideologies that focus on code, and what others can and cannot do with the code we create, with ideologies that focus on people, specifically with a focus on who benefits, and who doesn’t, from the code we create. What does a people-centric collaborative software development model look like? I’d like to explore some basic properties that such a model ought to have, as a starting place for building new institutions to support productive, non-exploitative software development.
What we owe to each other
Morality is inherently, whatever theory you subscribe to, about people. (Footnote: The following discourse isn’t going to satisfy my fellow moral philosophers. I apologize for that; my goal in this section to address an audience new to these ideas. The result is something rather watered-down and anodyne, but hopefully nevertheless illuminating for those who have never encountered these ideas before.) We don’t (usually) worry about the moral consequences of, for example, treating a thing badly, except insofar as that treatment has consequences for people. Without worrying too much about the nuances around this claim (and there are plenty), this is largely because we don’t think that objects (like a toy, or a shoe) are morally considerable, that is, put crudely, worth worrying about (although cf. Shintoism). But we do think that people are worth worrying about, that our treatment of them matters deeply. Some of us will extend this consideration to animals; a few to plants; certainly many of us will extend it to entire ecosystems. But very few of us are worried about how the outcome of an action affects a stone, for example. And almost no-one isn’t worried about how the outcome of an action affects other people, which is the basic point I’m trying to make.
So, people come first when we worry about the outcomes of our decisions, that is to say, when we reflect on the morality of an action. Morality is a question of how we treat people.
I myself have become increasingly convinced that T.M. Scalon’s contractualist theory of morality is a productive framework for thinking about how to treat people. I’m not going to summarize the theory here, as it has quite a lot of moving parts—you can read the Stanford Encyclopedia entry on your own time. But I will (roughly) summarize the key takeaway for this discussion, which is that insofar as our concern is understanding how we are to live together as humans (and that certainly concerns me, and it sure as hell is a central concern of any collaborative software development model), then the normative content of our moral judgments derives from whether we are treating our fellow humans as humans. If our choices derive from (or can ever be justified by) dehumanizing our fellow humans, then those choices are wrong. And therefore if our choices come from (and only from) a place of respect and recognition of other people, then our choices are right. (Footnote: An important part of Scanlon’s theory is that intent doesn’t enter into this determination. The road to hell is paved with good intentions. The question is this: If we look at the complete set of all reasonable justifications for a particular choice, do any of those dehumanize others, regardless of intent?)
I like this theory, because it provides a fairly straightforward litmus test that we can apply to different situations. And, unlike consequentialism, it doesn’t require us to engage in fanciful accounting of future (and hence unknowable) outcomes, nor can it be easily tweaked and twisted to give us the answers we want. So let’s run with it, apply it to Open Source, and see what comes out.
A moral appraisal of Open Source
Unlike ethical theories, Open Source dogma is concerned primarily with code, and to the extent that it is concerned with people, that concern is with the wording of software licenses. Open Source, as defined by the OSI, is focused on what people can do with code that is licensed as Open Source. (If you haven’t yet read the OSI definition of Open Source at the previous link, I encourage you to do so now.)
You might not think, therefore, that there are interesting moral implications or that we could use an ethical theory to judge the Open Source definition, but I disagree. Code is created by people, and consumed by people, and because the Open Source definition attempts to regulate how people can interact with code licensed as Open Source, choosing to create or to consume Open Source software is, therefore, a moral choice—a decision whose outcome affects others, and reflects the relationship we wish to have with them.
I encourage you to read the definition for yourself, but there are two principles in particular that I think deserve closer attention:
1. Free Redistribution
The license shall not restrict any party from selling or giving away the software as a component of an aggregate software distribution containing programs from several different sources. The license shall not require a royalty or other fee for such sale.2. Source Code
The program must include source code, and must allow distribution in source code as well as compiled form. Where some form of a product is not distributed with source code, there must be a well-publicized means of obtaining the source code for no more than a reasonable reproduction cost, preferably downloading via the Internet without charge. The source code must be the preferred form in which a programmer would modify the program. Deliberately obfuscated source code is not allowed. Intermediate forms such as the output of a preprocessor or translator are not allowed.
These clauses exist for what was perceived by their author to be a very good reason: The very core of Open Source is the idea that everyone should be able to take advantage of Open Source code. In principle, this sounds great! There shouldn’t be any grounds for excluding people from accessing the source code, and making what use of it they want. That just is the very idea, and the goal is a world in which source code is set free, and software development democratized so that anyone and everyone can participate, and anyone and everyone can benefit.
But, if we dig a little deeper, we see that these two clauses have an interesting feature: They privilege the consumer of Open Source code over the producer, by requiring that the producer give up certain rights. The producer is not allowed to put any conditions on who can use the code. Moreover, the second clause effectively prevents the producer from charging for access to the code—they are permitted to do that, but those who receive the code are permitted to redistribute that code for free, effectively negating the producer’s ability to charge. This is actually a quite important point that we will come back to later, but for now the important takeaway is that producers, by adopting Open Source, have locked themselves into a situation where they lose all control over their code once it’s released to the wild.
This is pretty absurd. But it’s a predictable outcome when we lose sight of our moral compass, and start prioritizing things and ideas over people. Let’s explore this situation in more detail.
Who benefits from Open Source?
At first blush, this seems an easy question to answer: Everyone! You get some code, and you get some code, and you get some code!
But this only holds true in libertarian utopian fantasies. The reality is quite different: It is true that you and I benefit to a certain degree, but large companies derive massive value from Open Source, and have every incentive to do so without reciprocation. The key is that Open Source is literally about exploiting unpaid labor. One of the key benefits of Open Source is that that by outsourcing development to teams of unpaid labor, companies can reduce their costs. This was a large part of ESR’s argument for why Open Source is a competitive advantage for companies, although he couches the point as “cost sharing”—the idea being that companies can share resources to develop open solutions. The reality in 2019 is better described as companies outsourcing their development to free labor to realize significant cost savings.
At OSCON 2019, Amazon’s VP of Cloud Architecture Strategy, Adrian Cockcroft, reinforced this view, and took it further:
So now that Open Source business is using the developer community as a force multiplier for engineering: It means they don’t have to invest as much in engineering as if they were doing 100% of this themselves, because the community is actually doing some of their engineering for them...and then you take the enthusiasm of those people, and you use that to create market awareness, and you invest in that market, so know you’ve got your marketing…you’re using open source to magnify your effect in the marketing side.
Although Adrian is specifically talking about companies who build business models around Open Source products, what he says can be applied, mutatis mutandis, to the way Amazon and other large companies exploit Open Source software as well. So while you and I can reap modest benefits from Open Source, commercial enterprises are able to literally hire free labor for their engineering and marketing departments, at scale. This is certainly a real advantage of Open Source—for those companies.
OK, fine, so companies can see real monetary benefits from the free labor Open Source provides. Is that really so bad?
Yes. Yes it is.
Let’s look at how this plays out on the maintainer side of the equation.
The costs of Open Source development
The challenge we face is not that companies are getting free labor. The challenge is that when large corporations are able to extract large amounts of value from open source, those providing the value are expected to continue to do so on the ground that the gift economy is ideologically pure, and that requesting money for labor provided is greedy, at best. It creates an informal institution, whose entire aim is maintaining a status quo in which Open Source maintainers feel obligated to continue to support software, even when it’s not in their own interest.
Which leads us to the bizarre situation in which those who have decided to pursue Open Source as a full-time career are in a constant state of panic. Consider, for instance, Buster Neece, the maintainer of AzuraCast. He has, for reasons that are utterly irrelevant to this discussion, opted to work on AzuraCast more or less full time. And why not? It’s a piece of software that delivers value to its users, and he is rightfully proud of what he’s built. And yet, Buster has, time and again, pleaded for money from the community, from those who derive value from the software. And plead he must, for without that money, his ability to simply pay the rent is at stake.
What kind of world have we created where we encourage people to sacrifice their free time, their families and friends in the name of creating software? This world we live in is, let’s be honest here, fucking deranged, and its values twisted up beyond recognition. We value software for software’s sake, and ignore the human costs—and worse, we encourage the very creators to themselves devalue their own labor, believing that if volunteer work is good, then more volunteer work is better, unto the point of burnout. By any rational notion, whether you subscribe to Scalon's contractualist ethics or not, this situation is morally repugnant.
But it gets worse than just the plight of an individual. Those individual’s choices, in the face of harrowing demands upon their time, can affect millions of others. Consider this flaming piece of the NPM hellscape. I’ve spoken with Tierney, I know what the module in question is. I won’t reveal anything here, but I will say this: It is a critical piece of Internet infrastructure that was abandoned because the maintainer could no longer uphold their perceived obligations, and decided that the demands upon their time were no longer worthwhile. This module represents a single point of failure for a shockingly large swath of the internet, and yet I cannot imagine any reason to blame the maintainers for jumping ship.
Never mind the sagas of leftpad and event_stream, modern versions of Grimm’s fairy tales, stories we tell our children to scare the shit out of them, and keep them from wandering into the woods alone at night.
We have built a system that depends upon the unpaid, unappreciated labor of thousands, and then created incentives for them to jump ship, leaving the rest of us at the mercy of the Fates. This isn’t sustainable. And it sure as hell isn’t morally defensible.
The Problem of Evil
There’s also the question of who fails to benefit from Open Source. What happens, when Open Source code is used by individuals or organizations to commit atrocities or to violate human rights? Many Open Source developers and maintainers are waking up to the idea that this is happening, today, are unsettled by it, and are looking to change the way their code can be used.
At this moment in the United States, families and children are being locked away in camps in what appears to be a gross violation of human rights by a government entity called Immigrations and Customs Enforcement, or ICE. And it is pretty clear that Open Source code is playing a role in this situation. Which seems to imply that anyone who has ever contributed to the Open Source projects utilized by ICE are complicit (at least to a degree), in these human rights violations. At the very least, those software maintainers would in some cases strongly prefer their code not be used for these sorts of purposes.
To wit, consider the case of Chef, a company that builds and sells support contracts for Open Source tool to manage computer infrastructure. It recently came to light that Chef had done business with ICE, who used the product in the course of their business with these incarceration camps. When the news broke, Seth Vargo, and ex-employee of Chef, was particularly distraught, as he knew that a great deal of Open Source code he created and maintained was being used. So he did something incredibly brave: He pulled his code from GitHub, more or less instantly disabling Chef’s offerings.
This was, at best, only a temporary measure, as the nature of Open Source means that Chef need only pull archives of Seth’s code to restore the lost functionality, and legally speaking there is nothing Seth can do to stop this, because he licensed his code as Open Source. And Open Source code is available for evil people to use for evil purposes.
Indeed, the very nature of Open Source means that of course Open Source code can and will be exploited to violate the rights of other. Indeed, according to the OSI, this is not only a natural consequence, but is to be tolerated. Tolerated! Here is what OSI has to say on this very topic:
Can I stop "evil people" from using my program?
No. The Open Source Definition specifies that Open Source licenses may not discriminate against persons or groups. Giving everyone freedom means giving evil people freedom, too.
Whiskey. Tango. Foxtrot.
What if, like Seth, or like many others, we’d rather not have our hard work used to create and perpetuate injustices, even human rights violations? In a world that places openness above all else, there is little that we can do.
Open Source is morally problematic
If I am being bombastic, I would go so far to say that Open Source is a moral travesty, even as it has provided us with innumerable benefits. This is not a utilitarian calculus. This is a claim about what we owe to each other. Open Source encourages us to strip away the humanity of maintainers, and focus only on the code. Only the code, and its freedom (as though a thing can be free), matter in the Open Source universe. But by dehumanizing maintainers, Open Source has created a culture that discards moral considerations in the name of profit.
Open Source encourages theft
I think we can agree that if I extract value from your labor, you deserve compensation. Money just is the medium for exchanging value, and without compensation, there is no fair exchange of value. There’s just me stealing your labor. The users of AzuraCast are stealing the labor of Buster Neece. Amazon is stealing the labor of MongoDB’s engineers. It’s a tragedy of the commons at planet scale.
What makes this theft particularly pernicious is that it is awfully casual, and really quite meaningless in the individual case. Were I a passing user of AzuraCast or event_stream, it is not clear that I owe Buster Neece or Dominic Tarr a financial debt. The software is free to download, free to setup, free to use. The support forums (often GitHub Issues) are open to anyone to post a request (actual replies on the other hand…).
Indeed, the very nature of Open Source is to encourage us to think in this way, that we are entitled to the software, because of course using Open Source software in whatever way we choose, unencumbered of obligations of any kind, is my ESR-given right. It’s built right into he very definition of Open Source.
1. Free Redistribution
The license shall not restrict any party from selling or giving away the software as a component of an aggregate software distribution containing programs from several different sources. The license shall not require a royalty or other fee for such sale.
Open Source undermines the autonomy of maintainers
Precisely because Open Source is so focused on the agency of those consuming software, it automatically rejects the agency—and hence the humanity—of maintainers.
What if we, like Seth, wanted our agency as creators considered? The creators of JSON inserted an interesting clause into their license that JSON is not to be used for evil. That’s an awfully broad term, open to interpretation, yes. Coraline Ada Emke recently published the Hippocratic License which attempts to leverage the UN’s Declaration of Human Rights to achieve something similar in a way more likely to have legal bite. The 996.ICU license protests the working conditions imposed upon Chinese software engineers, by enshrining restrictions on working conditions on the users of the licensed software. These kinds of clauses exists as a plea to entertain the idea that creators should have some say over their creation, that they are human, morally considerable entities, not to be forgotten on the way to monetizing all the things. They would really rather not see their work contribute to injustice in the world. (So say we all.)
Yet, as I’ve mentioned, this runs counter to the OSI’s position on the absolute importance of openness. If we want to consider the moral implications of our code, we cannot do so seriously when constrained by the dogma that openness is more important than the people our code impacts (or the people who create and maintain that code).
I think there’s still a lot to be said on this topic. There’s growing interest from some quarters in preventing their work from being weaponized, or used to perpetuate injustices. I think this is a perfectly rational desire, but as you can see the whole thing is incredibly complicated. Watch this space.
Open Source creates incentives for maintainers to undermine their own best interests
OK, so if Open Source is immoral, why not just walk away from it? Why not do…well, something else? Because it’s not that easy! Open Source has created a culture in which we expect that developers will contribute to Open Source code, as a matter of course. Better yet if they are maintainers. Better still if they are maintainers of popular projects. We lionize the creators of Open Source software, not just individually, but systematically. We have built entire institutions around the importance of being a part of the Open Source movement.
Want to be taken seriously as an engineer? Want a job in Tech? Need a portfolio of work? Require a measure of reputation in the developer community? Better have a track record of contributions to Open Source! Or better yet if you can show that you are a maintainer of a popular Open Source project. For many, you are your contribution graph.
Moreover, we live in a culture that values helping others at our own cost. We valorize selfless acts of kindness, and I think Scanlon’s ethical framework makes it easy to see why. Sacrificing something of yourself for others is the ultimate expression of respect for a fellow human as a human. But this expression of respect can be taken too far. When we engage in sacrifice until we have sacrificed all we have to give, or that sacrifice begins to impact our friends and family, or when we begin to expect that sacrifice from others, these are all situations where we fail to respect the humanity of people: ourselves or our family or other helpers.
And indeed, this kind of expectation, that we are entitled to the sacrifices maintainers make, has become the norm, as one commentator has shared. This culture of entitlement is rampant in the Open Source world, but maintainers have only so much to give. This culture of entitlement that surrounds Open Source, was created by the expectation that we get our software for free, is deeply morally problematic.
Working with Open Source is a privilege that, when exercised skillfully, gets you the best reputation, the best jobs. If you don’t have the time or money or will to take the time to provide labor for free towards an Open Source project, then you find yourself increasingly in the margins of the tech world. Open Source perpetuates systematic injustices. The ability to participate creates new opportunities to participate, and failure to participate lands you in a place where you cannot find the resources to continue participating. So get your commits in while you can.
Open Source denies the humanity of maintainers
Let’s tie this all back together. Scanlon’s conception of morality tells us that choices that devalue the humanity—the agency, the rationality—of others are wrong, and choices that respect the humanity of others are (therefore) right.
When we choose to participate in the world of Open Source, whether as maintainers or as consumers, we perpetuate systematic injustices against other maintainers. We contribute to a gestalt that rewards Open Source software and contribution. We extract unpaid labor from a workforce that might or might not want their labor extracted thusly. We send a message that we don’t care about the intents, and therefore the agency, of the maintainers of the software we use.
Open Source is unwilling to consider the humanity of those impacted by code
In the same vein, precisely because Open Source values maintain that Open Source code must be made available to all without discrimination, every time we release new code into the Open Source ecosystem, we risk our code being used by actors intent on doing evil, on creating injustices, on denying the humanity of those impacted by our code. Even if we have the best of intentions, Scanlon is pretty clear: Our choice to release code that could be used in this way is wrong.
Open Source is Immoral
Here it is. If you’ve followed me this far, and haven’t figured out where we’re going yet, the only possible conclusion is that choosing Open Source is therefore wrong, in the strongest moral sense of the term.
So what if we just didn’t? What if we chose not to participate in the Open Source ecosystem, while attempting to keep what makes Open Source actually valuable and interesting, what would that even look like?
People > Software
Well, it’s early days yet, but leveraging Scanlon’s ethics, we can at least see some principles, some concrete points of leverage to rally around and to focus our collective thinking around the kind of change that collaborative software development world needs to see.
If we want to move into a post-Open Source world, we first and foremost need a new term for what it is we do that captures what we stand for. I don’t know what that term is, but it isn’t Open Source (capitalized) or open source (lower case) or F(L)OSS (which is just Open Source (capitalized) with a conjunction to something else). I’m going to use the term “collaborative development”, but only because I’m not very good at naming things, and we need a name, and it will do for now.
Here are some candidate principles to guide an ethical conception of collaborative development.
Maintainers are people, and deserve to be treated as such.
Concerns about the “freedom” of software are overblown, and are just an attempt to hide from the complexities of dealing with people, to hide behind that false claim that we can separate technology from messy human things like politics and morality. Let’s instead begin with people, and treat technology as an extension of maintainers as people, an expression of maintainers’ needs and desires. Let’s stop thinking of software as a good to be traded freely, and start thinking about software as a product of human labor, labor that deserves consideration.
Technology exists to serve human needs.
(And not the other way around.) Trying to isolate software from politics is like trying to isolate cold from heat, or the evening star from the morning star. Instead of trying to isolate technology from messy human concerns, we should instead embrace this relationship by acknowledging that software is first and foremost meant to solve human problems. Our failure to collectively acknowledge this order of priority is what’s landed us in this mess.
We’re all in this together.
Open Source values large economic actors that consume software over the maintainers. Open Source creates incentives against contribution back, and sharing experiences. But one interesting effect of making the source code freely available, is that it can help lift others up—by giving them the opportunity to understand how their tools work, they can improve them. This in turn opens our tools to improvement through widening the range of experiences that inform how those tools should work, broadening the kinds of problems that exist that those tools can help solve. When we recognize that making source code available is first and foremost a mechanism for sharing and growing in the context of an ever-expanding community, we also recognize that the virtues of collaborative development are human-centered virtues. Not technology-centered, or business-centered. But Open Source as an institution doesn’t cast the virtues that way, because of its focus on making collaborative development palatable to business, ends up privileging business over the shared community of creators, and transforms would-be contributors into passive consumers. We should acknowledge that making source code available is first and foremost a way of acknowledging our own individual limits, and an invitation to others to help us transcend those limits, and find ways to capitalize on that invitation.
What comes next?
OK, there are some values. I bet we could come up with more. But for now they are just words on paper. How do we socialize them, normalize them, make them the default way that we approach software development as a community of collaborators? Institutions.
Our current institutions—including formal institutions like the OSI, and informal institutions like the relationship between Open Source contribution and recruiting—, need to shift because they lead us to make morally bad choices, choices that devalue human agency and rationality.
So we need new institutions to encode, propagate, and normalize these Human-centered values. Institutions that acknowledge that humans are at the center of technology, and that morality is a central part of thinking about and regulating human activity. Not technology, not “freedom” of code. We need to incorporate moral values and an understanding of the political nature of humans as first-class citizens in the pantheon of software development. We need institutions to legitimize this view, to show that collaborative development can be more than just the freedom to take code from maintainers for your own ends, but as a tool for advancing our very humanity, to frame software development at very large, social scales in just the way the FSF and OSI have done before. To not just legitimize the plight of the maintainer, but to center maintainers as humans, make them the center of a new value system, and normalize those values among developers of all stripes.
That’s a tall order!
The Ethical Source movement, started by Coraline Ada Ehmke, aims to redefine the terms by which we openly collaborate on software. She offers her own alternative to the Open Source definition, one that places ethical concerns front and center. I think this is a pretty exciting development, and worth discussing further.
I envision Maintainerati as an additional step in this direction. By pure chance, three humanities academics are now at the reins, and our mission has become to understand the challenges that maintainers face at both a local and a global scale, and to provide the frameworks for overcoming those challenges, which includes normalizing human-centered principles like those I articulated above as a replacement for oppressive OSI dogma. There is undoubtedly room for other institutions as well, as we are going to need all the help we can get. We'll be setting up a discussion forum in the coming days, where we hope you will join us to move this conversation forward.
Fin
This has only been a cursory introduction to just how problematic Open Source software is. There’s still a lot to be said. I’ve laid out some puzzle pieces, and showed that they belong to the same puzzle, but I haven’t really begun to assemble them yet.
I don’t know what comes next, what a post-Open Source world looks like. But I want to find out. I want to know what a model of collaborative development that values the autonomy of the creator, and the value of why they create, over the “freedom” of code, over the interests of the powerful, looks like. This is something that can only be found from the bottom up, by rejecting the institutions, formal and informal, that have framed the conversation for the past twenty-plus years, and creating a new set of principles—principles founded on the mutual respect for our fellow humans instead of abstract concepts. It’s not going to be an easy road, or a short road, but I am committed to understanding what this new model could be.
We live in a world in which there is a lot of weight placed on “Open Source values”. This is just dogma. I want to shift the ideology away from “politics-neutral values” and onto people. What’s valuable are people. Everything else, including software, is instrumental. What does a people-centric model of collaborative, open software development look like?
I have no idea, but I’m really excited about the possibilities. Will you join those of us exploring them?
Further Reading
If this topic interests you, then I recommend the following reading:
- https://firstdonoharm.dev/resources.html
- https://words.steveklabnik.com/what-comes-after-open-source
- https://words.steveklabnik.com/the-culture-war-at-the-heart-of-open-source
- https://thebaffler.com/salvos/the-meme-hustler
- https://www.vice.com/en_us/article/43zak3/the-internet-was-built-on-the-free-labor-of-open-source-developers-is-that-sustainable
- https://twitter.com/coralineada/status/1176615075408482305
- https://twitter.com/maybekatz/status/1176343575916773378
Top comments (65)
"I think we can agree that if I extract value from your labor, you deserve compensation."
I don't think we can agree on this. If I choose to give away my labor, I don't deserve any compensation.
Do you deserve compensation from me if I gain value from reading this article?
Releasing your code as open source is a choice. If you don't agree with an OSS license, don't use it!
And the same would go for the possible use you code can get...
You can maybe find a way through licenses to prevent usage in certain fields that you don't want your code to be used... But really you could change something or get an idea.
Bad use will ALWAYS be there.
"Choice" is the key word here.
Reading the article I felt like if OSI was pointing a gun at OSS contributors' heads.
NO! People contribute openly because THEY choose so. And they choose so because they WANT SO.
Open source is among the top reasons why IT is eating the world and advancing so fast, creating solutions to humanity's problems, opportunity for people to earn a living for themselves, their family, to contribute to society.
It's sad that the author got the idea so wrong...
As an open source developer, I solve problems because they're a problem for me. Once I solve the problem, I open source my solution because I don't want anyone to have to re-solve the problem that I just solved. Thousands of people run my code. If this is what being exploited feels like, then count me in.
The friends and collaborations I've made with random strangers on GitHub have given me a better sense of humanity and community than some of my best physical community service projects.
Also, to the open source devs don't maintain their stuff, thank you for making it open source so I can fix/update it myself when I need new functionality.
Your analysis rests on your producer-consumer model. But this is the wrong starting point for successful open source projects, where my definition of successful is a diverse and broad pool of contributors.
Open source (not free software) is a pragmatic model to encourage co-operation between developers. Pure consumers are simply accidental beneficiaries. Economically, they may appear to be exploitative 'free loaders', but unlike real examples of free loading (such as polluting), pure consumers of code do not impose any costs on anyone. However, your analysis says they are, by saying that these consumers are exploiting the developers. This is only potentially true if the developers are foregoing revenue by not charging consumers when they could. Traditionally, this requires technical copy protection and legal copy protection. However, at the same time, these barriers have a cost too: they block or impede co-operation from other developers, due also trust barriers.
Ironically for your argument, a closed-source model where users are financially 'exploited' by developers makes potential code contributors wary that their contributions will be exploited by those selling the software. This is a strong, in fact probably fatal, barrier to gaining developer contributions. Open source licences remove impediments to co-operative code-development by parties who are strangers to each other. It is remarkable, actually.
The open source model indeed does not make sense where a developer gets little relative benefit from encouraging other developers to contribute. This might because they don't need other developers, or can't attract them (perhaps the user-base is too niche). I said 'relative benefit'; perhaps the developers have some IP that is so compelling that the potential for user payments is very high, and that it is better to take these revenues, stay closed source and pay developers.
In these cases, the developers' economically optimal decision is not to go open source.
But to repeat myself, in a genuinely successful open source project, apparently the opportunity cost of user payments is actually lower than the benefits of attracting external developer contributions to the mutual benefit of participating developers. This is not conjecture, this is really happening, and a good scientist bases their theories on observations. Your essay sounds like the famous academic who lamented 'it might work in practice, but it doesn't work in theory'.
I do not dispute that some projects which started as open source find themselves in a position where it's not the right choice. I think there are examples of VC-financed startups that went open source as a tool to gain market share, but were not able to get any compensating benefits (that is, they did not get a critical mass of external contributors)
Really interesting article. Do you think there is anyway we can keep our source code open to read and contribute to for security reasons, while still being able to publish work for money?
It really sucks that developers who pour thousands of hours of work into a project just to have someone quickly grab the source code, without even a thank you.
I do! I don’t know what the best way is, but the Prosperity Public License is one possibility. prosperitylicense.com/ (I really want to drag License Zero into this conversation!)
Suggest what you're attempting to do is "Open Development". Something in the 1970's/80's we discussed. (turned into a LinkedIn article by request, see linkedin.com/pulse/open-source-bro...).
At the start of Open / Free Source, the unspoken idea was that the code was attached to the people who wrote/developed/maintained it, and they were attached and pulled along by it, sort of like a parachute, lifted into the air by attention/use.
In the excitement of the moment, many saw opportunity and the desire to "cut the lines" because they didn't like where things were headed, so many hard landings happened. That is how people who did the code got separated from it. And to cover for this, retconning spliced the lines as needed. Your might call it a moral failing, or a lapse in judgement.
Often discussion of this was considered "religious" and beneath the "pure code" desire. Many of the comments I see here want to still present the notion that "the code speaks for itself", as if it is "bootstrapped" from developers minds, to become something unassailable, "above them all". Perhaps another religious abstraction?
It is this "unassailable" fantasy that is used to remove "impure" people from the code, sometimes entirely missing the point of the code in the process, possibly obfuscated. This loss of integrity sometimes even kills the code longer term, where then certain open source projects "wander in the wilderness" until the integrity is restored. Perhaps the price for such "purity"?
When someone claims detachment from generation of code, it's really rather disingenuous because they did make it happen. It's immaterial as to "why". It's even worse to jump to the conclusion that because one claims to do this for one's own contributions, that another's can so be detached. This is the process by which integrity is lost, and people are detached as unnecessary destruction.
Suggest that if you focus instead of "prosperity" on "integrity", you deal with the fundamental issue of separating people from code. Perhaps the rest of the unfairness you correctly cite falls out of this more concise remedy.
And this is still quite a battle, because it's hard for humanity to retain integrity in a fair statement, because many need to distort it for a given ends. What I've found is that sooner or later integrity matters, and is reasserted, even after decades or more. Perhaps integrity, like beauty ... endures.
It really doesn't "suck", if you choose to willingly give away your code, that's a perfectly valid choice. If someone then makes money with it, good for them.
You are right about one thing - people are more important than code. But all these big corporations also consider people are more important than code (maybe less important than money, but let's not go there right now). Their take on it is probably different than yours, though.
Companies that hire programmers look for the programmer stereotype. This is probably true, to some extent, to all professions, but let's focus on the programmer stereotype - the kid who somehow obtained a Commodore 64 or an Apple II and spent his (forgive me for not being neutral here - but this is the stereotype) days figuring how what makes it tick and how to make it tick more colorfully. These are the "ideal programmer material" employers seek - probably not that specific (I did went full cliche here...), and they will have to settle because there are not enough stereotypic programmers for everyone, but that's the general direction.
What does that have to do with open source? It turns out we stereotypical programmers (and I include myself in this group even though I'm too young to had a Commodore and I learned programming on a Pentium III) love open source. We consider ourselves creators, and the creators want the most is a stage to present their creations. Open source is a great stage for those who only care about spreading their creation and getting feedback, and the fact we can use our peers' code makes it even better!
Now, companies want us, and they notice that connection, and found that it serves them in two ways. By publicly supporting open source (with the emphasis on "publicly") they can appeal to the people they want to attract. But even more important - they can use open source to find those types. The assumption is that the kids that programmed through their childhood will keep that passion and use whatever little free time they have as adults to program - so the open source communities are a good place to start looking for candidates.
So, it's not the free code that they want - it's the people that write it. Many companies are actually afraid of this free code - they fear that if the free code will fail at a crucial moment they'll have no one to turn to. This is why many companies prefer to pay for expensive products that have good open source alternatives - so that they'll have someone to turn to if things go wrong. Some companies even made it their business model to support open source software - companies pay them for software they could use for absolutely free just so they'll have someone to turn to.
When a company does rely on open source software, many times they'll have someone familiarize themselves with the codebase. Maybe they'll also fork it, or - at some not common but not that rare cases - send pull requests and sometimes even join the maintainers. This allows them to have "someone on the inside" that can fix emergencies for them.
You probably think of this as exploitation, but it's actually a symbiotic relationship. The companies get the programmers they want, and we get industrial contribution to their open source projects. The paychecks also help.
The problem is, that using open source contribution to find candidate is an economic concept called Signalling. And signalling mechanisms tend to have inflation. More and more people want to emit the signal, because they see the high tech jobs, the salaries, the benefits, the working conditions, and they want all that. Can you blame them?
And wherever there is a gold rush, there will be pickaxe sellers.
So, in the last decade or so we witness the rise of the everyone-can-code movement, which by itself is a positive thing - we live in a world of computers, and being able to control your computer can be a valuable work skill even if you are not a professional programmers. But during the last few years this movement started to preach open source, convincing many people that they need to contribute to open source projects, if not to maintain ones of their own. And they don't usually say it, but they definitely imply - open source is the gate to your dream high tech job.
But as always with signaling - the core concept behind it, actually - the "high quality" (not my term. I'm not judging. "high" and "low" quality were the terms used in Spence's paper introducing this concept) signallers have much easier time emitting the signal than the "low quality" types. While the "true nerd" programmers actually enjoy contributing to open source, and would have done it even if it didn't help them get a job, the "everyone can code" programmers suffer. They feel like they have to slave for free just to be able to get that prestigious job...
Which they don't even get. Because, as I said, signalling begets inflation. The companies looked for programmers they considered special, and fought over them because they were special. But the masses will never be special - that would be a logical contradiction to the very definition of "special". So employers have to look for other signals, and people will continue to bleed for a now-meaningless signal.
Does this make open source evil? I don't think so. The same thing happened with higher education, and no one claims higher education is evil. That's just a sad artifact of human behavior, and it will always find new forms, new signals.
Actually, you did not go full cliche. You mentioned male ('his', and true, that is part of the stereotype) and learning tech by using a Commodore 64 (not so much - we're talking current programmers here, not the likes of Bill Gates). You completely missed white or Indian, going to just the right college, young, urban, well-connected, and upper-middle-class.
See, if it was just learning on the earliest computers and male, I'd only be down by one - male (FYI, TI computers predate the Commodore 64, so if the 'original tech geniuses' stereotype were actually true, I would have most certainly been in the early wave of hires). Truthfully speaking, I'm actually down by all but one - white. And the necessity of creating Open Source is not just implied; it's actually part of job listings. 'Be a major contributor or creator of at least 3 Open Source projects' is sometimes given as an alternate to 'At least 5 years of experience at a major tech company, i.e. Google, Microsoft, Apple, or as a programmer with Amazon'. All it is, is a passive-aggressive way to 'pull up the ladder'.
Sure, when the market gets flooded with more people looking for the same job, it is harder to find a job, and it is only logical that companies would up the requirements, assuming, of course, that those jobs were becoming ever more technical. Yet, at least in the US, this absolutely contradicts the common tech company lamentation that there just aren't enough qualified candidates in the US and that they have been forced to find employees from outside the country. The argument seems even stranger, taking into consideration the increasing job requirement and convoluted interviewing and internship requirements even for relatively simple, data-entry jobs. Too Many Jobs, Not Enough Talent If the companies' claims in the article were true, people like me would be getting flooded with job offers and promises to help relocate, if needed, but instead, we simply get rejected with explanations like 'the position has been filled' (assuming we get a call back or get the recruiter back on the line at all) and watch as the same job offer sits unfilled with nothing changed but the date.
You claim that companies value people over code, but then why is there a push to create AI that can create their own non-human-readable coding language and use it to create new programs? People work in programming currently, but if the current trend persists, eventually, even the most well-connected, rockstar programmers will find themselves permanently in the unemployment line. Google AI writes its own code In 2018, it was writing its own code by scraping GitHub repos. Facebook AI creates its own language Why would companies continue these projects that could potentially create new AI 'employees' that do not need a paycheck or benefits if they truly valued [human] people over code? Granted, Facebook said it shut down the AI, yet somehow, Facebook is still working on its own AI program. I don't claim to have insider information, but that does sound shady to me.
It's simple, really. By pulling up the ladder in their own wealthy country and hiring people who will program for less pay, they create a stopgap measure to bridge between the time when employed programmers could still earn well above the cost-of-living in their area and the time when human programmers were no longer required.
Welcome to the world where Open Source, through no fault of its own (Open Source is a concept, not a human making actual decisions), has created a new philosophy in which humans, working freelance, working in small companies, and working in major corporations, feel entitled to use whatever Open Source code they want, for whatever ends, good or bad, they wish to achieve, for absolutely no cost all at, and often no credit to the original creator at all.
Open Source itself is not evil, per se, at least insofar as the original intent, but it is being used for evil, and if we can change that, we should change that.
So, in the end,
'The same thing happened with higher education, and no one claims higher education is evil.' - except they have been making that claim. Whether you agree with the people polled or not, it is true that at least someone claims higher education is evil.
'That's just a sad artifact of human behavior' - absolutely.
'and it will always find new forms, new signals.' - but that's no excuse for making signalling and the systematic exploitation of anyone easier. Programmers should be among the first to understand that problems need solutions. A programmer that gives up on finding solutions before they even bother giving problems a moment's thought is a terrible programmer. It might be easy to defend broken code or broken morals, but that doesn't make the broken things right.
First I need to say that I'm not American, so my experience may be different from what's going on in the US.
That's the "management material" stereotype - I don't think it's really considered as part of the "nerd programmer" stereotype. Sure, it has great effect on your ability to acquire the connections and education that can help you land a job, and the culture you grew in can change your probability of living the nerd programmer childhood, but it's still not part of the actual stereotype employers are looking for - a black man from a poor family can still fit the stereotype. A woman - can't. (though that changes too, though slowly, in the last years)
Employers don't want to be the first one to hire you. Not only they prefer you make your beginner mistakes elsewhere, they also don't want to take the risk of hiring an incompetent employee. That's one reason the want previous job experience (not the 20 years experience in C++17 stuff - that's just recruiters bs. They just want to know someone else already tried you and found you are good enough)
So... I guess now they expand their searches to open source? I'm not really that familiar with these job listings (I don't recall ever seeing one - are they really that common? Then again, I haven't looked for a job in 5 years, and this world changes rapidly), but maybe they think they can ask around these open source communities to get a feeling about your competence? Not sure how this is going to work... But one thing I'm sure of - the level of contribution they require is much higher than what those that only do open source to make themselves hireable think they need.
What I said is "But all these big corporations also consider people are more important than code (maybe less important than money, but let's not go there right now). Their take on it is probably different than yours, though."
OK, so we do need to "go there". A company's goal is to make money. If we go one resolution lower, the goal is to create value for people ("customers"), and have some business model for converting that value to money. Code is just a resource the company needs to create value (and in some cases as part of the process of converting that value to money). So are programmers - there is a reason why it's called "human resources".
The programmers are more valuable a resource than the code they write, because even if you use free code from the internet you still need programmers to fit that code to your needs and to fix it when thing go wrong. This may change in the future, with advanced AI that will replace us, but for now - we are more valuable than code.
They don't say higher education is evil because of the signalling, they say it's evil because it is controlled by the other camp. Maybe I should have appended "for that" to that sentence...
This is an economical problem, and trying to engineer the economy and fix the human nature never ends well. And besides - the only ones feeling exploited by open source are the ones who tried to exploit it in order to get a job. "I slaved on this open source thing and didn't get a job! Do you think I'm doing it for fun?". But the thing is - we are doing it for fun! It's not our fault that the pickaxes seller sold you a pickaxe and told you to hit that rock and find gold. We are not even here for the gold, we are just rock enthusiastic that want new rocks for our collections. Just because you are all sweaty from all the work you did for free doesn't mean anyone owes you any gold.
Your experience does differ. In the US, (the number of women in programming has been in a severe decline)[observer.com/2017/06/women-in-tech...] and in Silicon Valley, any (programmer who is not white or Indian and is not cis-male is seen as 'not real')[takepart.com/article/2015/08/04/en...]. Read all the way through the articles; it's not just a fringe thing.
In the US, unlike many other coutries, college and university level education is not free; (it's astronomically expensive)[theatlantic.com/education/archive/...]. Likewise, unpaid internships are a thing here - until relatively recently, Google required all applicants for programming jobs to successfully complete a one-year, (unpaid internship)[forbes.com/sites/cameronkeng/2013/...] and even then, they changed only after it had become an illegal practice. Now they use how much they pay interns as a PR stunt, but don't be fooled - the pay isn't 'out of the goodness of their hearts'. Essentially, the only ways to land a tech job are through being wealthy enough to afford college, then find a place to live near Silicon Valley (or another, newer tech center) where monthly rent or mortgage payments are well over $1,000 or be a well-known rockstar programmer on GitHub with years of experience working in major tech companies. For those privileged enough to be wealthy or be able to get financial help from wealthy family or friends, the cost may not seem that high, but for the rest of us ...
Take me as an example. I make $10 per hour at my full-time job - which is about the only full-time job available in the area I live in. That's 30-40 hours a week (I average about 33 hours per week), no overtime allowed. So, for one month, before health insurance, taxes, and other deductions, I make roughly $330 dollars a week or $1,320 per month. After deductions, it's more like $1,100. That's not even enough for rent or a mortgage in a tech city, much less for other expenses like food, gas, car payments, water, power, internet connection, money phone bills, or out-of-pocket medical costs. Worse, the 24/7, live-in, legally mandated caregiving I do for my mother-in-law is unpaid. My paycheck has to cover my family's (my husband, his mother, and myself) expenses. There's nothing left for college tuition, transportation to classes, books, etc.
But the cost isn't just financial. Between a full-time job, maintaining the household, and caregiving duties, I have very little time left, which is to say, almost no time to work on Open Source projects, and I'm certainly not the only one. The majority of caregivers in the US are women, due to the cultural, which assumes that caregiving is women's work because it involves nurturing, a stereotypical feminine trait. Likewise, most STEM fields are generally considered men's work. (Open Source coding is even more skewed than most STEM in terms of the gender gap.)[peerj.com/articles/cs-111/]
'They don't say higher education is evil because of the signalling, they say it's evil because it is controlled by the other camp. Maybe I should have appended "for that" to that sentence...'
Perhaps I should explain how those camps are divided up. When they take issue with 'the other camp', they are referring to liberals and progressives directly, which in turn, indirectly refers to people who encourage diversity (in terms of gender, sexuality, and ethnic background) in education and in the workplace. I disagree with the crowd that hates gender/sexual/ethnic diversity, but there is a point to be made about how financial diversity isn't much discussed in terms of admissions, aside from 'fill out some forms' and 'take out a huge loan that you won't be able to finish paying off, ever'.
You said, 'Just because you are all sweaty from all the work you did for free doesn't mean anyone owes you any gold.', but put more accurately, all that means is 'Just because you earned or generated a boatload of money, doesn't mean that your wealthy trust-fund overlords are ever going to let you see a dime of it.'
If you don't see the injustice in that, then all I can say is you've clearly bought into the 'logic' of Silicon Valley, Wall Street, and other areas of highly concentrated wealth. 'Everyone knows wealthy people are special geniuses, because all special geniuses are wealthy, and only special geniuses are wealthy'. Isn't it strange how few of those 'special geniuses' can see the (circular logic)[en.wikipedia.org/wiki/Circular_rea...] in that?
There's nothing fair when you try to buy a pickax, only to find you'll never be able to afford one, and all the precious metals, precious stones, pretty rocks, and even fertile soil has already been claimed by people who happened to have all the right things at all the right times, because they had the money already.
I agree with most of what you said. Here in Israel we have a saying that roughly translates to "You don't need nepotism when you've got connections". My point about narrowing the stereotype was that if a poor guy from a minority that fits the "true nerd" stereotype will arrive in Silicon Valley and show the necessary qualifications he'll have a decent chance to get an high-tech job - but being a poor minority means he has slim chances to get these qualifications and get to Silicon Valley.
These is not just, but I'm not sure what the solution should be. Location is important, and high-tech companies benefit from being in high-tech hubs - so if a single high-tech company builds it's HQ or a development center in a poor region, that company will be at a great disadvantage. Mainly because it'll have a hard time hiring experienced people. I'm not saying that all the people in that poor are stupid and unfit, but since they never had the a opportunity to work in the high-tech industry they'll be unexperienced - and high-tech companies need a core of experienced engineers. That company is unlikely to survive.
So, in order to get successful high-tech companies in that region, you need a lot of them - so that experienced developers will move there, seeing lots of employment opportunities. But that means gentrification - the poor region will strive and become rich, but the poor people will not.
But I digress. I wanted to talk about open source.
You said, that in order to get an high-tech job, one should either live in the hub or be scouted by the companies which requires to:
My argument is that the "on GitHub" part is not as nearly as important as the "years of experience working in major tech companies" part. Like you've seen - they don't really consider open source as experience (maybe unless you are a renowned open source programmer? But then you'll probably also have professional experience, or a position in MIT or some other academic/research institute...). They give that as an option in the resume because they want to attract people who care about open source. And because candidate with professional experience may add their open source projects to their resume, and as @moopet mentioned in another thread here - this gives them a chance to judge their code.
So, I'm objecting to the OP's claim that companies say "write open source and we may hire you" to get people to give them free code. They do use unpaid internships for that purpose, but in these cases they get to tell the coder what to do. With open source the company can't demand anything from the contributors, can't have the software built to their specifications, and can't have the maintainers (or someone trained by and paid by the maintainers) on their beck and call in case something goes wrong and they need urgent support. From a business point of view, this makes open source very risky.
And yet - you see many posts about how open source contribution can land you a job. I'm sure what the gain from it (business models in the internet are weird), and it's probably not direct, but I still call them "pickaxe sellers". Yes, you paid good money for the pickaxe and worked very hard, but it's still not the rock's fault that you didn't get any gold from it.
Look, I'm not saying everyone is going to, or should, get that first job with no effort, nor am I saying that all effort produces the same, perfect results. You seem to be misunderstanding me on both those points right there.
Perception is a huge problem when stereotypes (not actual merit) are what will determine whether or not you will be able to get a job.
Examples: I first learned to code a bit shy of 40 years ago, though I had a gap in coding for nearly 2 decades - first when school started and I was denied access to computers, and later during military service when internet access was nearly impossible to come by during much of that time. CS courses were not a thing in the colleges at the time, either. And yes, I'm showing both my age and the sad state of internet access in the US. Now, if I had never learned code on my own and I had taken 4 years of college (at the right school with the right students to make connections with), including some CS classes, I'd be looking like a pretty good candidate to any tech company. Instead, the decades of teaching myself to code are treated as 'proof' that I am unmotivated to learn and that I have no interest in coding, which is clearly the opposite of the truth. No one devotes decades to teaching themselves to code if they hate both code and learning.
Another example: Women are seen as only being interested in fashion, finding recipes and baking, finding a rich husband, making babies, and creating drama. We are seen as not understanding numbers, being terrible at logic, and being far too emotional and pregnant to handle having a professional level job. Men are seen as naturally good at logical things like code and at putting in more work. None of this is proven by actual data; it's merely seen as a thing 'everyone knows'. It's as if the 1800's never ended. Being born with a vagina is a serious detriment to being taken seriously when trying to land a job outside of retail, porn, and nursing. The fact that women, by and large, have far less time they can devote to Open Source due to unpaid home obligations reinforces the perception that 'women can't do math or code'.
So, possible solutions? There's a few that could certainly be put in place together in order to fix the issues.
The OP mentioned creating new Open Source licensing that gives creators and maintainers of Open Source code more control over who gets to use that code, what purposes they can use it for, and a legal framework for enforcing those licenses. You see, roughly an hours worth of driving from the rural area I live in, is a large city full of hotels, convention centers, and other tech meet-up necessities (and very little in the line of actual tech companies). Plenty of programmers live there, but many must work remotely as Silicon Valley isn't exactly next door. A new trend in the hotel industry in this city is using Open Source for everything but room key codes and storing guest's personal information, which allows them to keep a cutting-edge system and code base for everything from food ordering for the 5-star restaurants, water and air recycling to protect guests, aka walking ATMs, from the water and air dirty poors may have 'contaminated', to maintaining their own security and banking systems and still keep only the bare minimum of programmers hired, sometimes as third-party contractors so they can skimp on paychecks and avoid paying for benefits. Imagine if all the free Open Source resources were cut off to them until they started paying fairer wages, hiring more programmers, providing benefits, etc. You could still code as a hobby; that wouldn't go away. What would change is how the people that create and maintain the code are treated and that they'd have more say in whether or not their code could be used for evil.
We could also work towards changing cultural norms in an effort to rid society of the unjust master/slave relationship between men and women, between whites and non-whites, and between rich and poor. Currently, at least in the US, non-whites, esp. blacks, are set up to be funneled into the prison system from a very early age. A white kid gets disruptive in class and the campus cop writes them up. A black kid disrupts the class, and he ends up face down on the floor in cuffs and gets hauled off for processing into juvie. Men are expected to be employed. Women are expected to be employed, maintain the entire household, get the shopping and dry cleaning dropped off, raise the kids, care for the elderly parents, and have dinner ready for when the man of the house gets home, all for less pay from their place of employment and no pay at all for the rest of it. Poorer people have spotty access to the internet, can't afford healthcare, go homeless when the can't pay the rent/mortgage, and go hungry when food banks run out of food, all to be arrested if they fall asleep in a car or on a sidewalk or if they loiter, use public bathrooms too frequently, or worse, use the bathroom in public when the nearest public bathroom is miles away. Wealthy people can commit DUIs and barely get a slap on the wrist, or in some cases, repeatedly commit rape, murder, or other felonies, but use money and status to weasel out of having any real consequences.
We could also, again in the US, do like much of the rest of the world, and make things like higher education affordable, or better yet, 'free' (as in shared cost by way of taxes, like public education does now), but without the strangled budget the wealthy have been setting up using their financial power as political campaign donors.
It's not impossible, and it won't take your hobby away, but if we implement the right solutions, we just might bring the world some justice, help those with actual merit succeed, create better code by bringing in new ideas, and set up tech that works for everyone (as opposed to self-driving cars that don't stop for people with darker skin, automated phone services that do not recognized women's voices, and all sorts of other screwed up issues).
Video that explains what privilege is and isn't and why awareness of one's own privilege and taking responsibility for righting wrongs is a good thing
The moral injustice is intellectual property (at least, strong forms of), and the notion of restricting access to resources that can be freely copied and shared.
While it's socially good to compensate talented people for their work, and nobody wants to make tools for Nazis, MLK and Ghandi were never compensated for freedom fighting, and everybody uses tools.
You raise a few interesting points however - there's an injustice in large corporations using open source software to power cloud services that might as well be proprietary as far as end users can tell, especially if they don't contribute upstream.
But overall FOSS is a benefit to humankind, and most people do the right thing.
I will add - Devs are hugely underrated and maybe these corporations should be encouraged to contribute money upstream ;) like tithes - give 10% to the stack
That's a characteristic of artists, not open source developers. Most open source maintainers and contributors either do it as a hobby, do it as part of a payed job, or have a business model to earn money from it. Cases like Neece are rare - and even there, these guys are highly employable and could easily find a job if they see it doesn't work out.
It's nice you have such faith in those who have worked on Open Source projects, but getting hired isn't always so easy as all that. There is nothing about Open Source that guarantees future employment, any more than there is a guarantee that a Resume will automatically land you a job instantly. What you call 'highly employable' is nowhere near the same thing as actually becoming employed.
I've been writing code for over a decade, and wrote a bit of Open Source code, myself. Even so, the only place I could get hired was in a grocery store stocking groceries for minimum wage. I've tried getting into a job coding for years, but I still have never been hired at a traditional job involving code (other than produce codes, and that hardly counts) and the only freelance work I managed to get paid a grand total of $100 over a 4-year time period. And I'm not talking the dollar-equivalent I earned in some impoverished third-world country; I'm talking actual dollars in the US.
Never assume companies are falling over themselves looking to pay writers of Open Source code when currently, they can still get it all for free.
Buster Neece is not highly employable because he worked on an open source project - he is highly employable because he worked as a programmer in Bravely Blue Media before "retiring" to work full time on open source.
The thing about this profession, is that it's hard to get your first job, but once you're in - everyone will want to hire you. Neece was in, and even if currently he is technically "out" - potential employers will still want to hire him if he ever decides he wants to code for a salary again.
That's just it, isn't it? If all you have is Open Source as something you can show an employer, but you still have a decade or more of rejections from employers and still no initial job.
Again, the current incentive for companies is 'take what you want for free, because actually paying for free code cuts into profits and shareholders don't like that sort of thing'.
Employable =/= employed
I have a bit of a long reply for that, so I wrote it as another direct comment to the main post - dev.to/idanarye/comment/gck9
Wait, I have a bit of a sticky with "If all you have is Open Source as something you can show an employer".
Open source is all you can show an employer. Everything else is hearsay. You can say, "I worked on the doohickey that tamped down vibrations in the flux capacitor" if you want, but unless you have permission to show your work, it's just words. Sure, you can back it up in an interview, but you can do the same if it was open source.
Having open source software you can show people is always of benefit to the company looking to recruit you. Of course, if it's crap then you're not going to get far, but...
Only read about half the article when I realized this rant is misplaced. It is not about Open Source. It is about what people do with Open Source.
Commercial entities were initially reluctant to jump on the bandwagon of Open Source, even before it was called Open Source, and they fought tooth and nail against it. If they could not make money they weren't interested. The community was always reasonably good to one another. Until, that is, commercial entities realized they could exploit Open Source to reduce costs which is like making money. So the problem of Open Source is and has always been people. By focusing on the thing that Open Source is this article has placed the blame on the thing it set out to attack rather than the actual people who are being immoral in their use of said thing. People are getting a pass!
Open Source is not any more broken than any other thing because it is a thing. People are broken. The community fooled themselves into thinking commercial entities would use their code both morally and ethically. But such expectations were always naive. This is the reason such a strong emphasis was placed on stopping monetary transfers and requiring the viral Copyleft! Perhaps those measures also failed to realize cost savings equals making money.
But we're still talking about people here. People are immoral and will continue to be immoral no matter what actions we take nor what restrictions we attempt to impose. The only thing we can control is whether we continue to support obviously immoral and unethical enterprises. Don't try to force enterprises to be moral, instead stop working for them. And if you continue to work on Open Source, then require a Copyleft.
Don's follow up post gets into this more, looking at what people can do both via licencing and through ethical organisations to take positive moral actions rather than abdicate responsibility entirely (and losing their agency over their creations). As he mentions here, there is a lot more to this than code and licenses, and it's in need of more thought :)
Well, it wasn't when Open and Free Software were designed.
While your argument is very well built, I think that you should take time perspective in account: maybe OS and FS (someone else has already told you how different they are) need an overhaul because the market and the whole society have changed a lot, in the last 30 years. And, as you point out, they are many attempts at that being carried out, by many actors.
Saying that "Open Source is immoral" still needs many pages of careful wording and specification, before becoming a valid sentence. You bring many valuable discussion point to the table, but I don't subscribe to this view.
It boggles my mind that a GitHub employee is writing in opposition to open source. You want us to restrict who can use our software? If I sell a hammer, should it come with an EULA specifying that it's not for use in military applications or by communists? You're entitled to your free thought, I'm here to tell you that it's thoroughly wrong-headed. Go pitch to Debian and see how far you get. Open source distributions could not exist if each developer attached their own set of crazy-ass conditions to their license. "Not for use by Jews" "Not for use by Republicans" It's such a bad idea that I didn't continue reading after that (yet)
Some comments may only be visible to logged-in visitors. Sign in to view all comments.