CS107 Calendar

Calendar

Below is a preview of the week-by-week plan for the quarter. There may be adjustments and rearrangements as we go.

Last updated: August 06, 2025.

Lecture videos are posted on Canvas under the "Panopto Course Videos" tab for enrolled students.
In the readings listed below, B&O is Computer Systems (Bryant and O'Hallaron), K&R is The C Programming Language (Kernighan and Ritchie) accessible here (requires free Open Library account to borrow), and Essential C is a PDF available at http://cslibrary.stanford.edu/101. B&O scanned PDFs for the listed readings are available on Canvas under the "Files" tab.

Lecture Code

Any code examples worked in class will be posted into /afs/ir/class/cs107/lecture-code/lect[N] where you replace [N] with the lecture number. You can make a copy to compile or modify by doing the following, which will make a folder in the current location called lect[N] that is a copy of the lect[N] code.

cp -r /afs/ir/class/cs107/lecture-code/lect[N] lect[N]

Topics	Resources	Assignments
Week 1
Lecture 1 (Mon 6/23): Welcome to CS107! We'll go through course logistics, learning goals, and a tour of Unix and the command line.	Lecture Slides Handouts: Syllabus, Honor Code B&O Ch 1 - skim this chapter for a quick overview of what is meant by systems, and for a preview of topics to come.	Out: assign0
Lecture 2 (Wed 6/25): Unix and C We'll get started with the command line and introduce the C programming language.	Lecture Slides
Lecture 3 (Fri 6/27): Integers, Bits and Bytes Topic 1: How can a computer represent integer numbers? We'll learn about the representation of the integer types: `char`, `short`, `int`, and `long`, in both unsigned and two's complement signed. We'll discuss binary, hexadecimal, integer arithmetic and overflow.	Lecture Slides Lecture Code available on myth B&O Ch 2.2-2.3 - skim the formal proofs, but it's important to take away a solid working knowledge of two's complement and behaviors of integer operations.
Week 2
Lecture 4 (Mon 6/30): Chars and C-Strings Topic 2: How can a computer represent and manipulate more complex data like text? We'll explore how strings and characters are manipulated in C using the `char` and `char *` types, discuss null termination, and become familiar with the `string.h` functions.	Lecture Slides K&R (1.9, 5.5, Appendix B3) or Essential C section 3 for C-strings and `string.h` library functions. C-strings are primitive compared to Java/C++ strings, so take note of the manual efforts required for correct use and pitfalls to avoid.
Lecture 5 (Wed 7/2): C-Strings, Pointers, and Arrays We'll review a little bit of what we went over on Monday! Then we'll dig deeper into C strings and learn more about how C strings are examples of arrays and pointers.	Lecture Slides Lecture Code available on myth K&R Ch 1.6, 5.5 or Essential C section 3 on the mechanics of pointers and arrays. Pay special attention to the relationship between arrays and pointers and how pointers/arrays are passed as parameters.
Lab 2: C-Strings Be sure to check out our guide to Valgrind.
Week 3
Lecture 6 (Mon 7/7): Pointers and Arrays Topic 3: How can we effectively manage all types of memory in our programs? We'll answer questions like: how are pointers useful in programs? How are arrays and pointers the same? How are they different? How is an array/pointer passed/returned in a function call?	Lecture Slides K&R 5.2-5.5 or Essential C section 6 on advanced pointers
Lecture 7 (Wed 7/9): Stack and Heap We'll introduce dynamic allocation on the heap with `malloc` and `free` and compare the stack and the heap.	Lecture Slides K&R 5.6-5.9 or Essential C section 6 on the heap. The key concept is comparing and contrasting stack and heap allocation.
*Lecture 8 (Fri 7/11): Generic Operations: `void ` Topic 4:** How can we use our knowledge of memory and data representation to write code that works with any data type? We'll introduce untyped `void *` pointers and motivate C generics. We'll also discuss vulnerability disclosure, use-after-free bugs and partiality.	Lecture Slides Lecture Code available on myth K&R 5.11, review man pages or your C reference to be introduced to generic functions in the C library (`qsort`, `lfind`, `bsearch`)lecture_code = True
Week 4
Lecture 9 (Mon 7/14): Function Pointers We'll continue discussing generics and introduce function pointers, which allow us to pass functions as parameters and store them in variables.	Lecture Slides Lecture Code available on myth K&R 5.11, review man pages or your C reference to be introduced to generic functions in the C library (`qsort`, `lfind`, `bsearch`)
Week 5
Lecture 10 (Mon 7/21): Intro to Assembly Topic 5: How does a computer interpret and execute C programs? We'll introduce assembly/machine language and find out what's happening underneath the hood of the C compiler, including a discussion of the x86-64 instruction set architecture and its powerful mov instruction, along with addressing modes, data layout, and access to variables of various types.	Lecture Slides B&O 3.1-3.3 for background info on x86-64 assembly. Very carefully read B&O 3.4 on addressing modes and data transfer. The multitude of addressing modes is one of the things that puts the first "C" in CISC. Be sure to check out our x86-64 guide.
Lecture 11 (Wed 7/23): Arithmetic & Logic Operations We'll be talking about arithmetic and logical instructions and do practice reverse engineering examples.	Lecture Slides
Lecture 12 (Fri 7/25): x86-64 Condition Codes and Control Flow We'll see how to implement C `if`/`else` in assembly.	Lecture Slides B&O 3.5-3.6 Be sure to check out our x86-64 guide.
Week 6
Lecture 13 (Mon 7/28): x86-64 Runtime Stack We'll talk about procedures and the runtime stack along with instructions for call/return, parameter passing, local stack storage, and register use.	Lecture Slides
Lecture 14 (Wed 7/30): Alignment, Optimization, & Basic Architecture We'll have larger discussions of privacy and trust, and then find out what's happening underneath the hood of the C compiler	Lecture Slides
Lecture 15 (Fri 8/1): Managing the Heap Topic 6: How do core memory-allocation operations like `malloc` and `free` work? We'll have larger discussions of privacy and trust, and then move on to our final main topic. We'll see how the heap fits into the address space and introduce design decisions for implementing `malloc`/`realloc`/`free`, as well as performance tradeoffs (throughput, utilization).	Lecture Slides B&O Ch. 9.9 and 9.11 cover heap allocation implementation and memory misuses. There's lots of very useful detail in 9.9 for your heap allocator!
Week 7
Lecture 16 (Mon 8/4): Managing the Heap, Continued We'll explore the implicit free list allocator, and the explicit free list allocator, and compare them and discuss performance tradeoffs (throughput, utilization). We'll learn more about other techniques employed by allocators including coalescing and in-place realloc.	Lecture Slides Optimally skim B&O Ch. 5
Lecture 17 (Wed 8/6): Sockets Topic 7: How can we perform network interactions via C programs? We'll introduce the basics of networking and socket operations.	Lecture Slides
Final Exam Week
Final Exam: Friday, August 15th, 3:30PM-6:30PM PDT