The Programming Course Guide

Setting up a MacBook Air for C

Install the compiler (15 minutes, no downloads from random sites), pick an editor, write and run the first program from the terminal, learn the compile-run loop, and know the four ways a Mac differs from the lab machines.

Operators, I/O & selection, from the beginning

Values vs side effects, integer division and casts, 1/0 truth and precedence, short-circuit (with a stepper that shows which parts get skipped), & vs &&, ++/--, the comma operator, characters as numbers, nested if, ?:, switch fall-through, scanf as a pattern, and the three rewrite templates.

Operators, I/O & selection, in one page

Fifteen rule cards, the rewrite templates, three past-paper questions worked (including one the answer key gets wrong), a 13-row trap table, the prerequisite kit, and practice mapped to Hanly and the past-paper questions.

Operators & I/O: predict the output

Ten families (short-circuit, ++, comma, integer division, ?:, switch, scanf, & vs &&, chars, printf widths), six fresh items per sheet, trace on every answer. 460 generated programs checked against clang, 0 mismatches.

Number systems drill

Six methods on one screen (repeated division, fractions by repeated multiplication, place values, grouping bits from the point, 8-bit 2's complement, unknown bases), each worked on a past-paper example, then self-marking sheets with the actual working behind every answer.

Loops, from the beginning

Why repetition needs a new construct, the three parts of every loop, while / do-while / for built one at a time, a step-through of exactly when a for loop runs each part, nested loops as a grid, break vs continue, the three bug families, and the routine for attacking an unseen problem.

Loops, in one page

The ten patterns that cover the whole lab sheet (digit extraction, accumulators, flags, running pairs, shrinking ranges, nested grids), the trap table of standard mark-losers, two worked examples at evaluation level, the prerequisite kit, and a ranked practice table.

Loops, one rung at a time

Fourteen small programs in five rungs — fixed count, accumulate, digits, condition-controlled, nested — each one idea with the exact output to check against and a folded solution. The rung the sheet skips. Type them; twenty minutes a day.

Predict the output

Six freshly generated loops per sheet across six families (start/stop/step, break/continue, accumulate, nested, digit loops, while vs do-while); type what each prints, reveal the real output, the trace and the rule. Outputs verified against compiled C.

Lab 4, every problem worked

All seven practice problems, five debugging exercises, four dry runs and the calendar challenge — each with the thinking, a trace, and the output it really printed. Every program compiled and run before publishing. Opens with a 45-minute triage path for a short evening.

Functions, from the beginning

The black box, the parts of a function, what happens when you call one (step through it), return vs print, prototypes, void, pass-by-value, scope and shadowing, and why globals are a last resort.

Functions, in one page

Every idea from Lecture 7 on one page, the in-class temperature converter fully worked, a globals-and-shadowing trace, the trap table with the real clang error messages, the prerequisite kit, and a practice table.

Arrays, from the beginning

Boxes in a row and why indexing starts at 0, the traversal pattern, sum/min/search, binary search, bubble vs selection sort (with a step-through widget), 2D arrays and matrices.

Arrays, in one page

The patterns, the in-class Class Statistics activity fully worked, a binary search trace including not-found, matrix add/transpose, the trap table (i <= size, sizeof inside a function, …), prerequisite kit and practice table.

Strings, from the beginning

The '\0' rule in a memory strip, and an input widget: type a line and see exactly what %s, %[^\n] and fgets store, including the leftover newline and overflow. Then strlen vs sizeof, why == fails, the string.h and ctype.h tools, and character loops.

Strings, in one page

Rule cards, the palindrome in-class activity solved, a word count traced, a strcpy/strcat predict-the-output, the four slide corrections (zero-filled tail, <= strlen, safe scanf widths, strcmp's sign), a 14-row trap table and practice.

Arrays, one rung at a time

Small programs in rungs, from printing one element to sorting and 2D grids, some with a small function of your own. Each has its exact output to check and a folded solution. Every program compiled.

Functions, arrays & strings: predict the output

Freshly generated snippets: pass-by-value, return vs print, shadowed globals, early return, traversal, search, sort passes, 2D, and now eight strings families (strlen vs sizeof, '\0' in the middle, strcmp, strcpy/strcat, off-by-one, scanf). Type the output, then reveal the trace and the rule. 620 generated programs checked against clang.

Mid-sem past papers, decoded

All three papers quoted as set, with a traced answer to every question. The answer-key errors are flagged: two wrong outputs, a buggy quadratic, and two model answers that don't compile or are incomplete. Also: a topic map, the program-writing trend, and the negative-marking arithmetic for the multiple-choice sections.

Writing a program on paper

A five-move opening routine that earns the skeleton marks even when the core logic is shaky (up to 30 of 80 marks in 2026), eight patterns and their signal words, and the paper-coding mistakes a compiler would have caught.

Past-paper programs, built step by step

The past-paper programs (the 2026 ones use about 80 of 90 marks): insert with shift, largest of three, coin change, cricket stats, quadratic via switch, digit-array +1, smallest permutation, character streams. Routine applied, rubric-mapped skeleton, compiled solution, mark-losers. Most double as lab-exam practice.