SOLID STATE PRESS
← Back to catalog
CPU and Memory Fundamentals cover
Coming soon
Coming soon to Amazon
This title is in our publishing queue.
Browse available titles
Computer Science

CPU and Memory Fundamentals

Fetch-Decode-Execute, the Memory Hierarchy, and How the ALU Runs Machine Code — A TLDR Primer

Your CS class just hit processors and memory, and suddenly the lecture slides are full of registers, bus widths, and cache misses — and none of it is clicking. This guide cuts through the noise.

**TLDR: CPU and Memory Fundamentals** is a focused, 20-page primer that walks you through exactly what a processor does, one instruction at a time. Starting from the parts inside a chip, it traces the fetch-decode-execute cycle step by step with worked examples, then explains how main memory is organized, what a memory address actually is, and how data travels between RAM and the CPU. From there it covers the memory hierarchy — registers, cache, RAM, and disk — and shows why caching works. The final sections teach enough assembly-style notation to read simple code traces and connect all of it to real-world performance topics like pipelining and modern multicore chips.

This book is for high school students taking AP Computer Science Principles or an intro CS elective, college freshmen in CS 101 or a computer organization course, and parents or tutors who need a fast, honest explanation of how processors actually work. If you've searched for a **computer architecture study guide for high school** or a plain-English take on the **fetch-decode-execute cycle**, this is what you were looking for.

No prerequisites beyond basic algebra. No filler. Just the concepts you need, explained clearly, so you can walk into your next exam with confidence.

Pick it up, read it in one sitting, and know your CPU.

What you'll learn
  • Describe the parts of a CPU (ALU, registers, control unit) and what each does
  • Walk through the fetch-decode-execute cycle with a concrete instruction example
  • Explain the memory hierarchy and why caches make programs faster
  • Read and reason about a few simple assembly-style instructions
  • Connect CPU and memory behavior to the performance of real programs
What's inside
  1. 1. What a CPU Is and What Lives Inside It
    Introduces the CPU as an instruction-executing machine and names its core internal parts.
  2. 2. The Fetch-Decode-Execute Cycle
    Walks through how a CPU runs a single instruction from memory, step by step, with a worked example.
  3. 3. Memory: RAM, Addresses, and the Bus
    Explains how main memory is organized, how the CPU reads and writes it, and what an address actually is.
  4. 4. The Memory Hierarchy and Caching
    Shows why memory comes in layers — registers, cache, RAM, disk — and how locality makes caches work.
  5. 5. Reading Simple Assembly
    Teaches enough assembly-style notation to trace what a CPU does for a small high-level snippet.
  6. 6. Why This Matters: Performance, Pipelines, and What's Next
    Connects CPU/memory fundamentals to real program speed and previews pipelining, parallelism, and modern chips.
Published by Solid State Press
CPU and Memory Fundamentals cover
TLDR STUDY GUIDES

CPU and Memory Fundamentals

Fetch-Decode-Execute, the Memory Hierarchy, and How the ALU Runs Machine Code — A TLDR Primer
Solid State Press

CPU and Memory Fundamentals

Fetch-Decode-Execute, the Memory Hierarchy, and How the ALU Runs Machine Code — A TLDR Primer

Copyright © 2026 Solid State Press.

Published by Solid State Press.

All rights reserved. No part of this book may be reproduced or transmitted in any form without prior written permission, except for brief quotations in critical reviews and educational use.

Part of the TLDR Study Guides series.

Contents

  1. 1 What a CPU Is and What Lives Inside It
  2. 2 The Fetch-Decode-Execute Cycle
  3. 3 Memory: RAM, Addresses, and the Bus
  4. 4 The Memory Hierarchy and Caching
  5. 5 Reading Simple Assembly
  6. 6 Why This Matters: Performance, Pipelines, and What's Next
Chapter 1

What a CPU Is and What Lives Inside It

Every program you have ever run — a game, a browser, a script — ultimately boils down to a sequence of tiny, rigid commands executed one after another by a single chip. That chip is the CPU (Central Processing Unit), and its entire job is to read instructions from memory, figure out what each one means, and carry it out. Everything else in your computer — the screen, the keyboard, the storage drive — exists to support that loop.

To understand how the CPU does this, you need to know what lives inside it. There are four main components worth naming now: the control unit, the ALU, the registers, and the clock. Each one has a specific, narrow job.

The Control Unit

The control unit is the manager. It does not do any arithmetic itself; instead it reads each instruction and tells every other part of the chip what to do in response. Think of it as a conductor reading sheet music and cueing the orchestra. When an instruction says "add these two numbers," the control unit sees that, activates the right circuitry, and makes sure the result ends up in the right place. You will see this in more detail in Section 2, when we trace the fetch-decode-execute cycle step by step.

The ALU

The ALU (Arithmetic Logic Unit) is where computation actually happens. It handles two categories of work: arithmetic (addition, subtraction, multiplication) and logic (comparisons like "is A greater than B?", and bitwise operations like AND and OR). If the control unit is the conductor, the ALU is the section of the orchestra that actually makes sound. Everything a program does — looping, branching, calculating — eventually reaches the ALU as one of these simple operations.

A common mistake is to think the ALU handles all of the CPU's "thinking." It does not. The ALU only does the arithmetic and comparisons. The control unit handles interpretation of instructions, and the memory system handles storage. The ALU is powerful precisely because it is narrow.

Registers

Registers are the CPU's own tiny storage slots — the fastest memory in the entire computer, built directly into the chip. A modern CPU has somewhere between 16 and a few hundred registers, each holding one small chunk of data (often 64 bits on a modern processor). When the ALU adds two numbers, those numbers have to be sitting in registers first; it cannot reach out to main memory mid-calculation.

About This Book

If you're a high school student working through a computer science course and wondering how a CPU actually works for beginners, this book is for you. It's also for college freshmen in CS 101 or a digital systems course, students prepping for the AP Computer Science Principles exam, and anyone who has stared at a diagram of a processor and felt completely lost.

This is a computer architecture study guide aimed at the high school and early college level. It covers the fetch-decode-execute cycle explained simply, how RAM and the CPU communicate, the memory hierarchy and caching explained with real numbers, and a gentle intro to assembly language for students who have never read machine-level code. Think of it as a computer science fundamentals primer for college and advanced high school — about 15 focused pages, no filler.

Read it straight through once, then work the examples as you go. When you finish, hit the problem set at the end to find the gaps before your exam does.

Keep reading

You've read the first half of Chapter 1. The complete book covers 6 chapters in roughly fifteen pages — readable in one sitting.

Coming soon to Amazon