CS 61 is a first course in computer systems programming, meaning the creation of high-performance programs that use computer hardware effectively. Although many programs today are written in high-level programming languages—and many programs simply glue together existing components—the best programmers are craftspeople who understand their tools. For software builders, this requires a working knowledge of computer internal organization. It means understanding how machines interpret instructions, how compilers turn programming languages into instructions, and how operating systems combine programs and libraries to create running code. And it requires understanding the factors that affect code performance.
CS 61 introduces you the tools you need to build robust, efficient software and the mental tools you need to understand software systems written by others. We hope you’ll discover that systems software development is fun and worth the effort. We intend the course to be broadly accessible, though it will be easier for those who have some experience with systems programming in C++ or other C-like languages.
After this course, you should be able to:
- Write robust and efficient software.
- Use operating system interfaces effectively.
- Read and explain C and C++ programs.
- Read and explain simple assembly programs.
- Write programs that combine C/C++ and assembly language.
- Solve problems using computer arithmetic.
- Solve coding exercises requiring synchronization of concurrent activities.
- Analyze program performance and apply basic optimizations.
- Write simple network servers.
Diversity and inclusion
CS61 welcomes a diversity of thoughts, perspectives, and experiences. The CS 61 teaching staff respects our students’ identities, including but not limited to race, gender, class, sexuality, socioeconomic status, religion, and ability, and we strive to create a learning environment where every student feels welcome and valued. We can only accomplish this goal with your help. If something is said in class (by anyone) or you come across instructional material that made you uncomfortable, please talk to the instructors about it (even if anonymously).
Programming assignments are a critical part of the course. There will be six assignments handed out at one to two week intervals. We encourage collaboration among students (subject to the collaboration policy below), but all assignments will be graded based on individual turnins. This is a change from previous years.
Assignments will be due at midnight (11:59:59pm Eastern) on the due date.
Late work and your health
Each student has 144 free late hours which can be applied to any
of the assignments. (That’s a total of 6 late days.) This means that
all assignments can be late by a cumulative total of 144 hours without
penalty. If you wish to take late hours, you must add a prominent "DO
NOT GRADE" notice to the top of your
README.md. This notice must be
visible on the grading server from the assignment deadline until your
submission is ready for grading.
Significant penalties will kick in after the 144 late hours are exhausted, such as a letter grade off on over-late assignments per 4 hours of additional lateness, down to a minimum of F.
Skipped assignments receive a zero, not an F. Zero is far worse than F (in the letter grading system F is often represented as 50%). You don’t want zeros on any assignment: a great way to get a bad class grade is to skip an assignment. It’s better to complete and turn in assignments even if you’ve already used your late hours.
If you find yourself struggling, please contact the instructors as soon as you feel able; and if you have a health condition that affects your learning or classroom experience, please contact us so we can seek accommodations. We do not generally make exceptions to the late policy, but we work hard to help all our students complete the course without overwhelming stress.
Attendance in 2020
Lecture segments will be recorded at varying times of day with rotating groups of “active listener” students whose attendance is required (~12-16 per lecture). Over the course of the semester, each student must attend about 10 lectures as an active listener (exact number to be determined). There will often be some prep work, to get people ready for the lecture; active listeners must complete the prep work in advance. We would prefer that active listeners attend lecture with their videos on, though we understand this may not be possible for everyone.
You are also expected to watch the lecture segments you aren’t required to attend, either by showing up as a passive listener or by watching offline or in a listening group with course staff.
You are expected to show up for at least 2–3 synchronous hours with course staff per week. This includes lectures and office hours, and is a general policy for all Harvard classes.
We would prefer that extension students also serve as active listeners, but understand that this may not be possible for all extension students. (Extension policies)
Tests in 2020
Each student will be asked to invent two review questions per unit with solutions for a total of 12 questions over the semester. These review questions should be modeled on the questions in our question banks. Course staff will grade your review questions for relevance to the class material, creativity, and the existence of an unambiguous answer. In the first half of the class, we will provide a round of feedback so you have a chance to fix problems with your questions.
We currently plan to create a final by selecting from student-written review questions. Different students will have different finals.
Rationale: Prior offerings have included staff-written, timed midterms and finals. These tests have generally been considered difficult and long and we would like different ways to evaluate students. In addition, remote learning makes timed tests more inequitable and harder to police. We believe that student-written review questions may check individual student understanding in some of the same ways as tests, while reducing time pressure and granting students some opportunities for creativity.
Collaboration: Students must not collaborate on the review questions they create. Students should create questions on their own. Each question should represent the student’s own work—no copying a question from the Internet or posting questions to the Internet, although the usual resources (book, notes, course videos, prior course material, general Internet research) may be used in the process of creating a question. Staff can help students evaluate whether a review question is too close to material available in the book or on the web.
Question framework: Review questions should be written assuming open book and open notes. Answering a question should be possible without using a computer, but computer access and restricted Internet access would be allowed. The Internet access policy will resemble this:
The exam is open book, open note, open computer. You may access the book, and your own notes in paper form. You may also use a computer or equivalent to access your own class materials and public class materials. However, you may not access other materials except as explicitly allowed below. Specifically:
- You may access a browser and a PDF reader.
- You may access your own notes and problem set code electronically.
- You may access an Internet site on which your own notes and problem set code are stored.
- You may access the course site.
- You may access pages directly linked from the course site, including our lectures, exercises, and section notes, and our preparation materials for the midterm (including solutions).
- You may run a C compiler, including an assembler and linker, or a calculator.
- You may use a Python interpreter.
- You may access manual pages.
- You may not access Google or Wikipedia or anything else except as directly linked from the course site.
- You may not access Piazza.
- You may not access course videos.
- You may not access an on-line disassembler, compiler explorer, or similar applications.
- You absolutely may not contact other humans via IM or anything like it.
- You may not access solutions from any previous exam, by paper or computer, except for those on the course site.
Any violations of this policy, or the spirit of this policy, are breaches of academic honesty and will be treated accordingly. Please appreciate our flexibility and behave honestly and honorably.
A tentative grading breakdown for College students follows.
- 50% assignments
- 20% review questions
- 15% final
- 15% participation (lecture, office hours, Piazza)
Problem set collaboration
CS 61 labs may be completed in groups, but we expect every student to turn in a separate code repository. Here’s what that means and why we’re doing it.
Collaboration is an important part of CS 61. Talking through their code with partners and other students leads to less stress and loneliness and easier debugging.
But partner dynamics can hurt too. We want every student to have worked on every problem set, but previously some partners have shirked work or alternated assignments (“you do pset 4 and I’ll do pset 5”), which isn’t fair to others and reliably causes problems. We want each student to understand the entirety of the work they turn in. Partner concerns have also led us to put more grading weight on exams.
We seek a happy medium. We want to allow strong collaboration within the class, but avoid the pathologies of group turnin. So we ask every student to turn in separate code for each problem set. Students may create code together, and may share code, but code submissions must not be wholly identical and each student must understand all code they turn in. A good way to ensure this is for students to type in their solutions individually, rather than cutting and pasting. Another good way would be for partners to discuss ideas and code and help each other debug, but write their code themselves.
Collaboration is encouraged on all aspects of the course except exams. You are welcome to communicate with your classmates about strategies for solutions and about specific bugs, and you are welcome to use Internet resources for general information. However:
- You must not ask questions on Stack Overflow, paper.camp, or any similar site. (Of course, if you search for some C++ problem, Stack Overflow answers may come up—just don’t ask questions yourself.)
- You must not use solutions from past (or future) years.
- Cite help. If a classmate, other collaborator, or online resource helps you, acknowledge this in your assignment. Name the helpers and briefly describe how they helped. (You do not need to cite help from course staff or resources directly linked from this site.)
Do not post your solutions in a public place.
CS 61 participates in the Embedded EthiCS effort collaboratively launched by faculty from CS and Philosophy. In addition to the technical knowledge and skills one gains through a CS education, today’s computer scientists need to reason ethically about the design decisions they make. The course instructors and a graduate or postdoctoral fellow in Philosophy will present a unit in this course that exemplifies how you can identify ethical and social issues, think rigorously about those issues, design systems that thoughtfully address those issues, and communicate clearly the design decisions and tradeoffs made.