Document under review: _posts/2021-08-09-must-know-low-level.md Date: 2026-02-24

A. Similar “Must Know” Lists and Curricula

Question-based formats

  • Nigel Jones, “A ‘C’ Test: The 0x10 Best Questions for Would-be Embedded Programmers”: The closest precedent. 16 questions covering volatile, static, const, bit manipulation, interrupts/ISRs, integer promotion, and fixed-address memory access. Unlike the blog post, Jones provides answers — but the assessment philosophy is similar: questions reveal depth of understanding. Originally published in Embedded Systems Programming magazine (~2000).
    • https://rmbconsulting.us/publications/a-c-test-the-0x10-best-questions-for-would-be-embedded-programmers/
  • Wind River, “Job Interview Questions for Embedded Systems Developers”: ~38 questions in four categories: domain expertise (RTOS, Yocto, JTAG), coding (packed structures, endianness, bitwise ops), nomenclature (heap/stack, process/thread, volatile/static), and process (debugging methodology, collaboration). Significant topic overlap with the blog post.
    • https://www.windriver.com/blog/Internal-Job-Interview-Questions-for-Embedded-Systems-Developers

Tutorials and handbooks

  • freeCodeCamp, “Learn Embedded Systems Firmware Basics — A Handbook for Developers” (2024): 8 sections covering microcontroller architecture, firmware design, bare-metal/RTOS/embedded Linux, driver design, security, debugging/forensics, and testing. Uses ARM Cortex-M examples throughout. Answers-first tutorial format.
    • https://www.freecodecamp.org/news/learn-embedded-systems-firmware-basics-handbook-for-devs/
  • Memfault Interrupt Blog, “From Zero to main()” series: What happens between power-on and main(): reset vector, linker scripts, BSS/data section setup, bootloader development, C runtime bootstrapping. Directly addresses the blog post’s “who put it there” questions with deep worked examples.
    • https://interrupt.memfault.com/blog/zero-to-main-1
  • Dojo Five, “The Ultimate Guide to Modern Embedded Firmware Development” (2024/2025): Modern practices including TDD, CI/CD, static analysis, and modern toolchains.
    • https://dojofive.com/the-ultimate-guide-to-modern-embedded-firmware-development/

Comprehensive roadmaps

  • m3y54m/Embedded-Engineering-Roadmap (GitHub, 7k+ stars): The most comprehensive public roadmap for embedded engineers. Covers programming languages, microcontroller peripherals (GPIO, ADC/DAC, timers, PWM, RTC, watchdog, interrupts, DMA, clock management, power management, bootloader/DFU), communication protocols, RTOS, embedded Linux, testing, security, and advanced topics. Built from actual job posting analysis.
    • https://github.com/m3y54m/Embedded-Engineering-Roadmap
  • Embedded Artistry, Field Atlas / Embedded Education Roadmap: Curated guide covering embedded systems, software engineering, electrical engineering, product development, and career management.
    • https://embeddedartistry.com/beginners/

University curricula

  • CMU 18-348, Embedded System Engineering (Phil Koopman): 25 lectures: instruction sets, memory/buses/optimization, serial ports, timers, watchdog timers, interrupts, context switching, concurrency/scheduling, analog/digital I/O, control systems, checksums/CRCs, embedded networks. Freely available lecture materials.
    • https://users.ece.cmu.edu/~koopman/lectures/index.html
  • CMU 18-642, Embedded Software Engineering (Koopman): Code quality, safety, and security: peer reviews, requirements, testing, architecture, statecharts, safety engineering (FMEA/FTA/HAZOP), dependability, cryptography.
    • https://course.ece.cmu.edu/~ece642/
  • ARM Education, “Embedded Systems Essentials with Arm” Professional Certificate (edX): Digital/analog I/O, interrupts, low power features, timers, PWM, RTOS, serial communication for Cortex-M.
    • https://www.edx.org/certificates/professional-certificate/armeducationx-embedded-systems-essentials

B. Mental Model Approaches to Embedded Education

  • Pyjama Cafe: The closest match to the blog post’s philosophy. Explicitly teaches embedded systems through building mental models of CPU, memory, state machines, and scheduling. The “Programmer’s Model” is a core concept. Designed to “arm software engineers with the insights and imagination around how hardware operates” so they can “reason better and write clean software.”
    • https://pyjamacafe.com/courses/
  • Elecia White, “Making Embedded Systems” (2nd ed., 2024): Design-pattern oriented, which is inherently a mental-model approach. Chapters on system architecture, I/O, interrupts, managing flow of activity, optimization, and power consumption. The 2nd edition adds IoT, motors/movement, debugging, and data handling.
    • https://www.oreilly.com/library/view/making-embedded-systems/9781098151539/
  • Jack Ganssle, “The Art of Designing Embedded Systems” (2nd ed.): Explicitly anecdotal and philosophical. Presents “an overarching philosophy of development as a high-level strategic plan of attack.” Covers partitioning, scheduling, firmware standards, code inspections, design by contract, encapsulation, and real-time concerns.
    • https://www.amazon.com/Art-Designing-Embedded-Systems/dp/0750686448
  • Michael Barr & Anthony Massa, “Programming Embedded Systems” (2nd ed., 2006): Structured progression: hardware understanding → compiling/linking/locating → memory → peripherals → interrupts → operating systems → optimization. The compiling/linking/locating chapter directly addresses “where is the stack, who put it there.”
    • https://www.oreilly.com/library/view/programming-embedded-systems/0596009836/

C. Coverage Comparison

Strengths (relative to industry consensus)

