Syllabus

Lecture and section information

CS 4414/5416, Fall 2026
Lecture: Baker Laboratory 200, TR 2:55-4:10 PM
Discussion 1: Statler Hall 185, F 2:55-4:10 PM
Discussion 2: CIS 142, F 8:40-9:55 AM

Staff and office hours

Prof: David Bindel
487 CIS Building
Phone: 607-255-5395
Email: bindel@cornell.edu
OH: Thu 1:30-2:30, Fri 1-2 (or by appointment)

Prerequisites

CS 2110 (CS 2 in Java), CS 3410 (Computer Systems Organization and Programming), or equivalents.

Texts

There are two required texts:

A separate page provides many pointers to additional resources.

Approximate lecture schedule

The course involves five main modules, each of about 2-3 weeks.

Module 1: Introduction to Rust

The objective for the first part of class is to teach you the fundamentals of Rust and how the main abstractions are implemented.

  • Week 1: Intro and Rust essentials
  • Week 2: Rust memory management
  • Week 3: Rust polymorphism, error handling, and functional programming

Module 2: Writing fast code

The objective of the second module is for you to understand the performance of single-thread codes. This requires both modeling and measurement, as well as an understanding of the role of memory layouts and optimizing compilers in performance.

  • Week 4-5: Profiling, memory, and optimization
  • Week 5: Compilation, linking, loading, and build systems

Module 3: Unix abstractions

The objective of the third module is to understand and be able to employ some of the main facilities of Unix-style operating systems.

  • Week 6: Unix abstractions (files, pipes, virtual memory)
  • Week 7: Processes and inter-process communication
  • Week 8: Introduction to sockets

Module 4: Concurrent programming with threads

The objective of the fourth module is to understand how to write concurrent code that is both correct and performant.

  • Week 9: Message-based concurrent programming
  • Week 10: Shared memory concurrent programming
  • Week 11: Concurrent network programming

Module 5: Asynchronous programming

The objective of the fifth module is to understand the asynchronous programming interface, as well as a little about how it is implemented behind the scenes.

  • Week 12: Asynchronous programming
  • Week 13: Asynchronous programming, nonblocking I/O, and network programming

Special topics, review, and capstone

  • Week 14: Special topics (and Thanksgiving)
  • Week 15: Review

Course work

This is a four credit course. This means about 225 minutes of direct instruction each week (in lecture and lab) and 450 minutes outside for reading, study, and programming assignments. If you do not spend this time, you probably will get less from the course than you should.

Readings

Readings from the texts will be listed on the course page before class. You should read them before lecture! We will try to give clear guidance about what parts of the reading will be fair game for tests, but you should expect that not everything in the exams will be directly covered in lecture.

Class work

Each lecture will be partitioned into segments, with activities between segments. Come prepared to think and to talk with your peers! You are expected to bring a writing instrument with you to lecture. Please leave your phones and computers in your bags.

You will also be asked to write down answers (and questions) on a piece of paper during lecture; these pages should be turned in at the end of the lecture. Class pages will be scanned into Gradescope by the course staff. Each class page is worth half a point based on participation. I will also read through a sample of the pages after each lecture to try to get a sense of what things are confusing.

Lab sections

Friday lab sections are a mandatory part of the course. In each lab, you will be guided through an activity intended to reinforce the material taught in lecture during the weak. Please bring a computer, or work with a friend who has a computer.

Programming assignments

There will be six programming assignments, with the last two building upon each other. Each assignment is worth three points directly, but there will be questions on the exams that involve material you will learn through the assignments. Assignments will be submitted via Gradescope.

Exams

There will be an in-person midterm exam and an in-person final. These exams are closed-book, though you may bring one page of notes. The midterm and final are each worth 30% of the final grade.

Grading

