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: September 22, 2026.

Lecture videos are posted on Canvas under the "Panopto Course Videos" tab.

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]

NOTE: Please keep in mind lecture topics are expected dates, the actual date may be a bit later/earlier, all topics will be covered before the final.

Topics Resources Assignments
Week 1
Mon 9/22 - No Lecture - Observing Yom Kippur
Lecture 1 (Wed 9/24): Welcome to CS107!
We'll go through course logistics and begin our brief tour of Unix and the command line.
No labs this week.
Lecture 2 (Fri 9/26): Unix and C
We'll continue our discussion the command line and introduce the C programming language. 		Out: assign0
Week 2
Lecture 3 (Mon 9/29): 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. 		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.
Lecture 4 (Wed 10/1): Bitwise Operators
We'll wrap up integer representations by discussing truncation, sign extension and how mixed signed and unsigned comparison operations work. Then we'll see how to manipulate bits and bytes using bitwise operators. 		B&O Ch 2.1 Lecture Quiz
Lab 1: Bits and ints
Be sure to check out our guide to gdb.
Lecture 5 (Fri 10/3): More Bitwise Operators
We'll learn about the << >> shift operators and how to use GDB to examine the execution of our programs. 		In: assign0
Out: assign1
Week 3
Lecture 6 (Mon 10/6): 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. 		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 7 (Wed 10/8): C-Strings, Buffer Overflows and Security
We'll learn more about string library functions, and discuss buffer overflows and techniques to avoid them. 		Lecture Quiz
Lab 2: C-Strings
Be sure to check out our guide to Valgrind.
Lecture 8 (Fri 10/10): Introduction to Pointers
We'll spend some time with C arrays and reintroduce the pointer. 		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. In: assign1
Out: assign2
Week 4
Lecture 9 (Mon 10/13): 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? After this lecture, you'll understand how arrays and pointers allow two syntaxes for accessing sequential memory locations, but the underlying reality of the memory is the same. 		K&R 5.2-5.5 or Essential C section 6 on advanced pointers
Lecture 10 (Wed 10/15): Stack and Heap
We'll introduce dynamic allocation on the heap with malloc, compare the stack and the heap, and get practice using dynamic allocation. 		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 Quiz
Lab 3: Arrays/Pointers
Lecture 11 (Fri 10/17): Generics and 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. 		In: assign2
Out: assign3
Week 5
Lecture 12 (Mon 10/20): Generics, void *, and 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 13 (Wed 10/22): Function Pointers, Continued
We'll continue discussing generic function pointers and do examples of how to write and call functions with function parameters. 		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 Quiz
Lab 4: void */Function Pointers
Lecture 14 (Fri 10/24): Intro to x86-64, Data Movement
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. 		In: assign3
Out: assign4
Week 6
Lecture 15 (Mon 10/27): Data Movement, Take II
We'll play catchup and use today to finish up generics and introduce x86-64. 		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 16 (Wed 10/29): Introduction to x86-64 ALU Operations
We'll talk about arithmetic and logical instructions and work through practice reverse engineering examples. 		B&O 3.5-3.6
Be sure to check out our x86-64 guide. 		(Thursday) Midterm Exam 7:00 - 9:00 PM
No labs this week.
Lecture 17 (Fri 10/31): x86-64 Condition Codes and Control Flow
We'll see how to implement C if/else in assembly. 		B&O 3.5-3.6
Be sure to check out our x86-64 guide.
Week 7
Lecture 18 (Mon 11/3): x86-64 Control Flow, Continued
We'll continue exploring loops and conditions in assembly and discuss other uses of condition codes (setx/cmov). 		B&O 3.5-3.6
Be sure to check out our x86-64 guide.
Lecture 19 (Wed 11/5): 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. 		B&O 3.7, 5.1-5.6
Be sure to check out our x86-64 guide. 		Lecture Quiz
In: assign4
Out: assign5
Lab 5: Assembly
x86-64 in all its glory.
Be sure to check out our x86-64 guide.
Lecture 20 (Fri 11/7): Privacy, Trust and Managing the Heap
We'll discuss assign5's focus on reverse engineering executables. We'll do lots of reverse engineering practice to get you up to speed on assign!
Week 8
Lecture 21 (Mon 11/10): 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 22 (Wed 11/12): Managing the Heap, Continued
We'll learn about 3 different heap allocator designs: the bump allocator, the implicit free list allocator, and the explicit free list allocator, and compare them and discuss performance tradeoffs (throughput, utilization). 		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! Lecture Quiz
Lab 6: Runtime Stack
Fun explorations with the stack!
Lecture 23 (Fri 11/14): Explicit Free List Allocator
We'll learn more about the explicit free list allocator design, and other techniques employed by allocators including coalescing and in-place realloc. We'll also talk more about the requirements for assign6. 		Optimally skim B&O Ch. 5
Week 9
Lecture 24 (Mon 11/17): Optimization
We'll explore the compilation process and the various optimizations GCC does on our behalf. We'll also learn of some tools we can use to profile our own code so we know where to optimize ourselves. This could be helpful for final tuning of your heap allocator! 		In: assign5 (Sunday)
Out: assign6 (Sunday)
Lecture 25 (Wed 11/19): Caching and Memory Hierarchies
We'll continue our discussion some optimization feastures not covered on Monday, and we'll discuss how to write cache-friendly code! 		Lecture Quiz
Lab 7: Code and Memory Optimization
Experiments in optimization and profiling.
Be sure to check out our CS107 guide to callgrind.
Lecture 26 (Fri 11/21): Caching and Memory Hierarchies, Take II
We'll continue our discussion of caching and cache-friendly code.
Holiday: Thanksgiving break!
Week 10
Lecture 27 (Mon 12/1): Wrap-up and Q&A
We'll wrap up the course themes, preview courses and opportunities post-107, and say some final words. Bring questions if you have them!
Wed 12/3 - No Lecture - Off day
No labs this week.
Fri 12/5 - No Lecture - Off day In: assign6
Final Exam Week
Final Exam: Tuesday, December 8th, 8:30 - 11:30AM