Course Syllabus

Essentials

Overview

The catalog description for CS 134 reads:

Design and implementation of operating systems, including processes, memory management, synchronization, scheduling, protection, filesystems, and I/O. These concepts are used to illustrate wider concepts in the design of other large software systems, including simplicity; efficiency; event-driven programming; abstraction design; client-server architecture; mechanism vs. policy; orthogonality; naming and binding; static vs. dynamic, space vs. time, and other tradeoffs; optimization; caching; and managing large codebases. Group projects provide experience in working with and extending a real operating system.

In other words, in this class, you'll learn, amongst other things:

• How computers “really work”—things you really ought to know but didn't learn in CS 105.

• Techniques used in solving challenging problems in the real world (not just in operating systems, but everywhere) where there may not be an elegant theoretical answer. Solving real problems is all about looking at the trade-offs.

• How to work with a large codebase. The operating-system codebase will probably be the largest and most complex one that you will have worked on, unless you've worked in industry.

Electronic Access

Much of the communication for this course will be handled electronically through the class website, mailing list(s), and Piazza. You are responsible for being familiar with announcements posted to the class mailing list(s) and with the contents of the class website.

Website & Wiki

The class website is available at https://www.cs.hmc.edu/cs134/.

As well as providing useful general information (such as how to find me when you have questions), homework assignments will be posted on the class website.

Communications and Getting Help

If you have questions about the course (about assignments, course policies, C++, etc.) that you cannot answer yourself, please use Piazza for asynchronous communication (not email); there are more eyes on Piazza so you are more likely to get a quick response.

There are several different ways to get help, ask questions, and otherwise reach out, each with their own purpose. We will use Piazza for asynchronous communication, and professor office hours either online or in-person for synchronous communication. Please see the Getting Help page and the Office Hours post pinned on Piazza for details.

Computer and Website Accounts

This course requires you to use four main tools. (Sorry! We've tried to consolidate as much as we can!) These are

• Course Server: You should have received email from Nic Dodds about the course ssh server, cs134.cs.hmc.edu. You will use this server to build and run the OS/161 kernel.
• Course Website: This website is the hub for all course content, including course policies, learning material, and homework descriptions.
• Piazza: Most communication about the course, including announcements, requests for help from the instructors, grutors, or fellow students (see the help page for more on Piazza).
• GitHub: Your homework projects will use git for version control, and GitHub for distributing starter code, sharing code with your partner, making your code available to grutors and instructors when asking for help, and for submitting your code when it's due.
• GradeScope: We will likely use GradeScope for some graded parts of the course. When we do, we will provide you with the necessary information.

Coursework & Grading

Your final grade in CS 134 will be calculated by combining your grades each assessed course component in the following proportions:

(Sometimes it can be necessary to make small adjustments to these proportions during the semester. If any adjustments are necessary, the changes will be announced in class and posted on the course website.)

Assignments

We expect to have about six major assignments in this class. Most assignments are followed by a review process, so in essence there are ten distinct pieces of work.

Assignments in CS 134 are complex. Start early and take advantage of the provided help.

Group Programming

We strongly encourage you to work in pairs on the programming assignments. There is no requirement to switch partners between assignments, but you may if you wish. We also hope that this is a small enough class that students can form pairs without significant instructor intervention. But, if you are having trouble finding a partner, please reach out for assistance.

When working as a pair, true shared ownership is the goal. Thus, both members of a programming pair must contribute equally to the assignment, document who wrote what, and be sure that both members of the pair understand their entire submission. You are not required to adopt a CS-70 style pair-programming methodology, however.

Readings & Quizzes

I may occasionally set reading assignments. I may also occasionally instigate quick quizzes on material you are supposed to have read.

Exams

There are two exams, a midterm and a final. These exams are three-hour open-book take-home exams. In general, exams test do not test recall of facts, but your ability to apply what you know.

Your Responsibilities

You have a number of responsibilities in this class. It is important that you understand them so that you can avoid costly mistakes such as loss of credit on an assignment or accidental violation of the honor code.

Collaboration and the Honor Code

All students—even those from other colleges—are expected to understand and comply with Harvey Mudd College's Honor Code. If you haven't already done so, you must read, sign, and abide by the computer-science department's interpretation of the Honor Code to participate in this course.

You are encouraged to discuss general features of assignments and the ideas involved with other students, including general approaches to the problems, bugs in the specification, how long you've spent working on a problem, and so forth. You may also help each other with issues related to completing the assignments—how to use Unix, basic C++ programming issues, and the like.

Two good rules of thumb are the "in your head rule" and "understanding, not rote learning" rules. When students help each other, they should leave with understanding in their heads, not physical or electronic artifacts. Thus you are not allowed to meet as a group and leave with notes on paper, nor can you help someone fix a bug and then leave without first reverting the bug to its unfixed state. Similarly, it is not okay to leave with an answer you don't understand (in the worst case, where such a situation seems unavoidable because you have found out the answer but still don't understand it and have to leave, it is vital for you to say so, since not doing so is dishonest). Also, if you are helping someone, remember that giving away answers can actually be detrimental to someone's understanding—often it is better to ask leading questions instead. Working together as peers and coming to an understanding together is, of course, even better.

