Syllabus, Spring 2022, v1.0
What does an operating system do? How do you write programs that interact with the OS? How does it allow allow more than one process to run concurrently? How do you write concurrent programs and avoid “data race” bugs? How does the OS prevent running out of memory, even when the processes require more than the memory hardware provides? How are file systems constructed? How can we avoid complete system failures resulting from small errors (“faults”) in a subsystem? What security features does an OS use to protect running programs and stored data? The answers to all these questions an more will be learned in CS 111 / EE 128!
This course is for undergrad and graduate CS and ECE majors who want to learn how operating systems work, systems-level programming, and related topics like concurrency, synchronization, and fault tolerance.
Students should have completed CS 40 or EE 14 before attempting CS 111 / EE 128. Grad students may have taken an undergraduate course in “intro to computer systems”, “computer organization”, or “microprocessor design” at another school. If you are unsure whether a course you’ve taken meets the prerequisite, please contact the instructor.
Upon completion of the course, students should be able to:
- Explain how the mechanisms operating systems use to virtualize hardware work in order to allow multiple processes to run at once
- Explain how the mechanisms and abstractions operating systems use to facilitate program interactions with I/O devices, and particularly disk devices work
- Compare and contrast different policies that operating systems may use to manage resources
- Describe the things that can go wrong in operating systems, and explain how security and reliability mechanisms in operating systems help to avoid these problems
- Develop systems-level programs that interact with the operating system
- Choose and correctly apply system abstractions for concurrent programming
ALL of the following are required prerequisites for this course:
- CS 15 (Data Structures) or equivalent data structures course from another school
- CS 40 (Machine Structure & Assembly-Language Programming), or EE 14 (Embedded Systems), or equivalent computer organization course from another school
- Graduate Students:
- The registration allows “or graduate standing” and will not strictly check these prerequisites because many grad students have taken equivalent courses at other schools, rather than these exact courses at Tufts, and the registration system cannot know about courses taken at other schools. However, it is critical for your success in this class that you have the knowledge from both these classes.
- If you are unsure of whether your previous coursework is sufficient (or if you’ve learned this material outside of official coursework), you are welcome to talk to me about it and I’ll help figure it out. We’ll also discuss it as a class in the first week of the semester, so you can check your knowledge then.
- Operating Systems: Three Easy Pieces. Remzi H. Arpaci-Dusseau and Andrea C. Arpaci-Dusseau. Arpaci-Dusseau Books. August, 2018 (Version 1.00)
- Available free online here. Links to buy a hard copy are also on that page, if you want one, but it is not required – the free online PDFs are sufficient.
- Kernigham and Ritchie. The C Programming Language, second edition. Prentice-Hall.
- ISBN 13: 978-0131103627
- This course is not about learning to program in C, but you will have to program in C for the assignments. If you are not already familiar with C/C++ then this book may be helpful to you. (If you are familiar with C++ but not C, less so, but it may still be useful.) It is not required, but you should decide if it will be worthwhile for you.
- This is also a “classic” book. So if you do buy a copy, it is one that a computer scientist may proudly display on their bookshelf forever.
You will be given access to the CS department Linux server to work on for programming assignments and other purposes in this class. You should have access to a laptop or other suitable computer with an Internet connection that you can use to connect (via SSH) to the server. (On Mac or Linux, there is a built-in command line command to SSH; on Windows, I recommend using the free program PuTTY.)
Class Times & Location
This class will be held in-person for spring 2022, except on Thursday, Jan. 20, which will be online via Zoom. (Keep an eye on your email for announcements form the university or AS&E schools about COVID-19 precautions, and for announcements from the course instructor.)
- Tuesdays & Thursdays, 6:00 – 7:15 PM
- Joyce Cummings Center, 180
The first class will be Thursday, Jan. 20, 2022. The last day of class will be Thursday, April 28, 2022.
Instructor & TAs
Dave Lillethun is the instructor. TAs are to be announced.
Office hours and contact information will be posted in Canvas.
There will be four (4) significant programming projects, all of which must be written in the C programming language. You will be given at least 2 weeks to complete each one, and you should anticipate taking that long to complete them, so budget your time according and do not wait to start. These programming assignments must be completed individually, according to the “plagiarism & collaboration” policy below. You will be allowed to revise and resubmit programming assignments after receiving feedback on them, according to the “revise & resubmit” policy below.
Graded Questions / Problem Sets
There will be a number of graded questions that you will work on at home. Although they will be released in sets (a number of questions all due at the same time), each question will be graded separately (rather than combining them into a single grade for the whole set), so in a sense it’s best to think of each question as a separate assignment. Each question will be assigned to a single category for grading purposes – more details about categories below. However, a single question may have multiple parts (e.g., “part (a)”, “part (b)”, etc.). These questions must be completed individually, according to the “plagiarism & collaboration” policy below. You will be allowed to reattempt questions according to the “reattempts” policy below.
There will not be any midterms or final exam in the course; the question sets take the place of those. In lieu of a final exam, the final question set will be released and due on finals week. It will be at least theoretically possible to successfully complete enough questions to earn an A+ before the final question set, and if you have done so (or are otherwise satisfied with your grade up to that point) then completing questions in the final set is not necessary. Or if you only need to complete questions in some categories to improve your grade, then you will need to answer the necessary questions and may skip the others.
The questions will be the primary way to get credit towards your grade in the different categories, but there are also a number of other ways to get credit in a category instead of a question. You may use only one of these in each category (so you’ll still need to successfully answer at least one question in each category for full credit), and you may use each of these methods only once. (This list is in progress, and more options may be added as I think of them…)
- may be done individually or in groups up to 3 (maybe more with instructor approval)
- give a short presentation that explains the course content in the relevant category; assume your audience is your fellow students
- the “revise & resubmit” policy does not apply, but you are allowed to go through as many drafts of the outline / your slides prior to giving the presentation, so you can be sure that at least that much is good
- may be done individually or in groups up to 3 (maybe more with instructor approval)
- produce a short instructional video that explains the course content in the relevant category; assume you are creating it as instructional material for your fellow students to learn from
- the “revise & resubmit” policy applies (but you probably want to take advantage of this on the outline / script; while you are allowed to revise the finished product, it is a lot more work if you have to re-record)
- Blog Post(s)
- must be done individually
- write a blog post, or series of up to 3 blog posts, that explain the course content in the relevant category; assume you are creating it as instructional material for your fellow students or people on the internet with a similar technical background to learn from
- the “revise & resubmit” policy applies
- may be done individually or in groups up to 3 (hard limit)
- create a poster (may be digital format if you don’t want to print a physical poster) that shows the course content in a particular category, and the present the poster as if you were at a poster session at a conference or similar event
- the “revise & resubmit” policy applies to the poster itself, but not the presentation (although you are welcome to submit an outline for the presentation and get feedback on as many drafts as you need)
- Other – you propose something (subject to instructor approval)
There are most specifics to each of these assignments, which will be giving during the course, as we start working on class assignments. Be sure you know the details before starting one of these; ideally talk to the instructor before starting, so I know to expect your work, and you can be sure you understand well what you need to do to be successful before you start.
Late Work Policy
There are no late penalties or “late passes” in this class. If you will not have work completed by the deadline, then email the instructor (contact information is in Canvas) before the deadline and tell him when you will have the work completed. You don’t need to provide any excuses, just the new date when you will submit the work. As long as you send that email before the assignment deadline, your late submission will be graded for full credit. (However, if there is an emergency situation that makes it impossible or unreasonable to contact us before the deadline, then just send the email as soon after the deadline as is reasonable.)
Each graded question, programming assignment, or other graded assessment will not be given a percentage score or letter grade, but rather will be rated as “Demonstrates Proficiency” (or “Proficient” for short), “Not Yet Proficient” (or “Not Yet” for short), “Not Assessable” (or “N/A” for short). Canvas also may show “Not Submitted” (or “N/S” for short) for an assignment. These mean the following:
- Demonstrates Proficiency – This assessment shows that you have proficiency in the relevant grading category topic.
- Not Yet Proficient – This assessment shows some knowledge but does not yet demonstrate full proficiency in the grading category topic. However, some assignments allow you to revise & resubmit to attempt to show proficiency, while others may allow retakes. The “revise & resubmit” and “retake” policies are detailed below.
- Not Assessable – This assessment is too incomplete to accurately assess whether you have proficiency in the grading category topic or not, or it shows little evidence of knowledge in the topic. This could be, for example, a question in which not all parts were attempted fully, or a programming assignment in which not all features have a reasonable attempt to implement them, or that does not compile or crashes every time it is run.
- Not Submitted – This is not a grade, but a note we can log in Canvas to indicate that we never received a submission for an assignment. It is just for your information – see the “Late Work Policy” to understand if you may still be allowed to submit this assignment.
To earn a grade for this course, you will complete assessments that show evidence of proficiency in each of the following grading categories, plus the four (4) programming projects. (Unfortunately, Canvas calls these “Outcomes”, so do not get confused – Canvas is referring to the following categories, not the “Learning Outcomes” listed in that section above.)
- Processes & Time Sharing (CPU Virtualization)
- Virtual Memory
- Page Swapping (On-Demand Virtual Memory)
- Concurrency & Synchronization
- File Systems
- Input / Output (I/O)
- Parallel & Distributed Systems
To receive a top grade in this course (i.e., an A+), you will need to demonstrate proficiency (i.e., receive a grade of “Demonstrates Proficiency”), after your resubmissions and retakes, on two assignments in each of these categories, as well as all four (4) programming assignments. Note that there will be more than two opportunities to demonstrate proficiency in each category, but you only need 2 in each, so once you have those you can turn your focus to other categories. That said, the bar for demonstrating proficiency will be high – that is, you must actually demonstrate your proficiency in that topic. However, there are no extra programming assignments, so for a good grade, you will need to demonstrate proficiency in all of them (after you revise & resubmit).
Here is what you need to do to earn each letter grade:
- Demonstrate proficiency in all 4 programming assignments,
- Demonstrate proficiency twice in 9 (out of 10) grading categories, and
- Demonstrate proficiency at least once in the remaining 1 grading category.
- Demonstrate proficiency in all 4 programming assignments,
- Demonstrate proficiency twice in 7 (out of 10) grading categories, and
- Demonstrate proficiency at least once in the remaining 3 grading categories.
- Demonstrate proficiency in 3 (out of 4) programming assignments,
- Demonstrate proficiency twice in 6 (out of 10) grading categories, and
- Demonstrate proficiency at least once in at least 3 of the remaining 4 grading categories.
- Demonstrate proficiency in 2 (out of 4) programming assignments,
- Demonstrate proficiency twice in 5 (out of 10) grading categories, and
- Demonstrate proficiency at least once in at least 2 of the remaining 5 grading categories.
Students who meet all the criteria for a letter grade, plus at least one additional assignment that contributes progress towards the next letter grade by demonstrating proficiency (i.e., a third or more demonstration of proficiency in the same category doesn’t count), will receive a plus (+) on their grade.
Students who only need to demonstrate proficiency on one additional assignment to receive a letter grade will receive that letter with a minus (-), rather than the next lower letter. In other words, you get an X- by almost meeting the criteria for X, but you’re short by just one assignment. For example, demonstrating proficiency on all programming assignments, twice in 6 categories, and once in all the others would be a B- since you need to demonstrate proficiency twice in 7 categories. Note that if the assignment type in which you need an additional one demonstrating proficiency is the programming projects, then you still need at least one programming project to be at the “Not Yet Proficient” level. (You cannot bump up a N/A or N/S programming assignment in order to receive a grade with a minus; a reasonable attempt at the assignment must have been made.)
Students who do not meet the criteria for at least a D- will receive an F.
Revise & Resubmit and Retake Policies
All the programming projects and certain assignments in the “Other” category (if indicated in their descriptions) will allow you to “Revise & Resubmit”. This means that if you do not demonstrate proficiency on your initial submission of the assignment, once you have received feedback on your assignment, you may work on improving it (i.e., revise it) and the resubmit it to be graded again. Only the grade on the last submission of each assignment counts towards your course grade. This allows you to keep working on many of the assignments until you succeed.
(Note: Please do not submit work that you know will not demonstrate proficiency and count on being able to resubmit to improve it. See the “Late Work Policy” above – there is no need to “game” the resubmission process to get more time.)
Unfortunately, as a practical limitation, we can only grade resubmissions so quickly. In order to keep things reasonable, you may only submit one “resubmission” per week. (Or, you can submit more, but we will only grade one per week for you. We make no guarantees of what order we’ll grade them in, if you’ve worked ahead and given us too many.) The last day we will accept any resubmissions is Thursday, May 5. (That’s the day before finals start; once the final exam period begins, no more resubmissions will be accepted, unless you are taking an incomplete in the course.)
Graded questions from the question sets do not allow “revise & resubmit”, but instead follow the “retake” policy. There will be multiple opportunities to answer a question from each category (at least 3 opportunities per category), and you only need a maximum of two per category. Therefore, if you did not demonstrate proficiency on a question, you will have the opportunity to take another question in that category later.
Students in this class are responsible for reading, understanding, and following all of the course policies listed here. For spring 2022, there are also additional COVID-19 policies for the course. By continuing to take this course, you indicate your agreement to follow all the policies. If there is any policy that you do not understand, please ask. Ignorance will not be accepted as an excuse for violating any policies.
This syllabus and any policies for this course are subject to change during the semester in response to changing conditions. Such changes are at the sole discretion of the course instructor. If any changes are made, the appropriate documents will be updated and the change will be announced to the entire class in a timely fashion.
This document has a version number at the beginning to help you tell when changes have been made. When there is a new version, the changes that were made will be listed in the following Change Log. (This may help, for example, so you don’t need to re-read the entire document just to find a small change.)
v1.0: Initial version.