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 practise it, and certify you.

The plan

1. Work through the course (the card above — Bootlin's Yocto materials: slides plus hands-on labs). You don't need to memorise every recipe — aim to understand the ideas below.
2. Focus on these — they're what the check tests and what you'll use for real:
   • Yocto vs Buildroot — a layered, recipe-based system that builds a whole custom distribution vs. a simpler menuconfig-driven image builder. Know when each fits.
   • BitBake, layers, recipes — BitBake is the build engine; a recipe (.bb) says how to fetch/build/package one component; a layer (meta-*) groups recipes and config and is enabled in bblayers.conf.
   • Device tree — a .dts (compiled to .dtb) that describes non-discoverable hardware to the kernel; the compatible property is what binds a node to its driver.
   • What a BSP provides — the board-specific pieces to boot Linux: bootloader (U-Boot) config, kernel + device tree, and machine config.
   • Kernel module vs built-in — a loadable .ko loaded at runtime vs. code compiled into the kernel image.
   • The boot flow — ROM → U-Boot → kernel + DTB → mount rootfs → init.
   • Cross-toolchain & sysroot, rootfs images — building on the host for the target, and choosing an image/rootfs type.
3. Practise it (next section) — actually build and boot an embedded Linux image, on emulated or real hardware.
4. Take the K-Check to earn your certificate.

Why this connects to building real products

The fundamentals module gave you an embedded Linux running; this one is how you ship one. When a product needs a filesystem, networking, and updatable software on a real SoC, you don't hand-assemble it — you describe it in layers and recipes, bring the board up with a device tree and a BSP, and let the build system produce a reproducible image. Understanding that pipeline is what lets you turn a bare board into a maintainable product — and read why a given board's software stack is put together the way it is.

Time to actually build and boot one. Embedded Linux/BSP work lives outside Forge, so practise it with real tools — and the good news is you can do the whole loop for free without buying a board.

The easiest free option is QEMU, which emulates a full ARM machine on your laptop. Both Yocto and Buildroot ship a qemuarm (or qemuarm64) target, so you can build an image and boot it in software with a single runqemu (Yocto) or qemu (Buildroot) command — no hardware, no risk of bricking anything. If you have a Raspberry Pi lying around, use that instead: both build systems have first-class Pi machine configs, and booting your own image off an SD card is the most satisfying way to see a BSP work.

A good first exercise: build the minimal core-image-minimal for qemuarm with Yocto (or the default qemu_arm defconfig with Buildroot), boot it in QEMU, and log in. Then make one change — add a package (say dropbear or nano) via your own small layer/recipe or the config menu, rebuild, and confirm it's present on the booted target. That single edit-build-boot loop is the core skill this whole module is about.