[C Series 1] Why Study C Right Now?

C may be an old language, but it still shows you how computers work more directly than any other language. This post explains why we picked C as the next language in the Coding category and in what order you should study it. In Part 1 we do not try to learn every concept; we focus on understanding what we will study later and why it matters.

Terms To Lock In Now

1. Compile: the process of turning human-written C source code into a program the computer can run
2. Executable: the runnable program file that comes out after compilation
3. Memory: the byte-addressed space that stores variables and data

Terms Coming Up Soon

1. Pointer: a variable that stores a memory address; we dig in starting in Part 8
2. Binary: the machine-readable format, unlike the source code that humans read

Core Ideas

Here is the roadmap for the C track. The key is to connect concepts as “how code actually runs” rather than memorizing a list of syntax rules.

Session	Topic	Core Competency
01	Why Study C Right Now?	Understand the motivation and roadmap
02	Prepare the C Environment and First Compile	Learn the gcc/clang execution flow
03	Variables and Primitive Types	Build intuition about ints/floats/chars and memory size
04	Operators and Type Conversion	Understand arithmetic rules and conversions
05	Conditions and Loops	Practice branching and repetition patterns
06	Splitting Code with Functions	Plan declarations, definitions, and return values
07	Arrays and Strings	Grasp contiguous memory and string representation
08	Pointer Basics	Get comfortable with addresses and dereferencing
09	Arrays vs. Pointers	Learn pointer arithmetic and argument passing
10	struct, enum, typedef	Design data structures
11	Splitting Files and Headers	Distinguish .c and .h roles
12	Input, Output, and Files	Practice stdio.h-based I/O
13	Dynamic Memory Allocation	Manage malloc, free, and lifetimes
14	Memory Bugs and Debugging	Trace leaks and invalid accesses
15	Preprocessor and Macros	Understand #include and #define
16	Storage Duration and Scope	Track static, extern, and variable lifetimes
17	Function Pointers and Callbacks	Pass around behavior
18	Bitwise Ops and Low-Level Instincts	Practice flags, masking, hardware-aware thinking
19	Build Automation and Project Layout	Use Makefile and multi-file builds
20	Capstone: Build a Text-Based System Tool	Combine files, structs, pointers, and build steps

Sessions 1–5 lay the foundation for syntax and execution flow; 6–10 connect functions and memory structures; 11–15 focus on practical operations like file separation and memory management; 16–20 sharpen low-level control and project skills.

• After 1–5 you can write simple programs that calculate, read input, and loop on your own.
• After 6–10 you can group data with arrays and structs and split logic into functions.
• After 11–15 you can read files and manage memory for more realistic programs.
• After 16–20 you can build multi-file projects and ship them as system tools.

Our series philosophy fits in one sentence: “You should be able to explain how code moves through memory before advancing.”

• Execution-first mindset: learn compilation, executables, and memory alongside syntax.
• Small code, big observation: run tiny examples and trace how each line behaves.
• Growing system sense: chain strings, files, dynamic memory, and build tools so the journey naturally leads to OS or embedded work later.

When we say “core competency” on the roadmap, we mean that after each session you should be able to explain in your own words why the code behaves the way it does.

Follow Along in Code

The first thing to see is that C code runs only after compilation. The example below is the smallest viable C program.

#include <stdio.h>

int main(void) {
    printf("Hello, C!\n");
    return 0;
}

main is where the program starts. printf prints to the screen, and return 0; signals a normal exit.

Save this code as hello.c and compile it to produce a separate executable.

clang hello.c -o hello
./hello

Here hello.c is the human-readable source file, while hello is what the computer actually runs. In Part 2 we will slow down and examine preprocessing, compilation, and linking separately.

Variables store values in memory. In C you declare the type first because the compiler must know how much space to reserve.

#include <stdio.h>

int main(void) {
    int age = 17;
    char grade = 'A';

    printf("age = %d\n", age);
    printf("grade = %c\n", grade);
    printf("sizeof(int) = %zu\n", sizeof(int));
    printf("sizeof(char) = %zu\n", sizeof(char));
    return 0;
}

int stores integers and char stores a single character. char is usually 1 byte, while int depends on the platform. Experiencing these differences yourself lays the groundwork for arrays, strings, and pointers.

Pointers are both the reason to learn C and the part that confuses people the most. For Part 1 you do not need to master them; just remember that C deals with memory addresses as well as raw values. Part 8 covers addresses, dereferencing, and their relationship with arrays in detail.

Why This Matters

We are not learning C just to try an old language.

• It helps you understand the foundations of software like operating systems, embedded firmware, some game engines, and databases where performance and resource control matter.
• You get to handle memory and execution flow directly, gaining debugging instincts that high-level languages often hide.
• Once you can reason about pointers, arrays, files, and build steps, you can visualize “where and how my code runs” when learning any new language.

Keep three ideas from this post:

• C is strongest when you pair syntax with how execution works.
• Memory intuition and pointers form the backbone of the series.
• The roadmap grows naturally from fundamentals to shipping a system-style tool.

We progress through four blocks:

• Foundation (1–5): read code flow with types, operators, conditionals, and loops.
• Memory (6–10): connect data handling with functions, arrays, strings, pointers, and structs.
• Operations (11–15): handle real-world needs like splitting files, I/O, dynamic memory, debugging, and preprocessing.
• Expansion (16–20): deepen control with storage duration, function pointers, bitwise work, build automation, and the capstone.

Even if the examples look small, each one prepares you for the next topic. Run them, record the output and the memory flow, and connect the dots.

Practice in CodeSandbox

The sandbox below uses CodeSandbox's Universal starter. For C, the key learning loop is still compile and run in the terminal, so recreate the lesson code as a source file and repeat that cycle directly.

Practice

• Follow: compile the Hello, C! example yourself and note the difference between the source and executable.
• Extend: add float height = 172.4f; to the variables example and print sizeof(float) to see that each type can take a different amount of space.
• Debug: intentionally swap format specifiers to %d, %c, %f and observe how the output breaks.
• Completion check: explain compilation, executables, types, and memory in one sentence each and run both examples while interpreting their results.

Wrap-Up

C is not just an “inconvenient vintage language”; it is a direct window into memory and execution. The pace might feel slower at first, but once you understand it, you will see the hidden mechanics of every other language more clearly. Next time we will prepare the C environment on macOS and perform our first compile step by step.