Coming to Terms with the Troubling Side of Open Source’s Success

Daniel Narey Blocked Unblock Follow Following Feb 13, 2016

It’s exciting to be a part of the evolving conversation on open source infrastructures, and the economies and cultures surrounding them, now taking place on Medium.

As I have been reading and thinking more deeply about the politics of openness, I have started to appreciate the real complexity here and to understand why a lot of people don’t see eye to eye when it comes to opening up our ways of working and freely sharing the digital products of our labor. I came into this conversation as an advocate for all things open, with the intention of taking a critical look at some of the obstacles to wider adoption of open ways of working. As I write now, I am working my way toward a more nuanced point of view, and one that I hope can guide my personal ventures in open-source/open-data/open-design.

While I am still convinced that openness is an idea worth fighting for, I have also come to see that some of what is being celebrated under the banner of “openness” can be shallow, obfuscating, and exploitative. One problem that I see in media coverage of technology, for example, is that conversations around open source often bring in economics — how open source creates value (from one point of view), or eats up profitability (from the opposite point of view) — but they often leave out political economy — how particular social, legal, institutional arrangements allow some people to accumulate economic benefits at the expense of others.

Astra Taylor is one of the few people writing about technology and media today who puts political economy front-and-center. In The People’s Platform: Taking Back Culture and Power in the Digital Age, she expresses a skeptical view toward current enthusiasm about openness. I will quote her at length, because my aim in the remainder of this essay will be to unpack what she is saying here:

While openness has many virtues, it is also undeniably ambiguous. Is open a means or an end? What is open and to whom? Mark Zuckerberg said he designed Facebook because he wanted to make the world more “open and connected,” but his company does everything it can to keep users within its confines and exclusively retains the data they emit. Yet this vagueness is hardly a surprise given the history of the term, which was originally imported from software production: the designation “open source” was invented to rebrand free software as business friendly, foregrounding efficiency and economic benefits (open as in open markets) over ethical concerns (the freedom of free software). In keeping with this transformation, openness is often invoked in a way that evades discussions of ownership and equity, highlighting individual agency over commercial might and ignoring underlying power imbalances. (emphasis added)

As Taylor suggests, openness is becoming an influential idea in our culture, but when it is used loosely, more as a metaphor than any kind of clear principle, it becomes difficult to decide whether the version of “openness” being sold to us — Facebook’s version for example — is something we really want. In the limited context of software development and distribution, “open source” does have a precise definition, but people who comment on technology don’t necessarily adhere to that definition when they talk about “open source software,” and this only adds to the confusion.

As a first step toward being able to talk intelligently and critically about the idea of openness, I think it would be helpful to sort out what “open source software” actually means, where the idea came from, and how it has evolved over time. That’s what I’m going to try to do in the remainder of this essay.

Open as a Means, Not an End

As ubiquitous as it is today, the term “open source” only came into use in 1998, when it was proposed as a politically neutral and commerce-friendly alternative to “free software.”

In the Open Source Initiative’s official definition, “open source” is identified with a set of “distribution terms” for software products, and the word “license” appears 22 times in the roughly 500-word statement.

So, let’s start with the idea that open source is a software licensing model — that’s not entirely what it is, but play along for now. Why does this licensing model exist, and why do people in the tech world seem to care about it so much — either as proponents or critics?

To answer this question, we need to understand why there is such a thing as a software license to begin with.

Put simply, software licenses exist because software (as source code or object code) has come to be regarded as intellectual property, and copyright law restricts what you can do with someone else’s intellectual property.

In the U.S., you can give up your ownership rights over something you create by releasing it into the public domain, but there are a lot of circumstances where you wouldn’t want to do that (e.g., when you want people to credit your authorship, or when you don’t want them to make money off of your work). Put simply, licensing is an option when you want to give other people permission to use your work (e.g., some code you wrote) in certain ways, but you don’t want to give up all of your legal rights as the creator of that work.

Proprietary Software Licensing

