Interested in adapting one of our modules but not sure how it all comes together? This page will guide you through how to read our repository entries, and show how it all comes together. It is based on the repository entry for a  module taught by Dr. Trystan Goetze in Fall 2021.

The repository entry content makes up the main column of the page. As in the repository itself, many blocks of text have additional information from the module designer on their pedagogical choices and reflections—you can make these appear by clicking the ⓘ icons.

To the right of the blocks of content (or above, on mobile) are yellow annotations to explain the purpose of each section, and how to make use of it. Towards the end is a special section, not usually a part of our repository entries, to show how all the material comes together in the module delivery.

Scroll down to read more, or use these links to jump to a specific section:

• Course Description
• Module Overview
• Connection to Course Technical Material
• Goals
  • Module Goals
  • Key Philosophical Questions
• Materials
  • Key Philosophical Concepts
  • Assigned Readings
• Implementation
  • Class Agenda
  • Sample Class Activity
  • Module Assignment
  • Lessons Learned
  • Pedagogical Insights
• Finished Product
  • Lecture Recording
  • Slide Deck
  • Snapshot of class discussion
  • Assignment instructions and rubric
• Additional Research Notes

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.

This module took place in a course on compilers—the type of software that transforms code written by human beings into the 1s and 0s that the computer can actually run. The description of the course comes from the CS instructor’s course website. We include these descriptions in the repository entries in order to provide the context in which the module was developed and delivered: it is a cornerstone of our methodology that the technical and philosophical material should be closely aligned. While most of our modules have been in computer science courses, a few have been in closely related subjects, such as applied mathematics. As you explore the repository, look for course descriptions that resemble courses, units, or lessons in your own curriculum.

Tags

• free software (cs)
• open-source software (cs)
• licensing (cs)
• rights and freedoms (phil)
• responsibility (duty) (phil)

Tags are written by the module designers, and are noted as either CS-related, philosophy-related, or both. These are used to help users find relevant content using the repository’s search engine.

    Module Overview:

In this module, we consider the question of whether the freedoms protected by free or open-source software come with any ethical responsibilities. After an introduction to the history of free software, students learn about the four freedoms protected by free software licences, such as the GNU General Public License (GPL). We then consider some of the differences between free, open-source, and proprietary software, and why you might choose one licensing scheme over another. We then raise a philosophical question: do freedoms come with responsibilities? In particular, this is framed as an issue of giving back to the community or institution that safeguards those freedoms, so that they can continue to be preserved. Using an analogy with the Tragedy of the Commons, we explore several arguments for and against the idea that users of free or open-source software have an ethical obligation to contribute to those software projects. We also consider whether other institutions, such as big tech corporations or governments, could do the job instead.

Students continue thinking through these issues by discussing a realistic case study that asks them to imagine a dialogue between a software developer and her boss over whether to release a new compiler backend as open-source or to keep it as a trade secret. In the follow-up assignment, students continue to think through these issues by writing a short piece on whether the government should levy a software tax to fund free or open-source projects, or, whether the purpose of a piece of software matters when choosing the licensing scheme one publishes it under.

The Module Overview is like the abstract of a journal article or the executive summary of a report: it gives a high-level description of the module’s content, focus, and activities. Like an abstract, you can use the overview as a way to decide whether a given repository entry is relevant to your own lesson planning.

    Connection to Course Technical Material:

The connection to the course material is made in a few places explicitly, but implicit throughout the lesson is that many popular compilers are entirely or partially free or open-source. In addition, the lecture raises the question of whether anyone should be allowed to own something as fundamental to computing infrastructure as a compiler – but, because compilers are dependent on proprietary hardware on the backend, a conclusion that compilers should be free software may quickly become an argument that all software should be free, which is a much more controversial stance. The case study also engages with the course material by imagining a developer who creates a new backend for a compiler to use in creating software for medical devices. One of the assignment questions (on the purpose of the software) may also bring in compilers as one function software may serve that could be relevant in deciding whether to release it as free or open-source.

