Home › Module 01: Computer Architecture & The Machine Model

Module 01: Computer Architecture & How C Works Under The Hood

Duration: 3.5 Hours • Beginner to Systems

1. Ground Zero Fundamentals 1 / 4

What is a Computer & How Does It Think?

Understanding Bits, Bytes, and Binary from Absolute Ground Zero

At the physical hardware level, a computer contains billions of tiny microscopic semiconductor switches called transistors. Each transistor has two physical electrical states: Conducting electricity (High Voltage ~1.2V–3.3V) or Insulating electricity (Ground Voltage ~0V).

💡

The Binary Language

We represent these two physical voltage states mathematically as 1 (ON) and 0 (OFF). This single binary digit is called a Bit (Binary Digit).

Unit	Definition	Capacity / Value Range
1 Bit (b)	Smallest unit of digital information (0 or 1)	2 distinct states (`0` or `1`)
1 Nibble	Group of 4 bits (e.g. `1010`)	16 distinct states (Represented by 1 Hexadecimal digit `0x0` to `0xF`)
1 Byte (B)	Standard atomic memory unit = 8 bits (e.g. `11001010`)	256 distinct states (`0` to `255`)
1 Word	Natural CPU data transfer size (32 bits = 4 Bytes, or 64 bits = 8 Bytes)	4,294,967,296 states (32-bit) / 18.4 Quintillion states (64-bit)

2. Hardware Architecture 2 / 4

Von Neumann Architecture & The Memory Hierarchy

CPU, ALU, Registers, Cache, and RAM speed differentials

In the 1940s, mathematician John von Neumann established the fundamental blueprint used by every modern computer (Mac, PC, iPhone, Supercomputer):

Central Processing Unit (CPU): The "brain" containing the Arithmetic Logic Unit (ALU) for mathematical calculations and the Control Unit (CU) for decoding instructions.
Registers: Ultra-fast storage locations inside the CPU silicon itself (e.g. %rax, %rsp for stack pointer, PC / %rip for Program Counter).
Memory (RAM): Array of numbered storage cells holding both program instructions and runtime data.
Buses: Electrical wires transferring Address, Data, and Control signals.

Storage Tier	Access Latency	Typical Size	Analogy
CPU Registers	~0.5 nanoseconds	~1 KB	Information in your immediate conscious thought
L1 / L2 / L3 Cache	~1 – 15 nanoseconds	32 KB – 64 MB	A notebook sitting open on your desk
System RAM (DRAM)	~60 – 100 nanoseconds	8 GB – 64 GB	A book on a shelf in your room
NVMe SSD / Disk	~10,000 – 100,000 ns	512 GB – 4 TB	A book in the public library across town

3. The Compilation Pipeline 3 / 4

How C Code Turns into Machine Executable Binary

The 4-Stage Pipeline: Preprocessor → Compiler → Assembler → Linker

CPUs cannot read C source code directly. The compiler toolchain (like GCC or Clang) transforms your human-readable .c file into raw machine code through 4 distinct stages:

GCC Pipeline Commands

# Stage 1: Preprocessor (Expands #include, removes comments, evaluates #define)
gcc -E main.c -o main.i

# Stage 2: Compiler (Translates C code into target Assembly instructions)
gcc -S main.i -o main.s

# Stage 3: Assembler (Converts assembly text into relocatable binary machine object)
gcc -c main.s -o main.o

# Stage 4: Linker (Resolves external symbols & C standard libraries to create executable)
gcc main.o -o my_program

⚠️

Why C is Unique

Unlike Python (interpreted at runtime line-by-line) or Java (compiled to bytecode executed on a virtual machine), C compiles straight to native CPU opcodes. There is zero runtime interpreter overhead and zero garbage collection pauses.

4. Process Memory Map 4 / 4

Virtual Memory Layout of a Running C Program

Text, Data, BSS, Heap, and Stack memory segments

When the OS kernel loads a C program into memory, it assigns a dedicated Virtual Address Space divided into 5 standard segments:

${Visualizers.renderProcessMemoryMap()}

🚨

What is a Segmentation Fault?

