Free as in Way

Posted: 2024-03-13.

Free and open source software (FOSS) is often described as being either "free as in speech" or "free as in beer". This post will discuss the rise of a new paradigm, "free as in way": software as infrastructure[1]. We'll also see how the apparent prominence of FOSS in today's computing world can be illusory when it comes to freedom and openness.

Episode IV: A New Paradigm

During the rise of personal computing (say pre-1990), advocates recognized a dichotomy between proprietary software, which may exploit you even as you use it, versus "free and open source software (FOSS)". Today, software mediates almost everything we do: it runs our cars and coffee makers, our phones and finances, our (e-)books and browsers. Much of that software comes from companies with incentives to close and control it, and through the software, influence or control our decisions.

In some senses, FOSS has achieved amazing success despite corporate incentives to close software down. But I'll argue that since 1990, and especially since about 2010, there have been three major paradigm shifts that change the way we need to think about "free" and "open" software:

1. A shift from individual units of software to networked, interconnected software;
2. A shift from static software to continuously evolving software; and
3. A shift from the proprietary-vs-free dichotomy to a common paradigm of proprietary-layered-on-free.

Together, these changes resulted in a new, important class of "free" software as infrastructure, analogous to roads. Therefore, I call this paradigm "free as in way", or "free-way software". We'll explore these shifts and look at the implications.

First, let's recap.

Speech or Beer (or both)

Let's first define "free" versus proprietary. Some software is proprietary: nobody except the creator may read, access, or modify the programming instructions. In contrast, non-proprietary software mostly falls under a broad header of Free and/or Open Source Software (FOSS). FOSS advocates believe it is harmful to run proprietary code. The main two philosophical stances in FOSS are often characterized as "free as in speech" and "free as in beer".[2]

We can summarize open-source software as free-as-in-beer. Open-source refers, at a minimum, to something you get: knowledge of what your software does. However, most proponents of FOSS believe that software should come with more guarantees than that. Hence, advocates such as the Free Software Foundation and the Software Freedom Conservancy use the term "free" or "libre" software for software that is free-as-in-speech. Like free speech, libre software is about rights you have: in particular, the rights to modify the software, run it as you wish, redistribute it, etc.

FOSS, in theory, is a tool and ally of the person using it, designed to help and empower them. Proprietary software often is designed to limit, manipulate, or exploit its user. This will be important later.[3]

An example of proprietary, nonfree software is that in a typical Smart TV. It limits your choices of what apps to install, inserts advertisements where you don't want them, collects data about you, and generally tries to control your experience rather than empower you. Similarly, Microsoft's Windows and Apple's iOS are nonfree. In contrast, many Linux distributions for personal computers, such as Debian and Fedora, are free and libre software. They don't show ads, collect data[4], limit the apps you can install, or try to influence or manipulate your decisions.

In summary, we have long categorized software as either proprietary or FOSS, where FOSS means at a minimum free-as-in-beer if not free-as-in-speech. But next, this post will discuss the rise of a new type of "free" software paradigm.

Episode III: Revenge of the Proprietary

Let's walk through three empirical observations about how software works today, that were generally not true in the first era of personal computing when the principles behind FOSS were established. First, painting in broad strokes, software's primary interaction used to be with the person using it (and the computer it ran on):

But now, software increasingly relies on and interoperates with other software. This comes partly from connectivity over the Internet, where software interacts over APIs. It also comes partly from runtime platforms, where requirements of e.g. iOS, or the Python programming language, or web browsers and standards, affect the design of software that run on those platforms. And it comes partly from the software-development ecosystem, where developers rely on large numbers of tools, frameworks, libraries, and other dependencies.

Next: for personal computing until at least 2000, software was mostly shipped similarly to hardware. Actually, it was shipped on hardware (floppy disks, CDs, etc). It was installed, then it generally ran on the machine, just as shipped, for the lifetime of the software.

Today, of course, most software is ephemeral; we download it, run it, update to a new version (discarding the old), and repeat. This is increasingly true even for contexts like vehicles or televisions. A primary reason for this is the First Law, dependency amplification. To keep the software buildable on the developers' platforms, it needs to adapt to any updates to its dependencies, programming language libraries and runtimes, etc. To keep the software runnable, it needs to adapt to any updates to APIs, standards, regulations, and other software it interacts with. This all results in a Red-Queen race to maintain software:

Next, we come to the structure of the software. Until relatively recently, the traditional choice would be between proprietary software or FOSS. Think of Windows versus Linux, Internet Explorer (etc) versus Firefox, Windows Media Player versus VLC, Zoom versus Jitsi, Photoshop versus GIMP, etc.

But the situation today is often more nuanced. Since 1990, and especially since the 2000s, FOSS has grown massively and in two senses dominates the software industry. First, developers, even at companies producing proprietary software, increasingly rely primarily on FOSS tools and infrastructure. Second, much proprietary software is forked from or built on top of FOSS: iOS on BSD; Android on Linux; etc. This may be because FOSS is inherently better, or at least better adapted to the First and Second Laws.[5] But in any case, most software that most people use is still not itself FOSS.