This section can be used in addition to the course description to find modules that are relevant to your own context. We strive to keep the technical content and philosophical content of a module closely aligned, as this helps students understand the significance of the social and ethical issues we discuss to their learning in the course more broadly. However, this can also be one of the more challenging parts of module development. For this reason, we consult with computer scientists when developing material, and we use modules previously designed for a given course as a starting point when designing a new module. In addition, some repository entries may be usefully adapted to quite different courses when there is overlap in the scope of the technical content discussed. For example, we’ve repurposed case study material from this module for CS 50 and this module for a graduate course on behavioural economics in a module for the CS PhD Seminar.

    Module Goals:

1. Understand the origins and motivations of free and open-source software.
2. Know the differences between free, open-source, and proprietary software.
3. Understand the freedoms protected by free software.
4. Be familiar with and critically engage with arguments for and against the notion that the freedoms protected by free or open-source software come with ethical responsibilities to contribute to those projects.

The module goals are its learning outcomes. These goals aim at all levels of Bloom’s cognitive taxonomy, from knowledge of philosophical concepts, to understanding of the social and ethical issues under discussion, to the application of philosophical concepts to those issues, to the analysis of a case study in terms of those concepts, to the creation and evaluation of reasoned arguments in favour of particular position. Consider your own learning goals as you brainstorm possible computer ethics lessons.

    Key Philosophical Questions:

1. Do freedoms come with ethical responsibilities (duties, obligations)?
2. On whom does the responsibility of maintaining shared community resources fall?
3. How do we decide between different value sets, such as the business interests of a company vs. the ethical good the company could do?

These are the questions with which the students will grapple, with the help of the philosophical content introduced by the instructor. Typically, there is one primary question and several ancillary questions, which are often introduced near the beginning of the module and addressed directly by case studies, using the philosophical concepts that have been introduced. We separate these from the learning outcomes and philosophical concepts because they are both important learning material in their own right (one of our goals is to have CS students learn which questions to ask) and a distinctive part of our philosophical pedagogy that ties all the elements of a module together. This is another good place to look as you’re developing your own computer ethics content: you might have similar philosophical questions that you want students to be able to answer, though you don’t necessarily need to use philosophical questions as the throughline of your own lesson design.

    Key Philosophical Concepts:

1. Freedoms / Rights
2. Responsibilities / Duties
3. Different domains of values (ethical, business, legal)

This section lists the concepts, theories, and thought experiments that will help students to understand and reason about the philosophical questions identified above. If you’re aiming to teach students about a particular philosophical concept, regardless of the specific technical content to which it will be linked, this is a good section to look at to see if a repository entry might be useful to you. Note that even though we describe these concepts as philosophical, they might be associated with other academic disciplines, such as the social sciences, science and technology studies, feminist theory, critical race theory, or disability studies, among others. We aren’t interested in policing the boundaries of “the philosophical.”

    Assigned Readings:

1. Richard Stallman, The GNU Manifesto
2. Optional reading: Trystan Goetze, “An IP Cheat Sheet”

Choosing a reading for an Embedded EthiCS module is its own kind of challenge. CS students are often not assigned long or essayistic readings in their courses, and most will not have read works of philosophy before. So we try to use shorter readings that are more accessible, often drawing from popular tech or business periodicals. Sometimes we write up our own handouts or lab packets. Readings might introduce philosophical concepts, case studies from the news, or discussion of ethical topics in technical periodicals. You may find the readings linked in various repository entries useful to assign to your own students—or, you might use them to help develop your own material.

Class Agenda:

Every repository entry includes an agenda for the class, to give an idea of how the session ran. Not every module has as strict a time breakdown as this one. You can use this to think about how to structure your own lessons.

    Sample Class Activity:

