C Programming

C is a useful first language because it makes important programming ideas visible. Learners work directly with data representation, control flow, functions, memory, files and the build process instead of relying on a large framework to hide them.

This is an intensive foundations programme for people who are completely new to programming as well as learners who have used C informally and want to close conceptual gaps. The course builds progressively from small console programs to a modular command-line application.

Participation requirements

No prior programming knowledge or prior Deesha course is required. Learners need regular access to a 64-bit Windows, Linux or macOS computer, basic file-and-folder skills, and permission to install or use the course toolchain. Plan approximately 30–45 minutes of practice after most sessions and up to 90 minutes between final-project sessions; this practice is recommended for fluency and is not counted in the 40 guided hours.

Who should choose a different course

This course is not intended for experienced C developers who already work confidently with pointers, dynamic memory and multi-file programs. It also does not teach microcontroller peripherals, embedded toolchains, real-time operating systems, operating-system internals, exploit development, processes, threads, signals or network sockets. Those belong in focused follow-on programmes after the language foundation is secure.

Language standard and toolchain

The course uses ISO C23 as the current language reference while compiling all required exercises with an explicit C17-compatible portability profile. Selected C23 improvements may be demonstrated as optional awareness, but learners are never assessed on a feature that is not dependably available in the supported GCC and Clang environments.

Learners use a current stable GCC or LLVM/Clang toolchain with GDB or LLDB. The planned pilot environments are MSYS2 UCRT64 GCC on Windows, GCC on Linux and Apple Clang on macOS. Each must pass the clean-machine release checklist before the first batch. Early exercises invoke the compiler directly so diagnostics, compilation and linking remain visible. The final project introduces CMake for a reproducible multi-file build.

Development environment options

1. Recommended: Visual Studio Code with the C/C++ tooling, LLVM/Clang, a debugger and CMake Tools. This keeps the setup free and lightweight while exposing the real build and debug workflow.
2. Alternative: CLion with a configured LLVM/Clang or GCC toolchain. It provides a more integrated project, CMake and debugging experience, but has higher system requirements and must be used under an appropriate JetBrains licence.

How each session works

Each two-hour session follows a consistent rhythm:

• approximately 35 minutes of concept explanation and live demonstration
• approximately 70 minutes of guided and independent coding
• approximately 15 minutes of review, debugging discussion or a short formative learning check

The balance changes during final-project sessions, when most of the time is used for implementation, review and correction.

Final applied project — Campus Support Desk CLI

Learners build a domain-neutral command-line application for recording and managing campus support tickets. The brief requires no specialist helpdesk knowledge and gives learners clear acceptance criteria, starter interfaces and sample data without giving them the completed implementation.

The project requires learners to:

• model tickets with structures and enumerations for category, priority and status
• use a tagged union for category-specific lab, room or account-support details
• provide a menu with robust, line-based input and clear validation errors
• add, list, find and update ticket records
• store records in a dynamically managed collection
• save and reload data from a documented text or CSV format
• separate data, workflow, input/output and utility responsibilities across source and header files
• compile without warnings under the course flags and handle allocation or file failures safely
• include a README, sample data and a short learner demonstration

Recommended depth and boundaries

Pointers

Pointers are taught deeply enough for learners to reason about addresses, dereferencing, arrays, strings, function parameters, structures, dynamic memory, null pointers and lifetime errors. Function pointers and complex multi-level pointer designs are outside the required scope; a simple pointer-to-pointer example may be used when explaining an operation that reallocates a collection.

Dynamic memory

Learners use malloc, calloc, realloc and free, check allocation failures and practise one clear ownership model. The course introduces leaks, dangling pointers and double-free defects and uses sanitiser-assisted checks where the operating system and toolchain support them.

Data structures

Required structures are arrays, strings, structures, arrays of structures, enumerations, unions and one dynamically resized collection. Linear search and elementary sorting are included. Linked lists may be demonstrated as an extension; stacks, queues, trees, hash tables and graph algorithms are not required in this foundations course.

Systems programming

Required systems awareness covers compilation, linking, memory regions at a conceptual level, headers, multiple source files, command-line execution, file input/output, diagnostics and debugging. Processes, threads, signals, pipes, sockets, memory mapping and device-level programming are reserved for follow-on courses.

Assessment and completion

Each session includes a formative learning check. The required final quiz is delivered in Moodle; session checks may also be assembled there after platform import review. Course completion requires:

• at least 80% attendance
• at least 60% on the required final quiz, with a maximum of two attempts

For this first pilot batch, attendance and the final quiz are recorded and verified manually by the trainer. Automated tracking arrives with the learning platform; the completion criteria above are the same either way.

The final project is reviewed and demonstrated as applied learning evidence, but it is not an additional completion gate for this pilot. The completion record therefore confirms the attendance and knowledge-check criteria above; project evidence is recorded separately and does not claim an independently certified level of professional capability. This course does not provide a certification.

Learning materials

Active enrolled learners receive session study guides, starter files, exercises, the course quick reference and interview-preparation material. Approved session recordings may be provided when a batch records them with the required notice, consent, review and access controls. Learner material is shared through restricted access. Study material is view-only where the platform supports it; starter code and exercise data are downloadable so learners can compile and edit a personal working copy. Trainer plans, source presentations, solutions and question rationales remain private.

Interview-preparation material

Learners receive supplementary material covering common foundation-level C questions and code-reading exercises. It will be exported to an accessible participant format before release. This material supports revision; the course does not promise interview or employment outcomes.