If a C program attempts to write data into the read-only Text / Code segment (such as trying to modify a string literal like char *s = "apple"; s[0] = 'A';) or dereference an invalid memory address like NULL, the CPU's Memory Management Unit (MMU) halts the process with a SIGSEGV (Segmentation Fault).

1. Detailed Ground Zero: Bits, Bytes, and Semiconductor Memory

Every digital computer represents information using electricity. Inside RAM and CPU registers, tiny capacitor and transistor circuits hold electrical charge. Because measuring exact analog voltages is prone to noise and interference, computers use binary digital logic: any voltage above a threshold is 1 (True), and any voltage near 0V is 0 (False).

To represent numbers larger than 1, we combine bits into positional base-2 binary numbers. For instance, in 8-bit binary:

Binary Positional Math

Bit Position:   2^7   2^6   2^5   2^4   2^3   2^2   2^1   2^0
Decimal Weight: 128   64    32    16    8     4     2     1
-----------------------------------------------------------------
Binary:          0     0     1     0     1     0     1     0
Value:          0*128 + 0*64 + 1*32 + 0*16 + 1*8 + 0*4 + 1*2 + 0*1 = 42

2. Step-by-Step Deep Dive into the GCC 4-Stage Compilation Pipeline

Let us write a tiny C program and observe every single intermediate file generated by the compiler toolchain:

main.c

#include <stdio.h>
#define PI 3.14159

int main(void) {
    // This comment will be stripped by the preprocessor
    double radius = 5.0;
    double area = PI * radius * radius;
    printf("Area: %f\\n", area);
    return 0;
}

Stage 1: Preprocessor (`gcc -E main.c -o main.i`)

The preprocessor scans the source code and replaces #include <stdio.h> with the full 800+ lines of standard I/O declarations. It strips out all comments and substitutes occurrences of PI with the literal 3.14159.

Stage 2: Compilation to Assembly (`gcc -S main.i -o main.s`)

The compiler checks your code for syntax correctness, ensures variables match expected data types, and transforms C expressions into low-level assembly language mnemonics (such as movq, mulsd, call).

Stage 3: Assembly to Relocatable Object (`gcc -c main.s -o main.o`)

The assembler translates assembly mnemonics into raw binary machine opcodes (0s and 1s) packaged into an ELF (Linux) or Mach-O (macOS) object file.

Stage 4: Linking (`gcc main.o -o main`)

The linker resolves the memory address of the printf function by linking the compiled C runtime library (libc) into the final executable.

3. Ground-Zero Beginner Practice Exercises & Solutions

Exercise 1.1: What is the size in bytes of 64 bits of data? How many different decimal values can be represented by 1 Byte?

View Solution

64 bits ÷ 8 bits/byte = 8 Bytes.
1 Byte has 8 bits, meaning 2⁸ = 256 distinct values (0 to 255 if unsigned, or -128 to +127 if signed).

Exercise 1.2: Which memory segment in a C program holds local variables created inside functions?

View Solution

The Stack Segment. Local variables are automatically pushed onto stack frames when a function is entered and popped off when the function returns.

Module 01: Computer Architecture & How C Works Under The Hood

What is a Computer & How Does It Think?

Von Neumann Architecture & The Memory Hierarchy

How C Code Turns into Machine Executable Binary

Virtual Memory Layout of a Running C Program

1. Detailed Ground Zero: Bits, Bytes, and Semiconductor Memory

2. Step-by-Step Deep Dive into the GCC 4-Stage Compilation Pipeline

Stage 1: Preprocessor (gcc -E main.c -o main.i)

Stage 2: Compilation to Assembly (gcc -S main.i -o main.s)

Stage 3: Assembly to Relocatable Object (gcc -c main.s -o main.o)

Stage 4: Linking (gcc main.o -o main)

3. Ground-Zero Beginner Practice Exercises & Solutions

Stage 1: Preprocessor (`gcc -E main.c -o main.i`)

Stage 2: Compilation to Assembly (`gcc -S main.i -o main.s`)

Stage 3: Assembly to Relocatable Object (`gcc -c main.s -o main.o`)

Stage 4: Linking (`gcc main.o -o main`)