The main alternative to the free/open licensing model is often referred to as “proprietary” software licensing. (This is somewhat of a misnomer because a free/open license also preserves the intellectual property rights of the creator/owner, but there doesn’t seem to be a less confusing term for it).

Proprietary software licenses are designed to serve the interests of commercial software vendors in maximizing profit from the sale (or lease) of their products. To be more precise, what commercial software vendors are selling is the license to use their software within very specific parameters. The buyer in the transaction is not buying full rights to (a copy of) the software program, he or she is paying a fee to use the software in accordance with the terms of the license.

For much of the era of mainframe computing, software and support were bundled with hardware, and it was not uncommon for users to customize and share software. A number of circumstances led to hardware and software becoming unbundled, and the proprietary licensing model was invented so that software could become a profitable business separate from hardware and support services. This new business model, combined with the rapid take-off of desktop and personal computing, allowed software to grow into a major industry in the 1980s and 90s.

Origins of the Free/Open Licensing Model

Like the proprietary model, the free/open licensing model should be seen as a particular solution to a particular problem that came about at a particular time in history. The time was the 1980s: computers were becoming smaller and more powerful, new business-to-business and consumer markets were emerging for hardware and software, and companies were developing new business models to make a profit in these emerging markets. The problem was that these new business models were an affront to the hacker culture that had existed around university computing labs in the preceding decade.

Hardware became cheaper as a result of new technology and industry changes, but software was becoming more expensive, and proprietary restrictions were making it more difficult for programmers to write their own software or modify existing programs for new purposes. For people motivated not by profit, but by a desire to understand how computers work, make them better and more useful, write programs for them, and share what they were learning with the community, the move to lock up source code as a trade secret could only appear as the first step down a very dark path. The solution would be to create a form of software license that would help to set software development on a brighter path.

In 1983, Richard Stallman (then working at the Artificial Intelligence Lab at MIT) announced the GNU project to build a unix-like operating system that he would make freely available to users. Explaining “Why I Must Write GNU,” Stallman wrote:

I consider that the golden rule requires that if I like a program I must share it with other people who like it. I cannot in good conscience sign a nondisclosure agreement or a software license agreement.

So that I can continue to use computers without violating my principles, I have decided to put together a sufficient body of free software so that I will be able to get along without any software that is not free.

Two years later, Stallman founded the non-profit Free Software Foundation to support the development of GNU and advocate on behalf of these principles. Under Stallman’s intellectual leadership, the Free Software Foundation came to adopt a very specific definition of “free software” — importantly, making the move to defining “free” in ethical rather than monetary terms:

“Free software” means software that respects users’ freedom and community. Roughly, it means that the users have the freedom to run, copy, distribute, study, change and improve the software. Thus, “free software” is a matter of liberty, not price. To understand the concept, you should think of “free” as in “free speech,” not as in “free beer”. We sometimes call it “libre software” to show we do not mean it is gratis.

We campaign for these freedoms because everyone deserves them. With these freedoms, the users (both individually and collectively) control the program and what it does for them. When users don’t control the program, we call it a “nonfree” or “proprietary” program. The nonfree program controls the users, and the developer controls the program; this makes the program an instrument of unjust power.

For Free Software advocates, the proprietary licensing model employed by much of the commercial software industry, even today, unethically restricts the freedom of the software user. Stallman makes a compelling argument to support this thesis, and you should really watch this video to get a better understanding of what he is saying.

To briefly summarize his argument as I understand it, Stallman believes that closed-source, proprietary licensing is not ethically defensible because it is based on asymmetrical information about what the program does, how it works, and what precisely the user is agreeing to in accepting the license (e.g., how the program is using your data); because it creates monopolies over certain categories of software products and over the knowledge required to design new and better programs; and because it creates a culture of commercial software dependency, particularly in corporate and educational settings, locking in users to a limited set of products (which are often not as good as they could be, and can sometimes be very expensive).

The form of software license Stallman and the Free Software Foundation advocate was designed, in part, to prevent people from using these ethically dubious tactics to profit from software distribution.

