Intermediate C Programming Course – East Africa

Course outline and learning expectations

This is a tutor-led course. The outline shows what your tutor will cover; teaching materials and examinations are provided directly to enrolled students.

What you will learn

• By the end of the course, the learner will be able to:
• Trace stack and heap memory and explain object lifetime and ownership.
• Allocate, resize and release dynamic memory without leaks or invalid access.
• Model program data with structures, enumerations, unions and bit flags where appropriate.
• Design multi-file C programs with clean headers, internal helpers and public interfaces.
• Explain preprocessing, compilation, linking and common build failures.
• Process command-line arguments and robustly read text and binary files.
• Implement and evaluate dynamic arrays, linked lists and callback-based operations.
• Test and debug C code with assertions, sanitizers, GDB or LLDB, and Valgrind where supported.
• Build a modular, memory-safe data-processing application in C.

Modules

1. 1

   Pointer fluency and the C memory model

   Pointer arithmetic and array traversal.Pointers to pointers.Stack, static storage and heap.Object lifetime, scope and ownership conventions.Practice: trace and repair pointer defects.
2. 2

   Dynamic memory management

   `malloc`, `calloc`, `realloc` and `free`.Allocation checks and cleanup paths.Dynamically sized strings and arrays.Preventing leaks, double frees and use-after-free defects.Practice: resizable collection of records.
3. 3

   Rich data modelling

   Nested structures and arrays of structures.`enum`, `union`, `typedef` and bit flags.Choosing representations for clarity, size and correctness.Practice: transaction, inventory or sensor-reading model.
4. 4

   Modular C program design

   Headers, include guards and source files.Public interfaces and private implementation details.`static`, `extern`, declarations and definitions.Naming, contracts and defensive function design.Practice: convert a single-file program into modules.
5. 5

   From source files to a program

   Preprocessor, compiler, assembler and linker roles.Object files, libraries and common linker errors.Compiler warning levels.Repeatable builds with Make.Practice: build a small reusable library and application.
6. 6

   Robust files and command-line programs

   `argc`, `argv` and option validation.Text versus binary I/O.Structured parsing and malformed-data handling.File positions, status checks and useful error messages.Practice: import, validate and summarise a data file.
7. 7

   Data structures, tests and memory diagnostics

   Dynamic arrays and singly linked lists.Function pointers and callback-based operations.Assertions and table-driven tests.Debugging with GDB or LLDB.Detecting defects with sanitizers and Valgrind.
8. 8

   Capstone project

   Build a modular data-processing application with persistent storage.Suggested contexts: stock movement, clinic queue data, crop purchases or school records.Required evidence: multi-file source, Makefile, tests, memory-check report and README.Final code review and readiness check for the advanced course.