Song Li is a senior developer for Physicker, a healthcare technology company. Her boss, Mavis Sloane, has asked Song to use mainly open-source tools so that the company can save on costs. Song selects an open-source compiler that works well with the languages Physicker’s development pipeline prefers.

Song soon finds that some of the hardware used by a few of Physicker’s clients isn’t very well supported by the compiler she chose, and there aren’t good open-source alternatives with a frontend that supports their preferred languages. So, she spends some time developing a new backend for the compiler.

Sloane is impressed, and wants to keep the new backend as a proprietary trade secret. Song, on the other hand, wants to release her work under the same open-source license as the original compiler.

• What could Song argue when she presents her case to Sloane?
• What counterarguments might Sloane make in response? How could Song reply?

The main content of the page here is the case study that was used in the class discussion. The marginal note explains how the time was used. It was tricky to come up with a case study that brought things back around to compilers. The module designer and the course head decided on an example using medical equipment because this use case often involves unusual or non-standard processors and other hardware constraints that are not typical of most computing systems. This enables us to consider a case where it is the compiler itself that is the technology under consideration, as a compiler may need to be adapted to the medical hardware. As you explore the repository, you’ll find some modules that are a mix of lecture and discussion, like this one, and others that jump straight into a lab activity. For an example of a module that is more heavily activity-based, see this entry from CS 136 Economics and Computation.

    Module Assignment:

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

Option 1: Should the government levy a tax on proprietary software, and distribute the funds to support free and open-source software? Why or why not?

Option 2: Does the purpose of a piece of software (e.g. medical, accounting, software development) matter when considering whether to release it under a free or open-source license? Why or why not?

When possible given the constraints of the course, we try to have a follow-up assignment that counts towards the course grade. (Some courses don’t have the time in their schedules or space in their assessment structures.) The ideal is for students to have to demonstrate some ethical reasoning connected to the module topic in the context of their technical work, but again, this isn’t always possible. This module uses a fairly common follow-up assignment that we use when the closer tie-in isn’t possible, namely, a short reflection assignment.

    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. power dynamics between employee and boss, business values vs. ethical values).

I used a website called Padlet to capture their thoughts from the discussion, which was effective in giving us a fall-back resource for continuing the discussion when students were no longer raising their hands. The Padlet was filled with far more notes than we could possibly take up in class. No one group was unanimous in thinking that the issues in the case study were easy to solve.

    Pedagogical Insights:

1. The students who attended were remarkably engaged. This may be an effect of the course being upper-division.
2. Attendance was good, but probably less than 50% of registrants. This may be an effect of class attendance being explicitly optional for the majority of class sessions.
3. Students didn’t seem to need/want much time to think individually on the case study before talking in groups.
4. Concerns about business values (e.g. profitability, reputation, legal risk) seemed to be well-engrained in the students, and made it sometimes challenging to shift to a focus on ethical values.

After the module, we make note of things that went well or not so well, and why that might be. This helps when we iterate on past work. Please use these reflections in your own designs!

Finished Product

Lecture recording

This lecture recording was captured using the lecture hall’s built in equipment and Panopto. The recording ends just as the students are breaking up into their small groups; this is to preserve student privacy. Recording lectures and adding closed captions is a best practice for accessibility, especially when some students will be missing class due to illness in the ongoing pandemic. We do not recommend attempting to do a hybrid discussion- or activity-based session—for most instructors, this is too much to handle at once.

Free Software: Freedoms and Responsibilities

You can click through the slides from the lecture here. You’ll notice that the ethical and technical content is interspersed rather than a presentation of the philosophical content followed by a direct application. Depending on the concepts, ethical issues, and technologies under discussion, you may want to structure the flow of the material differently.