Topic Blog post coverage Comparable resources
MMIO register hazards Deep: bus width mismatches, read-modify-write, set/clear views, register modes Rarely covered at this level in “must know” lists
Interrupts / critical sections Two-part hardware/software split; tail chaining, nesting depth, critical section duration Deeper than most interview guides
Low power / clock gating WFI wake-while-disabled, clock gating control, oscillator startup ARM education certificate covers this; rarely at this detail
Analog interfaces “Flash is analog,” comparator initialization edges, setup/hold times Distinctive — other lists rarely cover this
Hardware-software boundary focus Tight scope on firmware-hardware interaction Most lists mix in software engineering practices

Gaps (topics consistently covered elsewhere but absent)

Missing topic Why it matters Where covered
DMA (Direct Memory Access) Cache coherency, buffer alignment, peripheral interaction m3y54m roadmap, CMU 18-348, freeCodeCamp handbook
Bootloaders / startup sequence Reset vector → clock init → BSS zeroing → C runtime → main Memfault “Zero to main()”, Barr/Massa Ch.3
Watchdog timers Last-resort recovery from firmware hangs CMU 18-348, Memfault, m3y54m roadmap
Endianness Protocol parsing, register access, cross-system data exchange Every embedded interview list
Linker scripts / memory sections .text, .data, .bss, .rodata, scatter-loading Memfault, Barr/Massa, freeCodeCamp
Debugging tools (JTAG/SWD) Knowing how to investigate is part of the mental model freeCodeCamp, CMU 18-348, Wind River
Compiler optimisation effects Beyond volatile: reordering, dead code elimination, -O0 vs -O2 in ISRs Barr Group materials, Nigel Jones
Cache coherency DMA + cache interactions, especially Cortex-M7 and Cortex-A STM32 community, ARM education
Memory protection units (MPU) Security, TrustZone, fault isolation ARM education, m3y54m roadmap

The blog post explicitly excludes RTOS internals and communication protocols (UART/I2C/SPI/USB), which is a defensible scoping decision stated in the “What About RTOSs?” section. The gaps listed above fall within the post’s stated scope of “hardware-software boundary mental model.”

D. The Question-Based Format

Pedagogical grounding

The blog post’s questions-without-answers format is pedagogically sound:

  • Socratic method: “We focus on giving students questions, not answers. The answers to questions are not a stopping point for thought but instead a beginning to further analysis and research.” The blog post’s questions prompt investigation of the reader’s own platform.
    • https://teaching.pitt.edu/resources/teaching-through-questioning-socratic-no-more/
  • Inquiry-based learning: Open-ended questions “generate more student participation than narrow questions” and are perceived as “less threatening.” The format maps to the first three steps of inquiry: engaging in a question, providing evidence, and formulating explanations.
    • https://resilienteducator.com/classroom-resources/what-is-inquiry-based-learning/
  • Self-directed learning: The format aligns with the self-directed model: identify learning needs → determine goals → find resources → direct study. The questions serve as the “identify learning needs” step.
    • https://www.asme.org/topics-resources/content/engineers-are-using-self-directed-learning-to-take-control-of-their-careers

Uniqueness

No other embedded systems resource found uses pure questions-without-answers. Nigel Jones’s “C Test” is the closest precedent but provides answers. The m3y54m roadmap uses a checklist format. Curricula and handbooks are answers-first. The blog post’s format is a genuine differentiator in the embedded education space.

E. The Blog Post’s Position in the Landscape

The blog post occupies a specific niche:

  1. Question-only format: Unique among embedded education resources. Functions as a self-assessment and learning-prompt tool.

  2. Hardware-interaction focus: Stays tightly scoped to the firmware-hardware boundary. Most “must know” lists mix hardware concepts with software engineering practices (testing, RTOS, coding standards, version control).

  3. Experience-encoded questions: Questions like “What do you mean WFI is woken while interrupts are disabled?” and “Flash memory is an analog circuit!?” encode specific debugging lessons. This is closer to Ganssle’s anecdotal style than a structured curriculum.

  4. Mental model philosophy: Explicitly named and positioned. The closest parallel is Pyjama Cafe’s “Programmer’s Model” approach, though the blog post is more concise and question-driven.

The main structural gap is that the post’s scope is implicit — a reader might expect RTOS, protocols, or debugging topics before reaching the “What About RTOSs?” section. Making the scope explicit earlier (e.g. “this list focuses on the hardware-software boundary”) would set expectations.

F. Key References

Books

Book Author(s) Year
Making Embedded Systems (2nd ed.) Elecia White 2024
The Art of Designing Embedded Systems (2nd ed.) Jack Ganssle 2008
Programming Embedded Systems (2nd ed.) Barr & Massa 2006

Online resources

  • Embedded Artistry: https://embeddedartistry.com/beginners/
  • Memfault Interrupt Blog: https://interrupt.memfault.com/
  • Barr Group: https://barrgroup.com/embedded-systems/books
  • Phil Koopman CMU lectures: https://users.ece.cmu.edu/~koopman/lectures/index.html
  • Pyjama Cafe: https://pyjamacafe.com/courses/
  • m3y54m Roadmap: https://github.com/m3y54m/Embedded-Engineering-Roadmap

Summary

The blog post occupies a genuine gap: a question-only, hardware-boundary-focused mental model builder for firmware developers. The format is pedagogically grounded (Socratic/inquiry-based) and unique in the embedded education space. The strongest sections — MMIO register hazards, interrupt/critical section depth, analog interface gotchas — cover ground that even comprehensive curricula skip. The main gaps within its stated scope are DMA, watchdog timers, bootloader/startup sequence, endianness, and linker scripts. The closest comparable resources are Nigel Jones’s “C Test” (question format, narrower scope), Pyjama Cafe (mental model philosophy, different format), and Ganssle’s book (experience-driven, broader scope).