Study guide — what to focus on

This module is curated — the teaching is a top free video series (linked in the card above); our job is to point you at the right things, give you a free way to practise them, and certify you.

The plan

1. Watch the series (the card above). You don't need to memorise every command — aim to understand the ideas below.
2. Focus on these — they're what the check tests and what you'll actually use:
   • The shell and filesystem — moving around with cd / pwd / ls, the single tree rooted at /, and reading permissions like rwxr-xr-x.
   • Cross-compilation — building on a fast host to produce binaries for a different target CPU, and what a toolchain prefix like arm-linux-gnueabihf-gcc is telling you.
   • The boot chain — bootloader (U-Boot) → kernel → root filesystem — and what each stage is responsible for.
   • The device tree — how the kernel is told about the hardware so one kernel can run on many boards.
   • Build systems — Buildroot (simple, single-config, great to start) vs the Yocto Project (more powerful, more complex).
   • Kernel vs user space — the privileged core that owns the hardware vs the isolated apps that call into it.
3. Practise on real Linux (next section) — a free, no-cost way to get your hands dirty.
4. Take the K-Check to earn your certificate.

Why this matters

Embedded Linux is what runs the moment a product outgrows a bare microcontroller — anything with a screen, a network stack, a filesystem, or real multitasking (routers, cameras, kiosks, single-board computers). The fundamentals here are the vocabulary of that world: knowing that the bootloader loads the kernel, that the kernel reads a device tree to learn the board, that your code is cross-compiled on a host and shipped to the target, and that a build system stitches a whole image together. Get comfortable with these and the rest of embedded Linux — drivers, BSPs, custom distros — stops looking like magic and starts looking like layers you can reason about.

The fastest way to make these fundamentals stick is to use a Linux shell, and you can do that free with nothing to install. Open a browser-based Linux terminal such as DistroSea or JSLinux — both boot a real Linux system in your browser — or, if you have the hardware, flash Raspberry Pi OS onto a Raspberry Pi with the free Raspberry Pi Imager for the genuine single-board-computer experience.

For a first exercise, live entirely in the shell: run pwd and ls -l to see where you are and read the permission strings (rwxr-xr-x), then mkdir practice && cd practice, create a file with touch hello.txt, and change its permissions with chmod +x hello.txt — watch the ls -l output change. Next, run uname -a and cat /proc/cpuinfo to see the kernel and the CPU architecture you're on, which is exactly the "target" a cross-compiler would build for. That loop — type a command, read what it did, connect it to a concept from the videos — is how real embedded Linux work begins, just scaled down.