This is a screenshot of the Padlet classroom response page used for capturing the students’ discussion. All comments are anonymous. This strategy helps to make students take notes to speak from during the large group discussion, shows all students what their peers are thinking, and provides a number of seeds for discussion that the instructor can use if students are reluctant to raise their hands. It also gives students who missed the class the opportunity to see what sort of discussion took place. The extra space for additional comments also helps with building classroom community in the limited time we have—you’ll see mainly jokes and comments about elements of the activity design here.

Assignment instructions and a rubric

Including a rubric and detailed instructions is especially helpful to CS students who may not be familiar with what is required in a reflective writing assignment. We often have students do this sort of reflective or argumentative writing, but other follow-up assignments include: long answer questions on exams, reflections on ethical choices made in technical assignments, or ethical questions in problem sets.

Additional Research Notes

1. While conducting your research for this module, what materials (articles, blog posts, podcasts, etc.) did you find most helpful? Please include one or two sentences by way of explanation if it won’t be obvious to a future GF what role the material played in your preparation for the module.The most helpful resources I used were Magnani’s slides from the previous iteration (available in the Teaching Lab Google Drive) and my own past lecture slides from a unit on intellectual property that I taught in a computer ethics course (some of these are shared in the Google Drive as well). For understanding compilers, in addition to Stephen Chong’s opening lecture for CS 153 (which was recorded), I relied on this webpage – Introduction to Compilers
2. While developing this module, did you have any ideas that were left on the cutting room floor (i.e. ideas about potential topics, readings, activities etc. that were not ultimately incorporated in the module or final repository entry)? If so, please record them here and briefly explain why they did not make the final cut (e.g. time constraints, CS instructor preferences, etc.).At the Set A stage, the module had far too much planned content on intellectual property law and foundations, which I condensed into an optional one-page handout instead.The initial Set B forms of the case study and assignment were focused on a more general question of whether all compilers or all software should be free. After discussion with the professor, these were refined to be both more realistic and more tightly focused on how the choice between publishing under an open-source or proprietary license might actually arise in connection with a compiler.A suggestion from Arpita Biswas in the Teaching Lab: Another topic that could be explored, which might have an even closer connection to the course material: how the choice of computer language affects the environmental impact of the project. Some languages require additional processing power when being compiled, especially when used for machine learning. For large projects this can make a difference to their electricity usage and carbon footprint. This topic wasn’t adopted because of concerns of overlap with another module that is on environmental impact of computing (specifically, data processing for machine learning models).
   • A recent paper on this topic: Energy Efficiency across Programming Languages
   • Summarized in this news article: Java is one of the most energy-efficient languages, Python among least energy efficient
3. A more informal take on lessons learned: What else should a future GF know if we have the opportunity to run this module again? For example, based on the actual performance of the module you may have additional insights or speculations to share – If a class activity was successful, do you think the class size was a key factor? Did you perceive any differences between undergraduate vs. graduate students with respect to receptiveness to the module or success on the assignment? Etc.The class size was small (only about half of the 70 registered students attended), which made it easier to circulate in the room when students were in small groups. But I have successfully run similar activities in a class size of 150, so class size isn’t a big factor here. Simultaneous enrollment and optional class attendance policies may have depressed turnout, despite the professor asking all who could to attend in- person.
4. After reviewing the student feedback form for the module, were there any comments or general takeaways that you think would be useful for future GFs to take into consideration if they are tasked with repeating this module?
   
   The feedback pool was small (5 responses). Students generally thought the module was delivered well. There was some desire for additional discussion of the differences between alternative licensing schemes – GPL vs. Apache vs. GoLang etc.

These notes are usually hidden in our repository entries, but we take them for every module we’ve run. The questions here are meant to provoke reflection that is helpful for future module designers. It’s rare that a module is run exactly the same way each time, but ideas and readings often get repurposed. After you run your computer ethics lesson, consider similar reflection questions to help with future iterations.

Home

About
  About Approach

Team
  Teaching Lab Team
  Faculty Alums

Column block with website map links

History

Modules
  Repository Tips
  Module Repository

News

More Resources

Contact Us