Study guide — what to focus on

This module is curated — the teaching is a top free course (linked in the card above); our job is to point you at the right things, make you understand them, and certify you. It builds on the fundamentals module: here we move up a level, from a single CPU to the application processor and the System-on-Chip (SoC) it lives in.

The plan

1. Watch the course (the card above). You don't need to memorise it — aim to understand the ideas below. It's long and thorough; you can audit every video for free.
2. Focus on these — they're what the check tests and what you'll actually reason about:
   • What a SoC integrates — CPU cores, memory controllers, GPU, and peripherals on one chip, wired together on-chip.
   • MCU vs. MPU — a microcontroller runs bare-metal/RTOS from its own flash; an application processor (e.g. an ARM Cortex-A) runs a full OS from external DRAM.
   • Cache & the memory hierarchy — L1/L2 caches, and cache hit vs. miss — small-and-fast closest to the core, large-and-slow further out.
   • Pipelining — overlapping instruction stages to raise throughput (and why hazards limit it).
   • Virtual memory & the MMU — translating virtual → physical addresses (page tables, TLB) and protecting processes from each other.
   • On-chip buses — AMBA/AXI, the interconnect standard that lets blocks inside the chip talk to each other.
   • DMA & interrupts — how peripherals move data and signal the CPU without burning cycles.
3. Go deeper on a real SoC (next section) — explore a live Arm system in an emulator and read a real block diagram, no hardware needed.
4. Take the K-Check to earn your certificate.

Why this matters

The fundamentals course taught you a processor; this one teaches you the processor you actually design around. Every phone, Raspberry Pi, and smart device is an application processor sitting in a SoC — and the reasons it feels fast (caches, pipelining) or can run Linux at all (the MMU and virtual memory) are exactly these ideas. Knowing what a SoC integrates, and how its blocks talk over AMBA/AXI with DMA and interrupts, lets you read a datasheet or block diagram and understand why a part is specced the way it is — the vocabulary you need to choose the right brains for a build instead of guessing.

The best way to make this concrete is to look inside a real system, and you can do that free with no hardware. Install QEMU, the open-source machine emulator, and boot a small Arm/AArch64 Linux image (for example qemu-system-aarch64 with the virt machine) — you'll be running a real application processor and OS in software, and QEMU can even show you the emulated peripherals and memory map. As it boots, watch the kernel log: it lists CPU cores, cache levels, the memory layout, and the on-chip devices — the exact SoC pieces this module names.

Then pair that with a real block diagram: pull up a free datasheet or technical reference for a well-known SoC (the Raspberry Pi's Broadcom SoC or an Arm Cortex-A core's TRM are good, freely available choices) and trace how the Cortex-A cores connect through the AMBA/AXI interconnect to the memory controller and peripherals, and where the caches, MMU, DMA, and interrupt controller sit. Seeing the same L1/L2, MMU, and AXI labels on a real diagram — and in a booting emulator — is what turns the vocabulary into a mental model you can actually use.