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
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).
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.
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 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 by the Extension School, and these lecture videos are available for viewing for all students, including college students.
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.
- 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.
CS 61’s final grades are assigned using a formula based on this rough breakdown:
- 50% assignments
- 35% tests (midterm and final)
- 15% participation (lecture, office hours, discussion forums)
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:
Don’t worry about grades, which will have far less impact on your life than you can imagine now. Instead, try to learn as much as you can without stressing yourself out.
Do some extra credit work to demonstrate mastery (and because it’s 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:
- Do 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.)
- Do not use solutions from past (or future) years.
- Do not post your solutions in a public place.
- No collaboration is allowed on exams.
In addition to this policy, college students are subject to Harvard College’s academic integrity policies as described in the College Handbook for Students, and extension students are subject to the Extension School’s academic integrity policies as described in its Student Policies and Conduct.
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.
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.