C Programming — Overview

Before you start: no prior programming experience is required — basic computer literacy is the only assumption.

Why This Exists (The Hook)

Higher-level languages like Python quietly manage memory for you — allocate a variable, and it's cleaned up automatically when you're done with it, no thought required. C makes you do that management by hand: request memory explicitly (malloc), free it explicitly (free), and if you forget either step, the program leaks memory or crashes — with no safety net. This isn't C being poorly designed; it's C deliberately exposing what every higher-level language is quietly doing underneath. Learning C is learning what "memory management" actually means at the level the hardware sees it.

Analogy — Think of C like driving a manual-transmission car, and higher-level languages like driving an automatic. An automatic car handles gear shifting for you — convenient, and you'll never stall it, but you also never really learn what the engine is doing at each speed. A manual forces you to feel the engine's RPM and shift gears yourself — harder to learn, but you come away actually understanding how the car works, not just how to operate it. C's manual memory management (malloc/free) is that same forced understanding — once you've done it by hand, garbage collection in other languages stops being a mystery and starts being "oh, that's the automatic version of what I already know how to do manually."

Try it (2 minutes) — Reason through why the guide insists on always compiling with -Wall, without looking anything up: C is described as "permissive by default" — it will compile code with real bugs (an uninitialized variable, a mismatched printf format specifier) without complaint. If a bug like that compiles silently and only causes a crash or wrong output much later, at runtime, far from where the actual mistake was made in the source — what would -Wall (enabling all compiler warnings) catch instead, and why would catching it at compile time be so much cheaper to fix than discovering it at runtime?

What is C?

C is a general-purpose, procedural programming language developed by Dennis Ritchie at Bell Labs, released in 1972. It's the foundation much of modern computing is built on: the Linux kernel, the CPython interpreter, MySQL's core, and most operating systems are written in C, directly or through languages that were themselves influenced by it.

What Actually Happens When You Compile a C Program

This is worth understanding early, since C's compilation model is a common source of confusion (and a common interview question):

Source code (.c)
   → Preprocessor    (expands #include, #define, macros — produces
                       expanded source, no syntax checking yet)
   → Compiler         (translates to assembly language for your CPU)
   → Assembler         (translates assembly to machine code -> object file, .o)
   → Linker            (combines your object file(s) with library code,
                        resolves function calls like printf, produces
                        the final executable)

Running gcc hello.c -o hello does all four steps in one command — but each is a distinct, separately-inspectable stage (you can stop after any stage with the right compiler flag, which matters once you start debugging build issues rather than just syntax errors).

Why Learn C?

C vs. C++ vs. Python — Where C Sits

|---|---|---|---|

The practical implication: C gives you the least "help" from the language itself (no automatic memory management, no exceptions, no classes) — which is exactly why it's taught first in many curricula. Once you understand what C makes you do manually, you understand what higher-level languages are actually doing for you.

Install a C Compiler

# Ubuntu/Debian
sudo apt update && sudo apt install gcc build-essential
gcc --version

# macOS
xcode-select --install      # Installs Clang (Apple's C compiler)
gcc --version                # Points to Clang on macOS

# Windows: MinGW-w64, or WSL (Windows Subsystem for Linux) for a native
# Linux toolchain

# Verify
echo '#include<stdio.h>
int main(){printf("Hello\n");return 0;}' > test.c && gcc test.c -o test && ./test

Hello World

#include <stdio.h>    // Standard Input/Output header

int main() {
    // Print to stdout
    printf("Hello, World!\n");

    // Variables
    int age = 25;
    float price = 99.99;
    char initial = 'A';
    char name[] = "Alice";

    printf("Name: %s, Age: %d, Price: %.2f\n", name, age, price);

    return 0;  // 0 means success to the calling shell/OS
}

# Compile and run
gcc hello.c -o hello    # Compile to executable
./hello                 # Run
# With debugging info and warnings enabled:
gcc -g -Wall hello.c -o hello  # -g = debug info, -Wall = enable all warnings

Always compile with -Wall. C is permissive by default — it will happily compile code with real bugs (using an uninitialized variable, mismatched printf format specifiers) without -Wall catching and flagging them for you.

Where C Shows Up Beyond the Classroom

Course Sections