Copyleft vs. More Permissive Licenses

When Stallman started working on the components of GNU, the free/open software licensing model did not exist. At that time, a developer could make a statement relinquishing copyright, and thereby release her source code into the public domain, but that might not prevent someone else from compiling the program with their own modifications, slapping a proprietary license on it, and trying to use the legal system to prevent others from distributing similar versions.

The idea behind the GNU General Public License (GPL), which became the paradigm of a “copyleft” license, was to prevent this kind of thing from happening. When you release a program under a copyleft license, anyone who distributes that program or a derivative must do so under the same (or a compatible) license. This means that no derivative that uses the original program’s source code can be distributed under a closed-source, proprietary license; violation of this clause would be subject to legal action by the developer, who retains legal copyright.

One effect of releasing a program under a copyleft license is that it makes it nearly impossible for anyone to make any money directly from the distribution of that version or any of its derivatives. Proprietary licensing restrictions were designed to make software development profitable — when you remove those restrictions, there is no longer any money to be made as a software vendor, because price is zero when supply is infinite (because there is no limit to how many times a program can be copied). Software only became a profitable industry by imposing artificial scarcity.

The only way to make money from the direct sale of copyleft-licensed software (other than exploiting the ignorance of the consumer regarding licensing terms) is to provide some added convenience that would entice a user to pay something for the program instead of nothing, or to bundle the software with a service (like customer support) that provides added value to the user. There are lots of other ways that free/open-licensed software development can be part of a sustainable business model, but with such business models, the software is not the actual product you are selling (see OpenSaaS, for example) .

MIT, BSD, Apache, and other permissive software licenses provide a more commerce-friendly alternative to copyleft. These licenses also allow users to copy, modify, and share a program’s source code, but they do not prevent derivative versions from being released with proprietary licensing restrictions.

Commercial software vendors never had a problem with these more permissive licenses (after all, they could distribute their own proprietary versions) — it was copyleft that created legal headaches and ultimately posed a threat to the profitability of the software industry.

Free/Open-Licensed Software Becomes an Infrastructure for Web 2.0

The real turning point for free/open-licensed software was the arrival of the full LAMP stack (Linux-Apache-MySQL-PHP) for web server applications in the late 1990s, coupled on the consumer end with the release of the Netscape browser source code under a free/open license in 1998. In Nadia Eghbal’s recent contribution on the history of open source as a software development paradigm, she points out that dot-com era startups played a big role in popularizing the free/open-licensed software by adopting the LAMP stack as a way of lowering their own development costs. Those lean startups of the late 90s and early 2000s became today’s Google, Amazon, and Facebook.

The stage was set a few years earlier. When Linus Torvalds agreed in 1992 to distribute his Linux kernel under a GNU GPL license, GNU/Linux was on its way to becoming a complete operating system that could be the foundation for developing commercially viable applications. The other components of the LAMP stack reached stable versions in the mid-1990s: Apache as the HTTP server (under the permissive Apache license), MySQL as the database (available under GPL or for purchase under a commercial license), and PHP as the scripting language for server-side applications (under the permissive PHP license).

Free as in “Freedom” vs. Open as in “for Business”

As the community around free/open-licensed software grew, not everyone was comfortable with Stallman’s view that commercial software vendors exercise “unjust power,” and not everyone was interested in campaigning for the freedom of software users as a political cause. Some people wanted to be part of a community not driven by profit and dedicated to making software better, but also wanted to be able to profit personally (or at least ensure that they could make a comfortable living) from their software expertise.

Although Stallman frames the argument for Free Software in ethical rather than economic terms, the type of freedom he is advocating, if fully realized, would clearly be disruptive to 21st-century capitalism. Obviously, whether this is a bad thing or not depends on where you stand politically, but some people would prefer not to have that conversation at all.

