Compilers (CS 153) – Fall 2023

Module Topic: Open-Source Compilers: Freedoms and Responsibilities
Module Author: Dasha Pruss

Course Level: Upper-level undergraduate
AY: 2023-2024

Course Description: “This course introduces students to the design and implementation of compilers for programming languages. Specifically, students will learn how to systematically translate modern, high-level, programming languages into efficient, executable machine code.
The course introduces a number of important concepts, such as parsing and program analysis that are useful in many other contexts beyond compilers, such as software engineering and security. Perhaps the most useful outcome of the course is that students will deeply understand the capabilities and limitations of modern compilers, and how they can be used most effectively. This knowledge is important for aspiring language designers and implementors, but also for debugging and optimizing just about any application.
This course is extremely programming intensive, as most of the understanding comes from constructing (small) compilers.” (CS 153 course website)

Semesters Taught: Fall 2021, Fall 2023

Tags

• open-source software [CS]
• tragedy of the commons [phil]
• corporate capture [phil]
• freedoms and responsibilities [phil]

Module Overview

This module introduces the micro- and macro-ethical issues raised by open-source software. Using the tragedy of the commons thought experiment, the first part of the module asks students to reflect on the freedoms and responsibilities that come with the use of open-source software. Potential tragedies include overuse and dependency of open-source software, security vulnerabilities such as the OpenSSL Heartbleed vulnerability, and long-term maintenance issues, resulting from insufficient contribution of developer time for maintaining the open-source ‘commons’. Students practice coming up with solutions to avoid these potential pitfalls of open-source software.
The second part of the module complicates the initial thought experiment setup by providing real-world context on corporate capture of open-source software, inviting students to reflect on the potential benefits and drawbacks of big tech companies’ disproportionate contribution to the open-source software ecosystem. Here, students are introduced to the tragedy of ‘sort-of’ commons, in which the commons are technically open-source but are in practice controlled and maintained by big tech companies, which forces the public to engage with those companies’ products and limits the influence of non-corporate contributors to open-source software. A small-group discussion prompt invites students to consider ways to mitigate the sort-of commons, as well as potential unanticipated drawbacks of these interventions.

    Connection to Course Technical Material

Compilers are essential to modern computing, and many popular compilers are open-source. During the lecture, students are asked to list the open-source compilers they have used, as well as any they have contributed to. The lecture also raises the question of whether anyone should be allowed to own something as fundamental to computing infrastructure as a compiler.

Goals

    Module Goals

1. Understand the origins and motivations of open-source software.
2. Understand the idea of a ‘tragedy of the commons’ and how it applies to open-source software.
3. Understand the role big tech companies play in the maintenance and shaping of open-source software.
4. Practice reasoning through the ethical responsibilities that come with the freedoms of open-source software (e.g., the responsibility to contribute resources to those projects).
5. Practice arguing for ways to resolve two ‘tragedy of the commons’ situations in open-source software.

    Key Philosophical Questions

1. Are there ethical obligations that you might acquire from using open-source software?
2. On whom does the responsibility of maintaining shared community resources fall?
3. How do we weigh the tradeoffs between goods that are fully public and goods that, while publicly accessible, depend on corporate sponsorship?

Materials

    Key Philosophical Concepts

• Freedoms and responsibilities
• Tragedy of the commons
• Thought experiment
• Argument by analogy
• Corporate capture

    Assigned Readings

• CNBC Video: “The Rise of Open-Source Software” (13:50)
• Excerpts of Chinmayi Sharma’s Tragedy of the Digital Commons (2023), pages 1-10; 20-30; and 60-61.

Implementation

Class Agenda

1. Reading response (before class)
2. Introduction and tie-in to compilers
3. Poll on who has used and contributed to open-source software
4. Background on the origins of open-source software and responsibilities 
5. Tragedy of the commons in open-source software
6. Discussion of how to avoid a tragedy of the commons with open-source software
7. Corporate capture and the tragedy of the ‘sort-of’ commons 
8. Discussion of how to avoid a tragedy of the ‘sort-of’ commons with open-source software
9. Wrap-up and assignment instructions

Sample Class Activity

Students are introduced to the following scenario: suppose Barbie and Oppenheimer both have a sheep that they bring to graze in the Boston Commons. Each of the two helps maintain the commons to make sure that it does not become overgrazed and depleted. One day, Barbie realizes that she can bring more sheep to graze in the commons without contributing extra to maintain the commons, so long as Oppenheimer keeps doing his part. Oppenheimer, too, brings in more of his sheep to graze in the commons and stops contributing to its maintenance. Before long, the grass in the commons is eaten up completely, and Barbie and Oppenheimer’s sheep both perish from hunger. This story is an example of the tragedy of the commons, which occurs when common goods are overused and unmaintained.

The TA draws an analogy between this example and open-source software, in which the commons are the open-source code base and the tragedy (e.g., overuse and dependency, security vulnerabilities, and long-term maintenance issues) results when too many people use open-source software without contributing to its maintenance.

In small groups, students are asked to address the following prompt:

1. How do we avoid a tragedy of the commons with open-source software? Come up with three possible strategies to help us solve this problem.

After discussing in small groups, the TA calls on groups to share what they talked about and collects a list of possible strategies on the board. The drawbacks of each potential solution are discussed.

    Module Assignment

“In the style of a blog post (250–300 words), write an answer to the following prompt:

To prevent a tragedy of the commons in public lands, governments sometimes limit individuals’ access to common resources. For example, to prevent overfishing from a lake in a National Forest, the US Forest Service may require the purchase of fishing permits to limit how much fish an individual is allowed to catch.

If we make an argument by analogy to open-source software, we might conclude that the government ought to put limits on how much individuals or large companies can use (or contribute) to open-source software.

• Do you think this is a good analogy? Explain your reasoning.
• Do you agree with the conclusion? Why or why not?”

A question about the module was also included on the final exam for the course:

“Why do open source compilers face a potential ‘tragedy of the commons’?

1. Open source compilers could be forked into a proprietary project at any time.
2. Open source compilers are free to use but might not get maintained.
3. Anyone can contribute to open source compilers, regardless of their intentions.
4. Open source compilers can be used for unethical purposes.”

(The correct answer is 2.)

Lessons Learned

Students listened attentively to the lecture segment. They were engaged during the discussion, and raised many issues that hadn’t been explicitly discussed in the lecture (e.g., examples of open-source acquisitions at companies they had worked at, and real-world experimental compensation systems for open-source contributors). No one group was unanimous in thinking that the tragedies of the commons in open-source software were easy to solve.

• The poll at the beginning of the class warmed up students to talking in a low-stakes setting, which can be valuable in a class that is normally lecture-based.
• Using a humorous case study with corresponding visuals in the slides increased students’ attentiveness and engagement with the module material. The absurdity of the imagined case study seemed to make it easier for students to notice important disanalogies between the open-source software and the Barbie-Oppenheimer scenario, which provided an excellent segue to discussing strategies to dispute a thought experiment.
• Students had mixed reactions to the second portion of the module; some students did not share the intuition that there was anything wrong with corporate capture of open-source software. Future iterations of the module could focus on one specific case study of corporate capture in which there are tangible harms.
• Students assumed the TA to be knowledgeable about specific technical details and case studies of open-source software. Signaling areas of expertise is important upfront.
• Responses to the assignment were thoughtful and well-written. Students were quite divided on whether issuing fishing permits was a good analogy/strategy or not. A weak majority were critical of the analogy and rejected the idea of government limits, but there was a lot of nuance. There was also a wide variety and creativity in the kinds of issues and strengths students identified with the analogy.