Fundamentals of Computer Architecture: CPU, Memory, and Storage Hierarchy

The article begins by introducing the concept of computers as machines that execute instructions on data, tracing the idea back to von Neumann's 1945 model and emphasizing that all modern devices—from Mars rovers to smartphones—follow the same fundamental principles.

It then describes the two core components of a computer: the processor (CPU) and memory (RAM). Memory is organized into addressable cells, each holding a byte, and binary signals on data and address buses represent the bits.

Binary numbers are explained as the basis for all computer operations, with examples of how high and low voltage represent 1 and 0 on signal lines.

The CPU fetches, decodes, and executes instructions in a repeatable cycle using a program counter (PC). Typical operations include moving data between registers and memory, arithmetic, and conditional jumps, illustrated by a simple pseudo‑code example:

if x = 0
    compute_this()
else
    compute_that()

Instruction sets map high‑level operations to numeric codes stored in RAM, and the article notes that modern CPUs have extensive instruction sets, yet the essential ones have existed for decades.

Cache memory is introduced as fast, small storage inside the CPU. Level‑1 cache (≈10 KB) can serve most accesses in about 10 CPU cycles, while Level‑2 (≈200 KB) and Level‑3 caches provide larger capacity at slightly higher latency, dramatically reducing the need to access slower RAM.

Memory hierarchy is further detailed: registers < 1 KB, L1/L2/L3 caches, RAM (1 GB–10 GB), secondary storage (hard disks or SSDs), and tertiary storage (tapes, optical media). The performance gap between CPU and RAM is highlighted, along with concepts of temporal and spatial locality that guide caching strategies.

Compilers translate high‑level language code into machine instructions. The article uses factorial examples to show how recursive code can be optimized into iterative form, and how compilers eliminate redundant calculations:

function factorial(n)
    if n > 1
        return factorial(n - 1) * n
    else
        return 1

function factorial(n)
    result ← 1
    while n > 1
        result ← result * n
        n ← n - 1
    return result

i ← x + y + 1
j ← x + y

t1 ← x + y
i ← t1 + 1
j ← t1

Script languages (e.g., JavaScript, Python, Ruby) are interpreted at runtime, offering rapid development at the cost of slower execution compared to compiled code; large projects may suffer long compile times, prompting the creation of fast‑compiling languages like Go.

The article also touches on reverse engineering and disassembly, explaining how binary programs can be decoded back into human‑readable instructions, a technique used both by security researchers and malicious actors.

Open‑source software is presented as a model where source code is publicly available, enabling community scrutiny for security vulnerabilities and fostering collaborative development, contrasting with closed‑source operating systems.

Finally, the piece summarizes that understanding and optimizing the memory hierarchy—leveraging caches, locality, and appropriate storage technologies—is essential for improving overall system performance.