At its heart, a computer isn’t just a random collection of parts like a CPU, memory, and a keyboard. It's a system designed according to a specific plan, or architecture. This blueprint dictates how all the components work together to turn instructions into actions. The most influential of these blueprints is the stored-program concept, which treats instructions the same way it treats data, storing both in memory.

This idea, primarily credited to John von Neumann, led to the Von Neumann architecture. Think of it like a cookbook where the recipes (instructions) and the list of ingredients (data) are written on the same pages in the same book. The chef (the CPU) has to go to this single book to read the next step of the recipe, then go back to the same book to check an ingredient quantity. This unified approach simplifies the design but has a key limitation.

Because the CPU can't read an instruction and read data at the exact same moment—it has to use the same pathway for both—a traffic jam occurs. This is famously known as the Von Neumann bottleneck and it fundamentally limits the speed of the system to the bandwidth of that single connection to memory.

An alternative approach is the Harvard architecture. Instead of one shared memory space, it uses two completely separate memories: one for instructions and one for data. Each memory has its own dedicated pathway, or bus, to the CPU.

Returning to our cookbook analogy, this is like having the recipe book in one hand and the ingredients list in the other. You can read a step from the recipe and grab an ingredient simultaneously. This parallel access can make the system much faster for certain tasks. This design is very common in specialized devices like microcontrollers and digital signal processors where speed and efficiency for a specific set of tasks are critical.

While most modern PCs use a Von Neumann architecture at their core, they often incorporate aspects of the Harvard design within the CPU itself. For instance, modern processors have separate internal caches for instructions and data, which is a Harvard-like feature used to speed things up and relieve the Von Neumann bottleneck.

The pathways connecting the CPU, memory, and other components are collectively known as the system bus. It's not a single wire, but a set of parallel electrical pathways. It's best understood as three distinct buses working in concert.

When the CPU needs to fetch an instruction from RAM, it places the memory address of that instruction onto the address bus. Then, the control bus sends a "memory read" signal. In response, the memory module retrieves the instruction and places it onto the data bus, where the CPU can access it. This tightly choreographed dance happens billions of times per second.

The Central Processing Unit (CPU) is the brain of the operation, but it's not a single entity. It's composed of several key subsystems, with two being the most critical.

The Control Unit (CU) is the director. It doesn't perform calculations itself. Instead, it fetches instructions from memory, decodes them, and then directs the other parts of the computer system to execute them. It tells the ALU what to do, which memory to access, and how to route the results.

The Arithmetic Logic Unit (ALU) is the calculator. This is where the actual computation happens. It performs all arithmetic operations (addition, subtraction, multiplication) and all logic operations (like AND, OR, and NOT). When an instruction requires a calculation, the CU passes the required data to the ALU, which processes it and sends back the result.

Understanding this fundamental architecture is the first step in seeing how software commands are translated into physical actions by the hardware.