Against the background of this controversy, the Open Source Initiative was formed in 1998 as “an educational, advocacy, and stewardship organization” to support and promote the a non-politicized, commerce-friendly version of free/open-licensed software. The organization’s “about” page explains the origin of the term “open source” as follows:

The “open source” label was created at a strategy session held on February 3rd, 1998 in Palo Alto, California, shortly after the announcement of the release of the Netscape source code. The strategy session grew from a realization that the attention around the Netscape announcement had created an opportunity to educate and advocate for the superiority of an open development process.

The conferees believed the pragmatic, business-case grounds that had motivated Netscape to release their code illustrated a valuable way to engage with potential software users and developers, and convince them to create and improve source code by participating in an engaged community. The conferees also believed that it would be useful to have a single label that identified this approach and distinguished it from the philosophically- and politically-focused label “free software.” Brainstorming for this new label eventually converged on the term “open source,” originally suggested by Christine Peterson. (emphasis added)

Proprietary Enclosure of the Free Software Commons

The importance of rhetoric should never be underestimated. Because of the conceptual shift from “free software” to “open source,” companies that make a lot of money by building walled gardens around their products can nonetheless claim to embrace open source and “give back to the community.”

An interesting case study is the relationship between Google and Android, the open source mobile operating system built on a variant of the Linux kernel. Writing about Google’s attempts to reign in the Android operating system, Ron Amadeo describes this relationship as resulting in a “look but don’t touch” kind of open for Android:

What many people think of as “Android” actually falls into two categories: the open parts from the Android Open Source Project (AOSP), which are the foundation of Android, and the closed source parts, which are all the Google-branded apps. While Google will never go the entire way and completely close Android, the company seems to be doing everything it can to give itself leverage over the existing open source project. And the company’s main method here is to bring more and more apps under the closed source “Google” umbrella.

As he goes on to explain, this considerably restricts what developers can do with Android:

You’re allowed to contribute to Android and allowed to use it for little hobbies, but in nearly every area, the deck is stacked against anyone trying to use Android without Google’s blessing. The second you try to take Android and do something that Google doesn’t approve of, it will bring the world crashing down upon you.

This is just one example illustrating how tech giants like Apple, Google, and Facebook embrace free/open-licensed software to the degree that it serves to improve their bottom line. Unless we hold them accountable, that embrace may lead to consequences that violate open-source contributors’ “share-alike” ethos. The more general point is that free/open licensing is only a means to an end — if we lose sight of the ethical and political-economic ends we value, open ways of working can easily be co-opted to increase the market share of proprietary platforms and boost the profits of their corporate owners.

In Lieu of a Conclusion

In his advocacy for Free Software, Richard Stallman has taken some positions that may seem extreme, like advocating that web users take pains to avoid running “nonfree” JavaScript in their browsers or personally refusing to watch a Netflix movie on a friend’s account as a protest against what is known as “Digital Rights Management.” I’m sure he could give me a number of reasons why I shouldn’t be publishing this essay on Medium.

As someone at the older end of the Millennial generation, I came into adulthood as the social web was taking off. As a dedicated user and interested observer of new media, I have a sincere appreciation for the ways in which today’s platforms enable us to inform and empower ourselves and connect with one another across geographic and cultural boundaries. Personally, I am an enthusiastic user of some proprietary platforms and a reluctant user of others; some I try to avoid entirely. All in all, my politics are such that I don’t believe it is any kind of solution to be an ethical purist about the technology you are willing to use.

Strategic disagreements aside, Stallman and others in the Free Software Movement have been right to press concerns about the ethical consequences of dominant business models around software and computing more generally. Those concerns have not changed in any fundamental way, but the technology and the business models have evolved considerably in the past 30 years, and this is why some new strategic thinking may be needed.

In addition to an ethical perspective critical of restrictions on the freedom of the technology user, we need to bring in a political-economic perspective critical of the exploitation of creative contributors to technology and digital culture. We also need to think beyond the free/open licensing model as an end in itself and start to experiment with new tactical approaches that would help to foster participatory, equitable, “share-alike” economies of digital production.