Schedule

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

Lecture Code

Any code examples worked in class will be posted after lecture 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]
``````

Week 1
Lecture 1 (Mon 3/29): Welcome to CS107!
We'll go through course logistics, learning goals, and a tour of C programs.
Lecture 1 Slides
Lecture 1 Code
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
No labs this week.
Lecture 2 (Fri 4/2): Integers
Topic 1: How can a computer represent integer numbers?
We'll learn more about the representation of the integer types: `char`, `short`, `int`, and `long`, in both unsigned and two's complement signed. We'll also discuss integer arithmetic, overflow, truncation and sign extension, and how mixed signed and unsigned comparison operations work.
Lecture 2 Slides
Lecture 2 Code
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 3 (Mon 4/5): Bits and Bitwise Operators
We'll dive further into bits and bytes and how to manipulate them using bitwise operators.
Lecture 3 Slides
Lecture 3 Code
B&O Ch 2.1
In: assign0
Out: assign1
Lab 1: Bits and `ints` Be sure to check out our guide to gdb.
Lecture 4 (Fri 4/9): 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 4 Slides
Lecture 4 Code
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.
Week 3
Lecture 5 (Mon 4/12): More C-Strings
Now it's time to start digging into the use of `*` and `&`, pointer operations/arithmetic, and memory diagrams. In lecture, we will trace through code, draw lots of pictures, and poke around in gdb.
Lecture 5 Slides
Lecture 5 Code
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. In (Wed): assign1
Out: assign2
Lecture 6 (Fri 4/16): Arrays and Pointers
Topic 3: How can we effectively manage all types of memory in our programs?
We'll answer questions like: 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.
Lecture 6 Slides
Lecture 6 Code
K&R 5.2-5.5 or Essential C section 6 on advanced pointers
Week 4
Lecture 7 (Mon 4/19): Stack and Heap
We'll learn about stack allocation, stack frames, and parameter passing. Then, we'll introduce dynamic allocation on the heap (`malloc`/`realloc`/`free`), heap contractual guarantees and undefined behavior.
Lecture 7 Slides
Lecture 7 Code
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.
Lab 3: Arrays/Pointers In (Wed): assign2
Out: assign3
Lecture 8 (Fri 4/23): `void *`, Generics
Topic 4: How can we use our knowledge of memory and data representation to write code that works with any data type?
We'll continue comparing and contrasting stack and heap allocation. Then, we'll move on to untyped `void *` pointers and motivate C generics.
Lecture 8 Slides
Lecture 8 Code
still working through K&R 5.6-5.9 or Essential C section 6 on the heap.
Week 5
Lecture 9 (Mon 4/26): More Generics
We'll talk about function pointers, which allow us to implement generic operations using client callbacks.
Lecture 9 Slides
Lecture 9 Code
K&R 5.11, review man pages or your C reference to be introduced to generic functions in the C library (`qsort`, `lfind`, `bsearch`)
Lab 4: `void *`/Function Pointers In (Wed): assign3
Out: assign4
Lecture 10 (Fri 4/30): 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. Then, we'll talk about addressing modes, data layout, and access to variables of various types.
Lecture 10 Slides
Lecture 10 Code
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.
Week 6
Lecture 11 (Mon 5/3): x86-64 ALU
We'll talk about arithmetic and logical instructions.
Lecture 11 Slides
B&O 3.5-3.6
Be sure to check out our x86-64 guide.
Lab 5: Assembly
x86-64 in all its glory
Be sure to check out our x86-64 guide. Out (Wed): Mid-quarter assessment
Lecture 12 (Fri 5/7): x86-64 Condition Codes and Control Flow
We'll see how to implement C `if`/`else` and loops in assembly and discuss other uses of condition codes (`setx`/`cmov`).
Lecture 12 Slides
Lecture 12 Code
B&O 3.6
Be sure to check out our x86-64 guide.
In: Mid-quarter assessment
Week 7
Lecture 13 (Mon 5/10): x86-64 Runtime Stack
We'll talk about procedures and the runtime stack and introduce instructions for call/return, parameter passing, local stack storage, and register use.
Lecture 13 Slides
Lecture 13 Code
B&O 3.7, 5.1-5.6
Lab 6: Runtime Stack
Fun explorations with the stack!
In (Wed): assign4
Out: assign5
Fri 5/14 - No Lecture
Week 8
Mon 5/17 - No Lecture
No labs this week.
Lecture 14 (Fri 5/21): Managing the Heap
Topic 6: How do core memory-allocation operations like `malloc` and `free` work?
We'll see how the heap fits into the address space. We'll introduce design decisions for implementing `malloc`/`realloc`/`free`, as well as performance tradeoffs (throughput, utilization). Then, we'll compare and contrast stack and heap allocation.
Lecture 14 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 9
Lecture 15 (Mon 5/24): Optimization
We'll take a look at 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!
Lecture 15 Slides
Lecture 15 Code
Optimally skim B&O Ch. 5
In: assign5
Out: final project
Lab 7: Code and Memory Optimization
Experiments in optimization and profiling
Be sure to check out our CS107 guide to callgrind.
Lecture 16 (Fri 5/28): 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!
Lecture 16 Slides
Lecture 16 Code
CS107 Recap Page
Week 10
Mon 5/31 - No Lecture - MEMORIAL DAY HOLIDAY
No labs this week.
Fri 6/4 - No Lecture In: final project