If your work is influenced by materials you have read, or discussions with other students, you should document that influence. When coding, you should describe those contributions in your comments.

You must not exchange literal copies of material, whether that material consists of code, program output, or English-language text (e.g., documentation). You also may not copy material from published or online sources, with or without cosmetic changes (such as altering variable names), without explicit permission. If you do have permission to use externally written material, you must attribute it properly and clearly indicate which material is yours and which material is not yours.

If you aren't sure whether something you've done or plan to do is allowed, you should explicitly document what you did and—if at all possible—consult with the course staff, ideally before you take the questionable action. Similarly, document any extensive or particularly important help you obtain, even if that help seems legitimate. If the questionable material or extensive help is explicitly marked as such, you might lose points but still avoid violating the Honor Code.

These principles apply to all methods and media of discussion or exchange (voice, writing, email, etc.).

Attendance and Participation

You are expected to attend every class. I will not be formally taking attendance, but many classes will have group exercises that will affect your final grade (both directly, because I grade for class participation, and indirectly, because questions on the exams are often similar to the group-exercise questions). If you wish to miss a class for any reason, you should ask beforehand about the make-up work you will need to do. If you are sick, you can send word to me through another student.

You are expected to participate actively in each class. The only way to receive a high grade for class participation is to be an active participant in the class (duh!).

Due Dates and Late Policy

Reward for Early Submission

If you submit a homework assignment 24 hours or more before the deadline, you'll receive a bonus of 3% on your overall grade for that piece of work. This bonus is intended to reward good time management and to encourage you to start early. (It is also intended to help you avoid the penalties for late work.)

Late Work Is Strongly Discouraged

The penalties for submitting late almost always outweigh the benefits. With proper planning, there is almost always a way to avoid suffering the penalties that arise from turning work in late. For example, if you know of an upcoming commitment that (such as an exam in another course, or a family event you must attend) that could affect your ability to get an assignment done by its deadline, you may ask for an assignment early. Similarly, if, after starting an assignment, you think it is impossible to accomplish the necessary work in the available time, consult me before the due date. It may be that there is some help I can offer you that would allow you to proceed more quickly, or it may be that everyone in the class is having the same problem, in which case we might adjust the assignment.

Unforeseeable Extenuating Circumstances Only

Extenuating circumstances (such as illness) are dealt with on a case-by-case basis. In general, you are only excused for situations you could not have forseen, and only if you explain the situation at your soonest opportunity (either directly or via someone else, such as the Dean of Students), before the due date.

Late Penalty Formula

If, against my advice above, you do submit work late, your score will be scaled using the multiplier returned by the following C function:

double lateMult (double mins)
{
   const double MAX_LATE_PERIOD = 12 * 60;
   /* i.e. twelve hours (in minutes) */

   /* This formula is strange, but gives a good penalty curve. */
   double  lateness = mins / MAX_LATE_PERIOD;
   double  root     = sqrt(lateness);
   double  squared  = lateness * lateness;
   double  penalty  = 1.0 - (root * (1.0 - root) + squared * root);
   return (penalty < 0.0) ? 0.0 : penalty;
  }

