Max Rees (they/them)

Lecturer, Department of Computer Science

Purdue University

Spring 2022 — CS 15900

My lectures: view lecture schedule in the table below

My office hours: confirm availability on Brightspace calendar

My office hours for finals week:

TA office hours: confirm availability on Brightspace calendar

Lecture Quiz Date Artifacts Topic
Week 1
1 NONE Tue
11 Jan
Recording (48:43) Overview of the class; course policies; motivations.
Slides (PDF)
2 NONE Thu
13 Jan
Recording (49:18) Chapter 1. Model computer; CPU; types of memory; instruction cycle; natural, machine, and programming languages; programming workflow.
Slides (PDF)
p. 61 – 72
Assignments posted Lab #0: no point value — complete before Lab #1
Week 2
3 1 Tue
18 Jan
Recording (49:44) Chapter 2. C program structure; basic vi and *nix command-line usage; compiler warnings and errors; commenting; C identifiers; data types: int family, including short, long, and long long.
Slides (PDF)
p. 73 – 77
4 2 Thu
20 Jan
Recording (48:53) Chapter 2 continued. Character data type (char) and ASCII table; boolean data type (bool); floating-point data types (float, double, long double); variables: declaration, definition, and initialization; uninitialized variables and undefined behavior; constants: literal constants, symbolic/defined constants, memory constants; formatted input/output: printf format string and data list; format string placeholders: code, size, precision, (minimum) width, and flag.
Slides (PDF)
p. 77 – 83
Assignments posted Lab #1
Homework #1
Week 3
Mon 24 Jan 11:00 PM EST Homework #1 due
5 3 Tue
25 Jan
Recording (49:33) Chapter 2 continued. Variations of the minimum width modifier for printf() placeholders; usage of scanf() for user input; types of errors: compile-time errors (including syntax errors and the difference between gcc's "errors" and "warnings"), and run-time errors (including crashes such as segmentation faults and floating point exceptions, and logical errors); debugging with diagnostic printf() statements.
Slides (PDF)
p. 83 – 85
6 4 Thu
27 Jan
Recording (50:37) Chapter 3. Expressions; operators; operands; operator precedence; simple and compound assignments; prefix and postfix increment and decrement; side effects and sequence points; undefined behavior.
Slides (PDF)
p. 85 – 90
30 minutes before lab period Lab #1 due
Assignments posted Lab #2
Homework #2
Week 4
7 5 Tue
01 Feb
Recording (49:46) Chapter 3 continued. Single data type and mixed data type expressions; implicit data type conversions (safe) and hierarchy of data types by relative size; explicit data type conversions (can be unsafe) using "type casting" operators; rounding versus truncation with regards to floor(), (int) casts, and printf() precision modifiers; assignment data type conversions (can be unsafe); immutability of object data types; what causes the value of a variable to change (simple or compound assignment operators, scanf(), or prefix/postfix increment/decrement operators); selection by calculation with examples, including the "scaling to zero or one" formula.
Slides (PDF)
p. 90 – 94
8 6 Thu
03 Feb
Recording (42:07) Chapter 3 continued. More selection by calculation examples.

Chapter 4. Purpose of functions; function factoring; functional cohesion; calling function and called function; parameters; return values; and a special guest appearance.
Slides (PDF)
p. 94 – 96
30 minutes before lab period Lab #2 due
Assignments posted Lab #3
Week 5
Mon 07 Feb 11:00 PM EST Homework #2 due
9 7 Tue
08 Feb
Recording (48:57) Chapter 4 continued. Function declarations and definitions; void functions; functions with no parameters and no return value (static output); functions with no parameters that return a value (input); functions with parameters and no return value (dynamic output); functions with parameters that return a value (calculation).
Slides (PDF)
p. 97 – 104
10 8 Thu
10 Feb
Recording (48:51) * Chapter 4 continued. Acceptable main() functions and guidance on Homework #3 design; parameter passing: pass-by-value and pass-by-address; address operator & and dereferencing operator *; pointers and pointer types; more examples of scope. NOTE: the video editor broke so the length may appear to be 55:00, but the content ends around 48:51.
Slides (PDF)
p. 104 – 109
30 minutes before lab period Lab #3 due
Assignments posted Lab #4
Homework #3
Week 6
11 9 Tue
15 Feb
Recording (50:24) Chapter 4 continued. Mixing pass-by-address with pass-by-value and return values; usage of scanf() with a pass-by-address parameter; when to use pass-by-address; final thoughts on scope (local and global, for variables and functions respectively); structure charts: format, rules, good and bad examples; recommended problem-solving method (specify, analyze, design, code, test and debug, refine); overview of current position in the class's content: just finished sequence with chapter 4; next is selection in chapter 5; then repetition in chapter 6.
Slides (PDF)
p. 109 – 114
12 10 Thu
17 Feb
Recording (50:00) * Chapter 5. Logical data (true or false); logical expressions; C convention for true and false values ("truthiness"); logical operators: NOT (!), AND (&&), OR (||); truth tables; short-circuiting. NOTE: the linked recording is from Xiaojin Liu's lecture since Zoom failed to record my lecture twice.
Slides and notes (PDF)
p. 114 – 116
30 minutes before lab period Lab #4 due
Assignments posted Lab #5
Week 7
Mon 21 Feb 11:00 PM EST Homework #3 due
13 11 Tue
22 Feb
Recording (50:00) * Chapter 5 continued. Examples of short-circuiting with side effects; relational operators (< <= > >=) and comparative operators (== !=); compound statements; logical complements and examples. NOTE: the video editor broke so the length may appear to be 55:00, but the content ends around 50 minutes.
Slides (PDF)
p. 116, 117, 119, 120
Wed 23 Feb 08:00 – 09:00 PM, Elliott Midterm #1 (see Lecture #15 slides for statistics)
14 12 Thu
24 Feb
Recording (49:42) Chapter 5 continued. More examples of creating complements and evaluating compound statements; two-way selection using the if/else construct; nested selection with if/else; "dangling else" logical error.
Slides (PDF)
p. 120, 118, 122 – 125
30 minutes before lab period Lab #5 due
Assignments posted Lab #6
Homework #4
Week 8
15 13 Tue
01 Mar
Recording (49:21) Chapter 5 continued. Flowchart for the dangling else logical error; two-way selection using the conditional expression (also known as the ternary conditional operator); multi-way selection using if/else if/else and switch (including case labels and break statements); "fall-through" behavior of switch; comparing floating-point values for equality; C language rules for switch.
Slides (PDF)
p. 125 – 128, 130 – 132
16 14 Thu
03 Mar
Recording (50:33) Chapter 5 continued. When and how to use switch; if/else if/else with redundant conditions; comparison of if/else if/else with independent if/else; structure chart and flowchart for the overall letter grade calculation program.

Chapter 6. Repetition using loops: loop control expression (LCE), loop control variable (LCV), loop initialization and loop update, loop iterations; pre-test versus post-test looping constructs, the minimum number of iterations and when to use each; flowchart example of looping to calculate a factorial.
Slides (PDF)
p. 132 – 133, 129, 120 – 121, 134, 137 – 138
30 minutes before lab period Lab #6 due
Assignments posted Lab #7
Week 9: NO LAB THIS WEEK
Mon 07 Mar 11:00 PM EST Homework #4 due
17 15 Tue
08 Mar
Recording (49:21) Chapter 6 continued. Tabular strategy for analyzing looping code; event-controlled versus counter-controlled processes; input validation as a event-controlled process using a post-test looping construct; while and do-while loops; implementation of the factorial example; infinite loops and forcing programs to exit using Ctrl-C.
Slides (PDF)
p. 138 – 142
NONE NONE Thu
10 Mar
NONE Canceled to account for Midterm #1 during Week 7. Last day for TA office hours is Fri 11 Mar, resuming on Mon 21 Mar.
Assignments posted Homework #5
Spring Break: NO LAB OR LECTURES THIS WEEK
NONE NONE Tue
15 Mar
NONE Canceled for Spring Break.
NONE NONE Thu
17 Mar
NONE Canceled for Spring Break.
Week 10
18 16 Tue
22 Mar
Recording (45:58) Chapter 6 continued. Nested loops and an example using factorials for ranges of numbers; more on infinite loops; introduction to the C for loop and when to use it; examples of rewriting while loops into for loops.
Slides (PDF)
p. 142 – 148
19 17 Thu
24 Mar
Recording (49:50) Chapter 6 continued. Final thoughts on for loop usage; looping example with structure chart and flowcharts: calculating average, minimum, and maximum for an unknown amount of exam scores; another example with structure chart, flowcharts, and code: rearranging the digits in a number from largest to smallest.
Slides (PDF)
p. 148, 135 – 136, 149 – 154
30 minutes before lab period Lab #7 due
Assignments posted Lab #8
Week 11
Mon 28 Mar 11:00 PM EDT Homework #5 due
20 18 Tue
29 Mar
Recording (48:50) Chapter 6 continued. Introduction to recursion: recursive cases and base cases; example of recursion with factorials; limitations of recursion (stack overflow); review of repetition techniques.
Slides (PDF)
p. 155 – 157
21 19 Thu
31 Mar
Recording (49:59) Chapter 8. Introduction to arrays: motivation, concept, declaration and definition, initialization and assignment; iterating over arrays with loops; going beyond the limits of an array.

Extra lecture quiz question. This is the answer key for the third question that we did not have time to get to. I would recommend that you attempt the question on your own by looking at the last slide from the "Slides (PDF)" link FIRST, then review your work using this other document. Additionally: what is the purpose of this segment of code, and is it performing that purpose correctly? What might you change?
Slides (PDF)
p. 161 – 166
30 minutes before lab period Lab #8 due
Assignments posted Lab #9
Homework #6
Week 12
22 20 Tue
05 Apr
Recording (49:08) Chapter 8 continued. Arrays across function boundaries: syntax and semantics of passing individual array elements by value and by address, and of passing entire arrays by address; handling of the array name as an address and the index as an offset with respect to that address (hence zero-based indexing); summary of passing various objects (variables, array elements, and arrays) by value and by address; printing or scanning entire arrays.
Slides (PDF)
p. 167 – 172
23 21 Thu
07 Apr
Recording (46:41) Chapter 8 continued. Introduction to efficient usage of arrays: more efficiently reversing the order of elements in an array; introduction to sorting: method of swapping values, unsorted lists and sorted lists, and passes; algorithm for selection sort.
Slides (PDF)
p. 173 – 175
30 minutes before lab period Lab #9 due
Assignments posted Lab #10
Week 13
Mon 11 Apr 11:00 PM EDT Homework #6 due
24 22 Tue
12 Apr
Recording (50:19) Chapter 8 continued. Algorithm and code for bubble sort; algorithm for insertion sort; summary of sorting algorithms.
Slides (PDF)
p. 176 – 180
Wed 13 Apr 08:00 – 09:30 PM, Elliott Midterm #2 (see Lecture #25 slides for statistics)
NONE NONE Thu
14 Apr
NONE Canceled to account for Midterm #2.
30 minutes before lab period Lab #10 due
Assignments posted Lab #11
Homework #7
Week 14
25 23 Tue
19 Apr
Recording (51:00) Chapters 9/10. Generalizing addresses and pointer variables from the pass-by-address technique using the address-of operator & and dereferencing/indirection operator *; pointer declaration/definition, initialization, and modification; relationship of arrays and pointers; pointer arithmetic and arrays; memory allocation for dynamically-sized arrays using the stdlib.h function malloc() and the sizeof operator.
Slides (PDF)
p. 192 – 199
26 24 Thu
21 Apr
Recording (50:05) Chapters 9/10 continued. Live coding examples of pointers, pointer arithmetic, and malloc(), and some final thoughts thereof.
Slides (PDF)
p. 192 – 199
30 minutes before lab period Lab #11 due
Assignments posted Lab #12
Dead week (15): NO LAB THIS WEEK
Mon 25 Apr 11:00 PM EDT Homework #7 due
27 25 Tue
26 Apr
Recording (50:35) Chapter 8 continued. Solving questions regarding sorting algorithms; multidimensional arrays.
Slides (PDF)
p. 189 – 191
28 26 Thu
28 Apr
Recording (49:00) Chapter 8 continued. Introduction to searching: sequential search concept and implementation; introduction to binary search: algorithm and implementation.

Extra lecture quiz question. This is the answer key for the fourth question that we did not have time to get to. I would recommend that you attempt the question on your own by looking at the second to last slide from the "Slides (PDF)" link FIRST, then review your work using this document.
Additionally: for the example demonstrated during lecture of finding the value of 25 in the array, what are the final values of first and last? Click here to reveal the answer. According to the implementation we see on p. 188, the loop is forcibly terminated by setting last = first - 1. This would mean first = 10 and last = 9. In general, this implementation can ONLY end if first > last.

In a similar vein, what are the final values of first and last for Lecture Quiz #26 question #2? Click here to reveal the answer. first = 6 and last = first - 1 = 5. See above for the rationale.
Slides (PDF)
p. 181 – 188
30 minutes before lab period Lab #12 due
Fri 29 Apr 11:00 PM EDT Lab Quiz #13 due (extra credit; read study guide)
Finals week (16): NO LAB OR LECTURES THIS WEEK
Thu 05 May 03:30 – 05:30 PM, Elliott Final Exam

Last modified on Sat 07 May 2022 11:57 AM EDT.