Systems Programming and Machine Organization
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 very high-level programming languages—and many programs simply glue together existing components—the best programmers are still, and will always be, craftspeople who understand their tools. For software builders, this means 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 means understanding the factors that affect code performance.
CS 61 introduces you the tools you need to build fast software, and the mental tools you need to understand software systems written by others. We hope it’ll show you 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, among other things:
- Write simple network servers.
- Write simple parallel programs.
- Understand the function of complex C programs.
- Understand the function of simple binary programs (no source code provided).
- Write programs that combine assembly code and high-level language code.
- Use operating system interfaces effectively.
- Analyze program performance and apply basic strategies for performance improvement.
- Solve problems using computer arithmetic.
Programming assignments are a critical part of the course. There will be approximately six to eight assignments handed out at one to two week intervals. The early assignments must be completed individually, and all of the assignments may be completed individually. Some of the later assignments may be completed in pairs; they’ll be clearly labeled.
Assignments will be due at midnight (11:59:59pm Eastern) on the due date.
Each student has 72 free late hours which can be applied to any of the assignments. (That’s a total of 3 late days.) This means that all assignments can be late by a cumulative total of 72 hours without penalty. You don’t need to tell us before using your late hours.
After the 72 late hours are exhausted, each additional day (or fraction thereof) that an assignment is late will come with a significant grade penalty on that assignment. An example penalty is a letter grade off per 4 hours of additional lateness, down to a minimum of F.
On assignments completed in pairs, lateness counts against both students’ late hours.
No assignments will be accepted after solutions are discussed in class or section. This will generally happen about 5 days after the assignment is due; deviations will be preannounced.
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.
Attendance at lecture is highly recommended (and strictly required for the lecture you scribe). Attendance at section is recommended.
There will be a midterm and a final. The final is currently planned for finals period, though we may reconsider this. Both midterm and final will be open-book and open-note. Computers will be allowed, too, though Internet access is forbidden.
Rather than slides or instructor-provided lecture notes, students will be creating collaborative scribe notes for each lecture, entered onto the wiki. We expect each student to help produce notes for one lecture. Scribe notes will be graded.
A tentative grading breakdown for College students follows.
- 45% assignments
- 20% midterm
- 25% final
- 10% other (participation in class and on Piazza, scribe notes, etc.)
Extension students have a similar grading breakdown, but class participation and scribe notes are not required, making the 10% “other” grade more like 3%.
Later assignments will include extra credit opportunities.
It can be most satisfying to complete assignments on your own. But you’re encouraged to communicate with your classmates about strategies for solutions as well as help on specific bugs. Collaboration is governed by two principles:
- Do your own work. Every line of code you submit must be your own, as must every sentence you write. You should be able to explain and reproduce your work yourself. It is OK to discuss an assignment with classmates, but not to share code and assignment solutions with classmates.
- Cite help. If a classmate or other collaborator helps you, acknowledge them in your assignment. Give their name and briefly describe how they helped. This principle also applies to online resources like Wikipedia.
This means that, for example, we expect Piazza to be an active zone for discussing assignments, but for Piazza to contain little if any assignment code.
Use of solutions from prior years, from other classes, or from the Internet is strictly forbidden. Don’t do it, and don’t post assignment questions on the Internet. Ask the course staff via private Piazza message if you have questions about this policy.
Collaboration in pairs will be allowed on some specifically named assignments.