When graphed, the function looks like

This function is swift to penalize lateness—even one minute late results in a lateness multiplier of 0.964 (i.e., a 3.6% penalty). At nine minutes late, the multiplier is 0.9, a 10% penalty. But with time the rate slows down, the 0.8 point is reached at a little before the first hour, and the 0.6 multiplier is not reached until the work is about 6.5 hours late. At, and beyond, the 12-hour point, the multiplier is zero. Times are based on the time that the submission process finished, not when you began submitting. For assignments due at 11:59 pm, we count late minutes from midnight and round down to whole numbers of minutes. Thus, you have about two minutes of grace after the clock ticks over to reading 11:59 pm. (It is, of course, risky to cut things close, especially since the submit system takes time to perform its work.)

Illness

If you get sick during the term, notify me immediately, even if you think that being sick will not affect your ability to complete your assignments. You should also notify me any time that you're sick enough to miss any classes (not just CS 70) or find that your performance is below par for any reason.

Getting Help

If you need help with a course-related problem, come and see me. Talking in person is often the fastest way to resolve a problem, especially if it's conceptual. If you speak to a grader and are not happy with (or convinced by) their answer, you should see it as their failure rather than yours, and seek me out for a better answer.

If you have a simple question, a clarification, or a simple request, you may prefer to use email. You should send email to the mailing list, which is read by me and the graders, maximizing your chances of getting a quick answer to your question.

I believe that you learn best when you discover answers for yourself, so I will often respond to conceptual questions with questions of my own, designed to help you find the answer for yourself. If you wait to ask your question until you are feeling very frustrated (or until the last minute), you may find my answer maddening. For that reason, ask your questions early.

If you have sensitive issues—such as personal issues or Honor Code violations—that you need help with, contact me directly.

Large Language Model (LLM) Usage Policy

As artificial intelligence and large language models (LLMs) become increasingly prevalent in the tech industry, it's important to establish clear guidelines for their use in academic settings. This policy outlines the acceptable use of LLMs, such as ChatGPT, in CS 134.

Permitted Uses

1. Concept Understanding: You may use LLMs to help clarify complex OS concepts or to get alternative explanations of course material.
2. Brainstorming: LLMs can be used for generating ideas or approaches to problems, but implementation must be your own.
3. Debugging Assistance: You may use LLMs to help identify bugs in your code, but you must understand and implement the solutions yourself.
4. Research Aid: LLMs can be used to find relevant resources or summarize research papers related to OS topics.

Prohibited Uses

1. Direct Code Generation: Using LLMs to generate code for assignments or projects is strictly prohibited.
   • This prohibition includes using coding assistants like GitHub Copilot to “autocomplete” code.
2. Take-Home Exams and Quizzes: LLMs must not be used for any take-home exams or quizzes.
3. Uncited Use: Any significant ideas or insights gained from LLMs must be cited in your work.

Requirements

1. Critical Evaluation: Always critically evaluate any information or suggestions provided by LLMs. They can make mistakes or provide outdated information.
2. Citation: When using LLMs for research or idea generation, cite them as you would any other source. Example: "Idea explored after discussion with [LLM name], [date]."
3. Transparency: If you're unsure about whether your use of an LLM is acceptable, consult with the instructor or TAs.

Academic Integrity Reminder

Your submitted work must represent your own understanding and efforts. Using LLMs as a shortcut doesn't just violate course policy—it undermines your learning and growth as a computer scientist. But if you present the output of a large language model as your own work, that is an academic integrity violation.

Accommodations

HMC is committed to providing an inclusive learning environment and support for all students. Students with a disability (including mental health, or chronic or temporary medical conditions) who may need accommodations in order to fully participate in this class are encouraged to contact their home college's accessible-education officer:

Textbooks

Textbooks cover much of the material discussed in lectures. By reading your textbooks prior to class and being aware of what they cover, you can significantly reduce the amount of note taking you need to do in class.

Recommended Texts

There is one recommended textbook, Operating Systems: Three Easy Pieces by Remzi H. Arpaci-Dusseau and Andrea C. Arpaci-Dusseau. This book is available online for free here.

(When logged in, completion status appears here.)