CS 275: Programming Abstractions — Fall 2024

Course Description

This is course broadly covers the core ideas behind functional programming and programming languages. We will learn Racket and use it (as well as other languages!) to think about the features of programming languages and how they are implemented.

Assessment

Your final course grades are based on four categories.

• 10% Class participation
• 60% Homeworks (including the MiniScheme project)
• 20% Exams
• 10% Summary problems (final project)

Class participation will be measured by answering iClicker poll questions so make sure you answer each one.

Homeworks

Homeworks should be done either individually, or in groups of two.

Each homework has a due date (which is typically Friday) and a “first commit” date (which is typically the Monday before it is due). For full credit on the assignment, you must push a commit to GitHub.

Drafts of most of the homeworks for the semester are available below for your reference. Any assignment that doesn’t yet have a GitHub Classrooms link is subject to change without warning.

• Homework 0
• Homework 1
• Homework 2
• Homework 3
• Homework 4
• Homework 5
• Homework 6
• Homework 7
• Homework 8

MiniScheme project

Several of the homeworks involve implementing an interpreter for a Scheme-like language. As with the other homeworks, these should be completed either individually or in groups of two. However, if you’re working with a partner on the interpreter, you should work with the same partner on all parts.

The details of the MiniScheme project can be found here.

Exams

There are two exams in the course, equally weighted. Each exam is a take-home exam. You’ll have 24 hours to complete the exam which will be due at the end of the day of the exam.

Summary Problems

Summary Problems function as the summative assessment in this class. The problems will be released at the beginning of the semester and you will have the ability to work on them informally throughout. You can submit problems for feedback from me, but not a grade, until Friday, November 22 at 23:59.

More information about the Summary Problems and the starter code is available here

The actual Summary Problem Final Project, which includes these problems plus some additional questions, will be released before the last day of classes. It is due by our Final Exam Slot: by 21:00 on Monday, December 16. More details on the Summary Problem Final Project will be released after the second exam.

Course Materials and Technology

Required Texts

We’ll be using Racket Programming the Fun Way: From Strings to Turing Machines.

We’ll also use The Racket Guide and The Racket Reference as required.

Course Technology

There are three main pieces of technology you will use in this class.

• iClickers. Similar to other CSCI courses you have taken, we will make use of iClickers for in-class questions. Answering these questions (or not) determines your course participation score.
• Racket/DrRacket. We will be programming in Racket (v8.14) this semester and DrRacket is the typical IDE of choice to use with Racket.
• Git/GitHub. We will be using GitHub to submit assignments. You will need to make a (free) account on GitHub, if you do not already have one.

Resources

• Racket is the implementation of Scheme we will be using. You can download the DrRacket interpreter and IDE for it here.
• The Scheme Programming Language by R. Kent Dybvig.
• Structure and Interpretation of Computer Programs by Harold Abelson and Gerald Sussman.

Learning Goals

By the end of the course,

• You will be proficient at thinking recursively;
• You will gain experience with functional programming;
• You will learn about the core practical and theoretical ideas underlying programming languages;
• You will gain experience reasoning about programs, their implementations, style, and testing;
• You will learn how programming language interpreters are implemented and you will implement one yourself; and
• You will learn more about how to learn new programming languages and how to become more proficient at the ones you already know.

Course Policies

Prerequisites

CS 151 is required. CS 241 is recommended. You should be comfortable with programming with higher level languages, such as Python or Java. No prior experience with Scheme or functional programming is expected.

Attendance Policy

You are not required to attend; however, you receive points for participation in each class period that count toward your final grade. You can miss up to 3 days without penalty. Research indicates that students who attend class are more likely to be successful. You are strongly encouraged to attend every class. If you are unable to attend class, you should consider asking a classmate to take notes for you.

Missed or Late Work Policy

Homework is due by 23:59 on the day specified on each homework page. You have 3 late days that you can use throughout the semester. Each day that a homework is late decreases the number of late days you and your partner have left. If you run out of late days, homeworks turned in late will receive a score of 0. You are responsible for keeping track of your late days. There will be no exceptions to this policy without prior approval from Prof. Checkoway.

College policy prohibits accepting any work after the scheduled final exam time for a course without an incomplete.

Electronic Communication Policy

All electronic communication with course staff should take place on Ed unless emails are specifically requested by the staff. Course staff may, from time to time, respond to emails, but a response to one email does not guarantee a response to a second. Use Ed!

Collaboration Policy

You are allowed, and encouraged, to work in groups of size two on all homeworks. You are free to have different groups for different assignments with the exception of the MiniScheme interpreter which should be completed with the same partner (or individually). You are allowed to talk to anyone in the course about the assignments; however, you are not allowed to share solutions with anyone outside your group. Doing so is academic misconduct.

Academic Integrity Policy

You must adhere to the Oberlin College Academic Integrity Policy.

Please familiarize yourself with the Honor Code.

Much of the work we cover in this course represents classic examples in the field, therefore solutions to similar problems are readily available in the wild. Do not actively look for them as this only decreases your own learning and can result in a potential Honor Code violation.

Artificial Intelligence Policy

AI tools, including but not limited to, GitHub Copilot and ChatGPT are not allowed and are considered a violation of the Honor Code for use at any point in this class.

Religious Holiday Observance Policy

Students wishing to be excused from class in order to observe religious holidays must follow the Oberlin College Religious Holiday Observance Policy.

Acknowledgments

The content in this course is adapted from previous iterations of CSCI 275 at Oberlin, most recently by Molly Feldman and Bob Geitz. There are also ideas throughout inspired by other programming languages researchers and educators – I thank them in advance for their perspectives on teaching this topic. I will do my best to acknowledge any other material adapted from other sources where I use it, as appropriate.