Your final grade in CS 4414 will be computed from grades on the assignments and exams using the following weights:

  • Labs: 12% (1 point each, 14 labs, saturating counter)
  • Class: 10% (0.5 points per lecture, saturating counter)
  • Coding assignments: 18% (3 points each for 6 assignments)
  • Midterm: 30%
  • Final: 30%

If you are taking the course as CS 5416, there will be additional tasks on the coding assignments and a few differences in questions on the exams. The emphasis of these additional tasks will be related to developing and deploying networked codes on Linux-based cloud systems.

Learning outcomes

At the end of the semester, you will be able to:

  • Proficiently program in Rust, and explain how the main Rust abstractions are implemented.
  • Model and profile program performance, analyzing the impact of data structure layout, algorithm selection, and implementation choices.
  • Describe standard Unix kernel abstractions and use them in applications.
  • Write concurrent programs, reasoning about correctness issues (like deadlock) and performance issues (like contention).
  • Write asynchronous programs and explain how the asynchronous programming abstractions are implemented.

Students in 5416 should also finish the course able to run networked codes on a Linux-based cloud platform.

These outcomes will be assessed through exams and hands-on activities.

Course policies

Use of AI tools

You may use generative AI tools to search, explore and review, and practice course concepts. No other uses are allowed, unless otherwise specified. For a thoughtful discussion that aligns with the reasoning behind this policy, we recommend this post on the rust-lang/rust LLM policy.

For most questions, I encourage you to post to the class discussion board. Even if an AI is able to give you an answer more quickly, you asking an AI a question will (at best) provide you with an opportunity to learn. A question to the class discussion provides everyone who reads an opportunity to learn.

Inclusivity and accommodation

We (Cornell as a whole, CS as a department, and I as the course instructor) are commited to full inclusion in education for everyone. Services and reasonable accommodations are available, whether you are facing permanent or temporary disabilities, immigration status issues, mental health or other personal challenges, or other types of learning challenges. If circumstances affect your ability to participate, let me know. Some resources that might be of use include:

Note that for structural accommodations like extra time on exams, you should work with SDS.

Ingredients for success

To be successful in the course, I ask that you

  1. Prepare. Course readings will be posted ahead of class, and we will provide pointers to supplementary reading. Come armed with questions!
  2. Engage. In class, we will ask you to ask questions and answer questions.
  3. Start homework early. We want to help you figure out the homework, but to manage this we need time for you to get confused, ask us for help, and repeat a few times.

Late work policy

Unless otherwise stated, all work is due by 11:59 pm on the due date. All projects should be submitted via Gradescope; you are encouraged to submit early versions, since resubmissions up to the deadline are counted without penalty.

If you need additional accommodation, ask in writing in advance, with rationale and a plan for when you will be able to submit the work.

Collaboration

An assignment is an academic document, like a journal article. When you turn it in, you are claiming everything in it is your original work, unless you cite a source for it.

You are welcome to discuss projects among yourselves in general terms. However, you should not look at code or writeups from other students, or allow other students to see your code or writeup, even if the general solution was worked out together. Unless we explicitly allow it on an assignment, we will not credit code or writeups that are shared between students (or teams, in the case of projects).

If you get an idea from a classmate, the TA, a book or other published source, or elsewhere, please provide an appropriate citation. This is not only critical to maintaining academic integrity, but it is also an important way for you to give credit to those who have helped you out. When in doubt, cite! Code or writeups with appropriate citations will never be considered a violation of academic integrity in this class (though you will not receive credit for code or writeups that were shared when you should have done them yourself).

Academic Integrity

We expect academic integrity from everyone. School is stressful, and you may feel pressure from your coursework or other factors, but that is no reason for dishonesty! If you feel you can’t complete the work on the own, come talk to the professor, the TA, or your advisor, and we can help you figure out what to do.

For more information, see Cornell’s Code of Academic Integrity.

Emergency procedures

In the event of a major campus emergency, course requirements, deadlines, and grading percentages are subject to changes that may be necessitated by a revised semester calendar or other circumstances. Any such announcements will be posted to the course home page.