Free-way Software

Due largely to the Three Laws --- dependency amplification, Red-Queen ecosystems, and FOSS-for-me-not-thee --- our current software ecosystem features many large open-source software tools that follow these laws and act as infrastructure for developers and companies. Concretely, free-as-in-way or free-way software has these characteristics:

• It is a framework, platform, or foundation. It supports other things that people do.
• It is highly interconnected. It is tightly related to other pieces of software and/or standards and/or APIs.
• It is open-source and open to the public, although it may not be fully free-as-in-speech.
• It is often canonical, the main or accepted way to do something, or at least has large market share.

Some main examples are Android; the Chromium browser that Google Chrome is based on; further, the web browser engines Webkit, Blink, and Gecko; Docker and Kubernetes; the Unreal and Unity game engines; popular programming languages such as (particularly) Python, Google's Go, Oracle's Java language and JVM framework, and Microsoft's C# language and .NET framework; the Node.js ecosystem; the Linux kernel itself; many Linux distributions such as Debian, Fedora, CentOS, etc.[6] As the list shows, free-way software is generally controlled either by a corporation or a non-profit organization.

Picture each thing people do with software as a geographical location. Free-way software is like a highway in the sky with on-ramps stretching down to connect to various spots. At first, the freeway needs to build ramps to connect to popular locations. Later, as the freeway becomes highly popular, locations will build or tailor their access ramps for compatibility with the freeway.

Combining the Three Laws, we have a picture of free-as-in-way software infrastructure that evolves rapidly in tandem with its interconnected ecosystem. It is an industry standard and is used by developers and companies as tooling and/or as a basis for (often proprietary) products. The challenges of dependency amplification and Red-Queen development are managed by the large FOSS project and its community. This allows companies to focus on their relatively small proprietary extensions or additions. For example, Microsoft's Edge web browser is now based on Google's free-as-in-way Chromium project, as are Brave, Vivaldi, and Opera.

Economics of Free-as-in-Way

In First- and Second-Law systems, keeping up with frequent updates to many interconnected ecosystems is a huge barrier to entry. Often, it is only achievable for a very large FOSS project. Network effects make the winning projects even more popular and entrenched, resulting in a market dominated by a few large options.

These winner-take-all dynamics create business incentives to sponsor and control the major project in a space, even if that project is ostensibly FOSS[7]. One business plan is freemium products like the Unity game engine, which use a free tier to become a broad de-facto standard, then make money on enterprise customers. Another is commoditize your complement, where e.g. hardware manufacturers like Nvidia contribute to free-way infrastructure that runs on their hardware.

But a more insidious business model is Embrace, Extend, Extinguish. Consider a large open-source free-way software project like the Android operating system or the Chromium web browser, both controlled tightly by Google:

• Although it's open-source, it's effectively un-forkable, i.e. is extremely impractical to copy and modify, due to dependency amplification and Red Queen ecosystems. A fork would go out of date quickly without a large group effort.
• Even if it is libre for developers, it is often not libre to end users. It makes decisions that do not benefit the user of the software, but influence or control the user for the benefit of the producer (things like ads, privacy and data collection, etc).
• It is protected from competition by network effects, such as the amount of compatible software designed to work specifically with it (e.g., websites designed to work well on Chrome but not other browsers).

Of course, nothing theoretically prevents you from building a second highway in the sky, right above the first, that connects to all of the same exits and interchanges. For example, Firefox is a separate FOSS project that competes with Chrome. But in practice, the difficulty is very high due to the size, complexity, and interconnectedness of the space. It is even harder if the dominant project adds features or changes standards --- the "extend" phase --- and the interconnected "locations", such as apps or websites, update accordingly. This dynamic could allow a free-as-in-way project like Chromium to eventually extinguish competitors. FOSS wins, but freedom and open source both lose.

Episode IX: Rise of Sidewalkers

We've seen two main problems with free-as-in-way software:

1. End users still typically face non-free, exploitative software layered on top of free-way infrastructure.
2. Free-way software can occupy a natural monopoly, being difficult to outcompete; and can be exploitative despite being FOSS.

These are very challenging problems. For the first, it's important not to confuse the success of free-as-in-way software with success of free-as-in-speech. However, I also don't think the nature of the fight for libre software has changed that much, so I don't have more to add here.

For the second problem, we can break down the barriers to competition in several ways. In general, simplification is our friend. Simpler ecosystems with fewer exposed points of interconnection help slow down the Red Queen's pace of updates and changes. Simpler, smaller standards (such as web standards) are easier to meet, making competition easier.

A compromise could be standards that incorporate the old idea of progressive enhancement. On the Web, pages might be required to adhere to a small set of standards, and could optionally take advantage of a larger, newer set of features. This would make it possible, for example, to design a new browser that is guaranteed to function on critical sites like banking, shopping, or government sites, even if it doesn't implement all the bells and whistles of Chrome.

Finally, we should aim for free-way software, i.e. important software infrastructure, to be managed not by small groups or for-profit corporations, but by community-run and democratically-principled organizations. If a piece of software must act as a public good, it should ideally be managed according to public interests.

Notes: