Almost forty years ago, in 1985, the idea of “Free Software” was born. That is not to say that the idea of sharing software with colleagues and making source code available was born. Ten years before the GNU Manifesto and the Free Software Foundation, I worked at a cloud services company (only we called it “timesharing” back then), and in order to encourage people to use our offerings and pay us for renting computer time and disk space and network bandwidth, we curated a collection of software libraries that customers could freely use. We called it the Public Library, of course. The software therein was public software. The idea of public software was software that anybody could freely use. What happened in 1985 was the birth of the idea that creation of software was a political act. And that when the creation of software was motivated by politics, it should be called free software to differentiate it from software created for other reasons. This became clear to be when I attended my first O’Reilly Open Source Conference, where I watched Miguel de Icaza debate Richard Stallman — and the question on the table was whether or not there was a difference between “free software” and “open source software”. The conclusion was that there was no detectable difference from examining the software or the license or any artifact. The difference was the intent of the programmer. If the intent was political (i.e. a concern for freedom), then the result was free software. If the intent was industrial, the result was open source software. I use the term industrial because the motivation of the open source crowd is to use what they believe to be a superior method of producing software.
My interest in free or open source software has never been either political or industrial. My interest has always been educational. That is, access to the source code provided the opportunity to learn from it. So, in the same spirit as the Open Source / Free Software distinction, I coined the term Liberal Software to refer to software where the intent of the programmer is educational (liberal as in education). Any one of these three intents can produce software for which the source code is available — and that is often called FLOSS, meaning Free, Liberal, or Open Source Software.
I prefer to think about these categories in terms of intent, because that opens the door to reflecting about effective strategies to implement that intent. So, for example, if it were to turn out that, all other things being equal, providing source code for libraries could be shown to produce software of inferior quality (and there is much evidence to support such a conclusion), then someone with an intent to produce industrial software might choose to pursue a course of action that did not involve making the source code available. The availability of source code is certainly invaluable in Liberal Software, and there are several scenarios regarding industrial software that require access to the source code. But that is a discussion for a different time.
Today’s topic is political software. I think it is clear that the Free Software Foundation has failed to move the needle on the political issues relating to software. Those of us who are interested in issues of freedom and ethics and social justice related to software must explore alternative stratagems to achieve those objectives. The tactics of the Free Software Foundation (the insistence on copylefting software and fighting software patents) have become more and more ineffective. The world of software has evolved and changed in the years since 1985: we need to let the past die and build a better future.
The first sign that free software is intellectually bankrupt is that the Free Software Foundation seems unable to develop new generations of leadership. Free societies are usually lukewarm to the practice of “dictators for life”. After around a decade, it is a healthy sign if new leadership emerges. It is a sign of growth and innovation. It is healthy. Seeing the same people in the same places pursuing the same failed tactics decade after decade is evidence of a lack of broader acceptance.
Secondly, I am reminded of Harry Truman’s quote:
It is amazing what you can accomplish if you do not care who gets the credit.
The Free Software Foundation is famously fixated on insisting that it be given credit for Linux. Caring about who gets the credit more than successfully creating change is not a good look. It is, of course, consistent with the ego required to cling to power and smother the growth of the next generation. Linux is perhaps the child that succeeded where GNU failed.
Thirdly, the rhetoric of Free Software devotees is awkward and unconvincing. The inflexibility (or inarticulateness) that has failed to evolve the talking points to make them more effective is a failure of politics. To take my own pet peeve, it is unarguable that inanimate objects cannot have freedoms. People have freedoms. Frying pans, as an example, cannot have freedoms. If one were to talk about Free Frying Pans, the only way to interpret that statement is that one is referring to frying pans that one needn’t pay for. When one uses the phrase “free press”, one is not suggesting that the pile of metal and wood that constitutes a printing press machine is entitled to freedoms. The word “press” in that phrase is a figure of speech known as metonymy. It refers to journalists. “Freedom of the press” is talking about the freedom bestowed on journalists. Most people understand that “the press” refers to the journalist collective. So when one says “free software” or “software freedom” we know that the freedom is not given to an executable file. The expression (unless we are referring to software that we needn’t pay for) is referring to freedom for some group of people that we know as “the software” (y’know, like “the press”). And who are those people who are members of “the software”? That was a rhetorical question. Please don’t try to explain it to me. I was pointing out how nonsensical this framing is. Rhetoric is a discipline that has been around for over two thousand years. We have two thousand years of scholarship that inform us that the phrase “software freedom” is meaningless gibberish. It can only sow confusion — and the confusion is only exacerbated by explaining that you used the words to mean something else entirely. That was Lewis Carroll’s point in Through the Looking Glass:
“I don’t know what you mean by ‘glory’”, Alice said.
Humpty Dumpty smiled contemptuously. “Of course you don’t — till I tell you. I meant ‘there’s a nice knock-down argument for you!’”
“But ‘glory’ doesn’t mean ‘a nice knock-down argument’,” Alice objected.
“When I use a word,” Humpty Dumpty said, in rather a scornful tone, “it means just what I choose it to mean — neither more nor less.”
“The question is,” said Alice, “whether you can make words mean so many different things.”
The Free Software coterie is fond of insisting that words mean what they say they mean, and that is a profound misunderstanding of the nature of language. Such linguistic naïveté is not an asset in pursuing political goals.
With all that said, the intent of the adherents to the term Free Software is to seek to promote certain freedoms for the users of software, by depriving the creators of software (at least in the United States) of the rights afforded them by Congress under Article I, Section VIII, Clause VIII. Many programmers are under the impression that “software freedom” is meant to increase the freedoms of software producers. Nothing could be further from the truth. The GNU manifesto and Free Software Foundation take great pains to explain that their intent is to increase the freedom of computer users — at the expense, of course, of software producers. “The Software” is a metonym for software users. The difficulty is that the freedoms that the Free Software Foundation insists on giving software users are freedoms that most software users do not want, and the freedoms that they wish to restrict for software producers are freedoms that most software producers would rather retain. The so-called Free Software coterie might make more headway if it took the trouble to find out what freedoms “the software” (a/k/a software users — see how awkward this metonymy is) actually wanted. Instead they invest most of their energy trying to convince “the software” of which freedoms they ought to want. In that vein, the intent of the programmer who selects the license makes it “free software” or not — the intent of the user is not considered. If a user uses software with political intent, but it is not licensed in a way that the Free Software Foundation approves of, can “the software (meaning the user)” be exercising freedom?
Prior to 1983, (two years before the Free Software Foundation was founded), all computers sold by IBM (which in those days meant pretty much “all computers”) came with the source code to the operating system. Like Linux (although you usually have to download the source code separately nowadays). Every company (because computers were so expensive that individuals couldn’t afford them) had a “data processing” staff which might make changes to the source code should the need arise (fixing problems, adding features). Many companies, however, were not large enough or sophisticated enough to have the kind of staff which could do this effectively. They would prefer to contract out the maintenance of the operating system software to the vendor (IBM). IBM, however, was unwilling to take this on, since everybody had the source code, and might have made modifications. IBM had no way to know what modifications might have been made, and consequently would be unable to accurately estimate how much work might need to be done. Eventually, due to persistent customer demand, they came up with their OCO (Object Code Only) program — in which you could receive the software WITHOUT the source code. In that case, IBM could provide a service contract for their software as they wouldn’t have to contend with individual local modifications. It turns out that computer users mostly wanted freedom FROM source code, rather than the freedom to use the source code to modify their operating system. Two years later, the Free Software Foundation was founded to try to foist the source code on people who didn’t want it.
If your counter-argument to that is “but that was the 1980’s and the nature of software has changed since then — so that situation no longer applies” I have two responses. Firstly, the GNU manifesto was written in the 1980’s, and the nature of software has changed since then, so it no longer applies. Secondly, the largest Free Software business, Red Hat, has always had “freedom from source code” as its business model. A business pays Red Hat with the same licensing scheme as they would for any proprietary commercial operating system, in exchange for which Red Hat frees them from the inconvenience of needing to be exposed to the source code.
Discussions of Free Software often start with the origin myth about access to the printer software source code at the MIT AI labs. Being denied the ability to get a notification when the network printer jams is fairly low down on the list of human rights violations. When discussing why Free Software partisans think “software freedom” is of any use or interest, the canonical answer is some form of the argument: fear the “bad actor”.
This conspiracy theory goes something like this: If you can’t examine the source code, then some bad actor might provide you some executable software that has evil baked in, and you wouldn’t be able to tell — whereas the bad actor would not be able get away with such nefariousness if you had access to the source code. As with all conspiracy theories, two things are true. 1) If repeated often enough, people will start to believe it. 2) It is nonsense.
Free-softwarists are right on their fundamental premise: this is a political issue. Protecting myself from bad actors is not my job. It is the government’s job. Americans like to perpetuate the myth that it is everybody’s job by pretending that the right to bear arms is somehow related to protecting one’s family. Somehow, we still need to spend close to two trillion dollars a year to hire government employees to protect us (military and police and border patrol and firemen and sheriffs and marshals and immigration agents and intelligence services). If owning a gun were sufficient to protect ourselves, we could save those two trillion dollars. But the same people who proudly display the weapons that they own (to protect themselves) are the first and loudest to insist that we need to spend trillions of dollars on government-employed protectors.
Free-softwarites like to use beer metaphors (free as in beer). Let me suggest that if one were concerned with bad actors, one wouldn’t drink purchased beer (or free beer). One would brew one’s own beer, because bad actors might have poisoned the beer. And one would have to grow one’s own hops, (as bad actors might have poisoned purchased hops). And what might one use for water to brew the beer? Bad actors might have poisoned the water supply. One would need to dig one’s own well (unless, of course, the bad actors had polluted the water table). This way lies temperance.
The alternative, of course, is to believe that you could safely purchase beer, because it is the government’s job to keep you safe. There might be government inspectors who inspect breweries. There might be laws against selling poisoned beer, and courts and district attorneys to go after beer poisoners and jails to incarcerate people who poison beer. There might nevertheless occasionally be a tragic instance of beer poisoning, but having a government agency whose job it is to keep the beer supply safe might be more effective than having each household test the beer they purchase to determine if it is safe — with the only punishment for the purveyors of poisoned beer being that some people might notice that the beer was poisoned and organize a boycott. The “bad actor” conspiracy theorists need to believe that many commercial actors are evil and all government actors are ineffective. And although I believe that there is the occasional evil entrepreneur and the occasional ineffective bureaucrat, in general, we must live our lives as if people are trying to do what they believe to be the right thing. Airplanes won’t usually fall out of the sky, restaurants won’t usually serve poisoned food, automobiles won’t usually explode, bridges won’t usually fall down when we drive over them. Software vendors won’t usually be inserting spyware into their wares. Q is not prescient. The evils are likely to be petty; misdemeanors rather than felonies.
And on those occasions when bad actors are engaging in nefarious activity, a much better solution than having everybody auditing every line of source code for every bit of software they use, is to pass laws criminalizing such behavior and having a government cybercrime division tasked with punishing people who do that. And in this regard, free software is one of the bad actors. In the GPLv3 (and it was there in GPLv2 and v1) clauses 15 and 16 are the Disclaimer of Warranty and the Limitation of Liability. To be fair, proprietary software licenses have the same clauses, but the free-softers cannot claim the moral high ground here. These licenses assert that if the software causes any harm, the people who wrote it aren’t liable (limitation of liability). And also that the software is completely useless and it would surprise the author if it worked at all (disclaimer of warranty). UNLESS REQUIRED BY LAW. The paragraphs are in all caps to make extra sure you understand that GPL software is guaranteed to be broken by design and that nobody is responsible for the damage it causes. The free-softwarian defense of this “it’s OK to do evil” posture is that since the people writing the software aren’t charging money for it, you shouldn’t be able to sue them for any evil they might have accidentally baked in. And this is, of course, after arguing that programmers can make money with free software by charging for the labor of writing and packaging and distributing the software, but not for licensing it. In summary, the Free Software Foundation asserts that a) you can definitely make money writing free software, and b) you shouldn’t be held liable for any harm your software causes because you can’t make money writing free software.
Of course, there are those five fateful words (in all caps): UNLESS REQUIRED BY APPLICABLE LAW. It seems that the intent of the GPL (and by extension, Free Software authors) is to be permitted to be as evil as possible (accidentally), brought up short only by applicable law. That, of course, is freedom. So, naturally, they assume that other (non-free) software authors will be equally unscrupulous. Put me down as being in favor of additional legislation to hold software authors liable for any damages they cause. And also of additional legislation to require them to warrant that the software is merchantable and fit for some purpose. I would like to see specific legislation that makes the person who provided me the software assume some risks as to the quality of the program. The existing free software license specifically states that “should the program prove defective, I assume the cost of all necessary servicing, repair or correction”. The existing free software license specifically states that “in no event shall any party be liable to me for damages for losses sustained by me for using the program”. As it turns out, there are many jurisdictions in which the applicable law voids the entire disclaimer — you can’t limit your liability by disclaiming it. The problem exists in those jurisdictions that allow the kinds of freedom-limiting licensing provisions embedded in the GPL to be enforceable. I wish that free-softies would aspire to emulate D J Bernstein, who offered, in 1997, $500 to anybody who found a security hole in his software qmail. ( https://cr.yp.to/qmail/guarantee.html )
As a software user, as a member of that group of people known as “the software”, for whom “software freedom” applies, the freedom that I would like is the freedom to seek recompense from people who create damage to me via software. I would prefer software insurance to “software freedom”. When the GPL was written, when the term “Free Software” was coined, software was used for accounting software and text editors and printers. Nowadays, it is used to run MRI machines and radiation therapy machines and surgical robots and nuclear power plants and drive cars and fly airplanes, and so on. When the GPL was written, when software failed, it meant I didn’t get notifications about printer jams. Today, when software fails, it means I get a lethal dose of radiation. Maybe I would have been satisfied by the freedom to see the source code to the printer driver to deal with the paper jam. Today, however, the freedom that I want is not the freedom to see the source code to the radiation therapy machine. The freedom that I want is the freedom not to worry about receiving a lethal dose of radiation because the programmers who wrote the radiation therapy software took extra care because they know they would be harshly punished if they screwed up. That would make me feel much safer than a copy of the source code that I could peruse before being hooked up to a machine running software that was written by programmers who knew that nothing would happen to them, even if it killed me. I want the freedom to not have to audit every line of software of every software system I ever use, or which is used on me. That might have been possible in the 1970’s. It is not possible today. ( For those of you who think I’m concocting hypothetical scenarios for fear-mongering … I refer you to the incidents with Therac-25. https://en.wikipedia.org/wiki/Therac-25. The result being an international standard (IEC 62304) for medical device software. The authors of IEC 62304 identify a set of criteria to determine whether the software is sufficiently safe to be included in a medical device. Availability of the source code is not one of them.)
The free-softwarians make the argument that without access to the source code, one would not be able to detect the nefarious intent of the bad actors. Let me digress briefly to reminisce about an incident during my career. I was employed by a large investment bank who had asked for (and received) a copy of the source code for Microsoft Windows. This bank then proceeded to make modifications and compile their own custom version of Microsoft Windows which they distributed to tens of thousands of employees. Furthermore, we also wrote custom applications which relied on features of this custom version of MS Windows. You’ll never guess what happened next. Microsoft came out with a new version of Windows! Which, as it did not have our custom modifications, meant that our applications couldn’t run on this version. Unfortunately, none of the new versions of the Microsoft applications (like Microsoft Office), nor any of the applications written by software vendors who wrote applications to run on the publicly available Microsoft Windows would run on our custom version of Windows which did not include the new features available in the new version of the operating system. What could we do? Well, for starters, we could choose to not upgrade any software for a few years. That worked for a while. Then there was yet another new version. And plenty of demand for new versions of commercial applications. So we bought tens of thousands of licenses for VMWare so that every employee could run two virtual machines: one running our custom version of Microsoft Windows, and one running the publicly available version. For all I know, they are doing this still.
The point being: large corporations and government agencies have always had the ability to get access to the source code of commercial software, and modify it if they wish. And if they have a good reason, they will do so. But usually, they don’t wish to. The GPL (or other such licenses) will only assist in foiling bad actors if the expectation is that individual hobbyists are responsible for regulating cyberspace and preventing cybercrime. The government and regulated utility companies and large corporations do not need special copyright licenses in order to audit proprietary software. They have plenty of existing mechanisms for doing that. After all, it’s not as hard as tracking every telephone call on the planet — an activity which you or I might not be able to engage in — but rest assured that it is not as challenging for a certain government agency as it would be for you.
And while we’re on the subject of preventing bad actors from harming us with software, I read recently that the losses from cybercrime in the US exceeded the losses from all natural disasters combined. That’s a worrisome bad actor situation. And do you know what would make a big difference in that fight? Ubiquitous code signing! And does the Free Software Foundation come down on the side of those in this fight who would deter the bad actors? No they do not! The unimpeded access to source code and running software (like the unimpeded access to unregulated assault rifles) is more important than the peace of mind which comes from reducing the threat of criminals breaking into your computer (or shooting up your school).
Next point (I’ve lost track of the numbers): why does copyrighting software provide more freedom than patenting software? The stated intent of Article I, Section 8, Clause 8 of the United State Constitution, is to “promote the progress of science and useful arts” by striking a bargain: inventors would document their inventions in exchange for an exclusive right for a limited time. That “limited time” for copyright is the remaining life of the author plus 70 years. That “limited time” for patents is 20 years. It seems to me that there is more freedom sooner with a patent than a copyright. If we eliminated the ability to copyright software, we could have more software in the public domain sooner. That sounds like increasing freedom. There is a fruitful area for proposing legislation to advance things on this front. Software patents could be of shorter duration. Software patents might require the source code to be part of the filing (which, not incidentally, provides the same “bad actor” protection as the GPL). Then the government would be enforcing universal access to the source code, as opposed to now, where that function falls to a subsidiary of Microsoft (Github). If there is a political dimension to software, then the mechanisms to enforce that freedom properly belong to government, not multi-national corporations. Yet the Free Software Foundation does not have a great record of proposing and lobbying for legislation to increase the rights of “the software”, relying instead on a single counter-intuitive quirk of copyright law. Sometime in the early 2000’s, I was invited by a telecommunications lobbying group to attend an event in Washington D.C. to lobby on behalf of free software to a collection of congressmen and senators. I remember the event because it was there that I met Bruce Momjian (who was the most interesting free software advocate) and Joe Biden (who was the most interesting politician). Unfortunately, the politicians did all of the talking, because the free software contingent did not have a legislative agenda. I doubt I’ll get another opportunity, but I sometimes ponder the hypothetical: if I did get another meeting with Joe Biden to lobby him for legislative changes to improve “software freedom”, what would I ask him to implement? If the Free Software Foundation has a legislative platform, I don’t know what it is. It seems to be an organization that focuses on litigation rather than legislation. It is against laws that others have proposed, rather than for laws that it has proposed. It focuses on products (boycotting them or building them) rather than governance (proposing legislation and regulation). The Free Software Foundation seems to be a collection of programmers who want to write software and talk about software and boycott software. It seems to be uninterested in proposing political solutions to issues it cares about — but willing to attack proposals that others have made that it disagrees with. As a political organization, it is profoundly ineffective, apparently by design.
Before so-called “free software”, there was public software. We could return to public software. As there are public libraries for books, there could be public libraries for software. Interestingly, a public library does not give people the right to make their own copies. They can check books out of the library and read them for a time, then return them so that others can read them. The activity is funded by the government. There is no reason that this activity could not be mimicked with software. It need not be “free software”. It could be licensed commercial software (using floating network licenses), funded by the government, providing software licenses to its citizenry to check out, use for a time, then return for others to use. This would increase access to software to our citizenry — increased freedom for all.
Freedom of the press is the freedom to publish without government interference. However, the existence of a “free press” does not mean that I can copy an article written by a journalist, print my own copies, and distribute them myself (whether I charge for them or not). Specifically, we are all agreed that a free press can healthily exist in a regime where copying or modifying the published work of that free press is not allowed. Is, in a word, illegal. (Illegal, incidentally, according the same regulatory regime that the Free Software regime employs to “keep software free”.) That prohibition against copying apparently, does not infringe on the freedom of the press. Similarly, I think it is manifestly obvious that freedoms of “the software” do not require the ability to make copies or even to make modifications. If we are going to use the “free press” metaphor to understand “free software”, then programs which are “free software” can be restricted from being copied or modified without impinging on any freedoms. Which is a long winded way of saying that I can easily imagine a world in which the GPL has been abandoned, but other policies and regulations and legislative actions have created a world with considerably more freedoms for “the software” than we enjoy today.
These are people who are so invested in their cultish conspiracy theories that they literally have no idea how software works today. The funniest part of the recent Stallman announcement about his return to the FSF board was the admission that they couldn’t figure out how to make a video of the announcement and distribute it. We are way beyond new board members, or a new organization to keep the flame of “Free Software” alive. It is time to admit that all the tropes and rhetoric and conspiracy theories of the so-called free software movement are an impediment to making any actual progress on making positive political change with regards to software. I believe firmly that we need to have better engagement from government to improve the positive impact that software can make on society. Regulations and legislation and governmental programs and non-governmental organizations need to keep pace with the evolving nature of software. I also firmly believe that so-called “free software” is the greatest impediment to making real progress on any of these fronts. The Free Software clique is rooted in the deep past, and committed to endlessly rehashing the software controversies of the 1980’s — when mainframes were battling with minicomputers for supremacy. The leadership is morally and intellectually bankrupt. The organization is morally and intellectually bankrupt. The “movement” is morally and intellectually bankrupt. It was an idea that had resonance and a potential future in the 1990’s. Back then, I was a believer.
That time is passed. Let the past die. Kill it, if you have to. That’s the only way to become what we aspire to be. A society with a rational governance framework for software and its effects. I’m willing to support a Public Software Foundation that advocates for that.
In the future, should I use the phrase “free software”, I will be talking about software that I don’t have to pay for. Otherwise, I’ll be talking about “digital autonomy”, or open source software, or liberal software, or, as most publications have been doing for the last few decades, “liberally licensed software”. It’s from the Latin “libre” (referring to freedom), or perhaps from the Latin “liber” (meaning “book” — a metonym for education).