This is not the current version of the class.

Course Description

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.

Objectives

After this course, you should be able to:

Diversity and inclusion

CS 61 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).

Students are expected to behave collegially in class and in our discussion forums. Harvard College students must follow school policies regarding disruptive behavior.

Joining the course late

Students who enroll in this course after the first day of class are responsible for making up all missed work (i.e., watching lecture recordings on Canvas (see 'Panopto' tab), reviewing section material, and submitting problem sets). Catching up may take a significant time investment, depending on your level of preparation and how many classes you’ve missed. We want you to get caught up as quickly as possible so that missed content doesn’t accumulate and make it even harder to catch up. To that end, the latest date at which you may join the class is 9/27 (i.e., two days before pset 1 is due); you will still be required to submit pset 1 on time (or use some portion of your 144 free late hours to submit it within a week of the due date). Joining the course after 9/27 will only be considered in exceptional circumstances, and will require instructor approval; if you wish to join the course after 9/27, you should email cs61-staff.

Assignments

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.

Each assignment will have a check-in date and a due date. By the check-in date (typically one week before the due date), you should have made a submission to the grading server that passes all tests up to a specified phase of the assignment. The dates, requirements, and point values for these check-ins will be specified along with each assignment release. Late hours may not be applied to check-ins.

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.

Getting help

Office hours are a great place to get help in this course. Individual and small-group tutoring is available through our Patel Fellow and the Academic Resource Center (ARC) (which has CS 61 tutors) .

Attendance

Attendance at lecture and section is required for college students. Important things are discussed in lecture and section.

Attendance at section is critically important for simultaneously-enrolled college students. If you are simultaneously enrolled and cannot attend lecture, your section attendance will count toward the class participation portion of your grade. (This is required by the college’s new simultaneous enrollment policies.)

Course lectures are recorded , and these lecture videos are available for viewing for all students, including college students, via Canvas > Panopto.

Sections

Section begins in the first week of class. New material will always be introduced on Wednesdays, and sections will run through the following Tuesday. You will not be asked to sign up for a specific section — come to whatever one works for you each week. Attendance is expected for all students, but we will only track it for simultaneously enrolled students.

Times and locations for all sections are on the CS 61 Google Calendar. Zoom links for virtual section can be found via Canvas > Zoom. At least one virtual section per week will be recorded and posted via Canvas > Zoom > Cloud Recordings.

Section material will be posted under the 'Sections' tab of the course site.

Tests

There will be a midterm and a final. Both midterm and final will be open-book and open-note. Computers will be allowed with limited Internet access. This is the policy:

The exam is open book, open note, open computer. You may access the book and your own notes. You may also use computers or electronic devices to access your own class materials and public class materials. Specifically:

  • You may access a browser and a PDF reader.
  • You may access your own notes and problem set code electronically.
  • You may access Internet sites 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 lecture notes, exercises, and section notes.
  • You may access our lecture, problem set, and section code.
  • You may run a C compiler, including an assembler and linker.
  • You may access manual pages and common utilities, including calculators and a Python interpreter.

However:

  • You may not access class discussion forums or other question forums such as Stack Overflow.
  • You may not access an on-line disassembler or compiler explorer.
  • You may not access solutions from any previous exam, by paper or computer, except for those on the course site.
  • You may not broadly search the Internet for answers to questions or access other courses’ materials. Stick to our course site.
  • You absolutely may not contact other humans with questions about the exam—whether in person, via IM, or by posting questions to forums—with the exception of course staff.

Any violations of this policy are breaches of academic honesty and will be treated accordingly. Please appreciate our flexibility and behave honestly and honorably.

Additionally, students are taking the exam at different times. Do not post publicly about the exam until given permission to do so by course staff. This includes general comments about exam difficulty.

Tests in CS 61 have typically been considered difficult.

Grading

CS 61’s final grades are assigned using a formula based on this rough breakdown:

CS 61 is not harshly graded; many students get A or A- grades. However, we grade using a mastery framework for assignments. The assignments purposely allow most students to pass almost all provided tests. Obtaining 92% of the available points on assignments does not indicate mastery of the subject, and will not guarantee you a straight A. We encourage students to do two things:

  1. Don’t overworry about grades. In the long run, it is extremely unlikely that getting an A versus a B will have a material impact on your happiness. Many students find it healthier to try to learn as much as possible without stressing yourself out.

  2. Do some extra credit work to demonstrate mastery (and to have fun).

We are unlikely to respond to questions about course grades before they are assigned. For instance, we do not know what your course grade is going to be.

Collaboration and academic integrity

Discussion, collaboration, and the exchange of ideas are essential to doing academic work, and to engineering. You are encouraged to consult with your classmates as you work on problem sets. You are welcome to discuss general strategies for solutions as well as specific bugs and code structure questions, and to use Internet resources for general information.

However, the work you turn in must be your own—the result of your own efforts. You should understand your code well enough that you could replicate your solution from scratch, without collaboration.

In addition, you must cite any books, articles, online resources, and so forth that helped you with your work, using appropriate citation practices; and you must list the names of students with whom you have collaborated on problem sets and briefly describe how you collaborated. (You do not need to list course staff.)

Limitations and caveats:

In addition to this policy, college students are subject to Harvard College’s academic integrity policies as described in the College Handbook for Students.

Rationale: 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. However, in previous years, 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. We thus ask every student to turn in separate code for each problem set. Students may create code together, and may share small amounts of code, but 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.

Generative AI tools like ChatGPT and Github Copilot can provide helpful insights about programming (and other topics!). However, such tools are not guaranteed to be correct, and may provide information that is subtly or dramatically wrong. A key goal of this class is to provide students with a deep understanding of how computers work; armed with this understanding, students will be better positioned to use an appropriately critical lens when interpreting the output of generative AI.

Embedded EthiCS

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.