Tenderfoot: Recommended Reading
Twenty years on, these are the books that turned an electrical engineer into an embedded software pro. Matthew Eshleman walks through influential reads from Code Complete to Practical Statecharts and Test Driven Development, explaining how each shaped his design, estimation, and testing practices. This short list is a practical starting point for 'tenderfoots' launching an embedded firmware career.
Embedded Toolbox: Programmer's Calculator
A tiny but powerful cross-platform tool, QCalc evaluates full C-syntax expressions so you can paste results straight into firmware. It handles bitwise ops, mixed hex/decimal/binary constants, and scientific math, and it automatically shows integer results in formatted hex and binary. The post explains key features, variable handling, error messages, and how to run qcalc.tcl with the wish Tk interpreter.
Tenderfoot: Introduction to Magic (Numbers that is...)
A source-code review revealed repeated numeric literals in C, exposing the classic problem of magic numbers in embedded software. This post explains what magic numbers are, why they are especially painful in firmware, and simple fixes using named constants and comments tied to specs. Read this if you want clearer, safer embedded C code and fewer surprises during maintenance.
Donald Knuth Is the Root of All Premature Optimization
Knuth's famous line "premature optimization is the root of all evil" has turned into a blunt rule on forums, Jason Sachs argues, and that overuse masks important nuance. He walks through concrete embedded examples, from dsPIC33E floating-point timings to an ROI analysis in the Kittens Game and a continuous optimization toy problem, to show when to measure, when to speculate, and why profilers can mislead.
Zebras Hate You For No Reason: Why Amdahl's Law is Misleading in a World of Cats (And Maybe in Ours Too)
Amdahl’s Law is a useful warning, but Jason Sachs argues it can be misleading if you stop at the equation. Using the Kittens Game as a playful model, he shows how Gustafson’s perspective, positive feedback loops, and system-level synergy can turn modest component speedups into big real-world wins. The article closes with concrete embedded-systems examples like ISR timing and developer productivity.
Favorite Tools: C++11 std::array
Firmware teams that avoid malloc or new need safer alternatives, and this post makes a strong case for C++11 std::array as that alternative. It highlights zero-overhead, type-safe, compile-time buffers and points to an ESP32 LED-strip demo where NUM_PIXELS_ fixes RAM usage at build time. Read it to see std::array used with std::rotate, passed to C libraries via data(), and as a low-risk path to std::vector later.
Vala applications on Embedded Linux: maybe a clever choice [part 1]
If you need a high-level language for constrained embedded Linux devices, Vala is worth a look. It compiles to C and relies mainly on GLib, giving you native performance and minimal runtime dependencies. With reference counting instead of a garbage collector, modern language features, and a small storage footprint, Vala can outperform Python, Java, or Qt on low-RAM, low-storage boards. This first part focuses on dependencies, ABI compatibility, runtime characteristics, and a real-world example.
Favorite Tools: C++11 User-defined literals
Units are a frequent source of bugs in embedded software, and keeping code aligned with product specs helps prevent mistakes. This post shows how C++11 user-defined literals let you write expressive, type-safe unit values like 80_MPH and convert them to meters per second using constexpr operator"" overloads. The conversion happens at compile time, improving readability and reducing reliance on macros or magic numbers.
Surprising Linux Real Time Scheduler Behavior
An embedded Linux data acquisition project ran into puzzling UART latency whenever heavy UI animations ran. Moving all app threads to SCHED_FIFO helped but did not eliminate delays. After reading about kernel worker thread interactions, Matthew moved the UI back to the normal scheduler and the jitter vanished. The post highlights an unexpected kernel level priority inversion risk and a pragmatic workaround.
Favorite Tools - Look Up Tables
Look up tables are one of the simplest but most effective tools in an embedded engineer's toolbox, and this post shows why. Using a keypad example the author demonstrates a static table of key behaviors that packs repeat rates, enum mappings, and debug names into one place so changing behavior or adding keys is trivial. The article also outlines other uses like state machines and UI internationalization.
Assembly language is best - except when it isn’t
A look at why writing in C often produces more efficient code than hand-written assembly language.
Tenderfoot: Recommended Reading
Twenty years on, these are the books that turned an electrical engineer into an embedded software pro. Matthew Eshleman walks through influential reads from Code Complete to Practical Statecharts and Test Driven Development, explaining how each shaped his design, estimation, and testing practices. This short list is a practical starting point for 'tenderfoots' launching an embedded firmware career.
Favorite Tools - Look Up Tables
Look up tables are one of the simplest but most effective tools in an embedded engineer's toolbox, and this post shows why. Using a keypad example the author demonstrates a static table of key behaviors that packs repeat rates, enum mappings, and debug names into one place so changing behavior or adding keys is trivial. The article also outlines other uses like state machines and UI internationalization.
Surprising Linux Real Time Scheduler Behavior
An embedded Linux data acquisition project ran into puzzling UART latency whenever heavy UI animations ran. Moving all app threads to SCHED_FIFO helped but did not eliminate delays. After reading about kernel worker thread interactions, Matthew moved the UI back to the normal scheduler and the jitter vanished. The post highlights an unexpected kernel level priority inversion risk and a pragmatic workaround.
Bad Hash Functions and Other Stories: Trapped in a Cage of Irresponsibility and Garden Rakes
A tiny filename decision in MATLAB's publish() can silently swap rendered equations, and Jason Sachs shows why that matters. He reproduces the bug, walks through hash-function basics and collision math, and contrasts safe and unsafe caching strategies. The piece then broadens into practical lessons about software fringes, legacy constraints, and the usability traps that leave engineers repeatedly stumbling over avoidable design choices.
Embedded Programming Video Course Teaches RTOS
From basic foreground/background loops to priority-inheritance protocols, this free video course walks you through building and improving an RTOS step by step. Lessons cover manual context switching, round-robin and preemptive priority schedulers, efficient thread blocking, and synchronization primitives. The series finishes with a practical port to a professional RTOS in the QP/C ecosystem, showing semaphores, mutexes, and ways to prevent priority inversion.
Jaywalking Around the Compiler
Messing with inline assembly can feel powerful until the compiler silently undoes you. Jason Sachs walks through a real bug on a Microchip dsPIC33E where pushing CORCON and writing a fixed value corrupts compiler-managed state and produces wrong results when the compiler reorders code. The post shows why the stack and certain registers are off-limits to raw inline asm, and gives practical, safe patterns to save and restore mode bits.
The Hardest Bug I Never Solved
A single overlooked sentence in the STM32 datasheet turned intermittent startup resets into a major time-leach. Senior engineers chased DMA buffers and overflows for hours until Unni discovered the ISR vector table had been relocated to RAM with only 256 byte alignment while the MCU required 512 bytes. The misalignment caused interrupts to jump to the reset handler, and fixing the alignment stopped the reboot loop for good.
Embedded Programming Video Course Shows How OOP Works Under the Hood
Want to see how OOP actually maps to machine level code? This free video course walks through encapsulation, inheritance, and polymorphism with hands-on comparisons between C and C++. You will inspect C implementations, compiler-generated code, and debug traces, and learn how encapsulation relates to RTOS concurrency. The polymorphism lesson reverses the usual order to expose runtime costs and previews implementing polymorphism in C.
Hidden Gems from the Embedded Online Conference Archives - Part 2
A look back at a deep dive into the Mars Perseverance flight software from one of the technical leads at JPL.
Some Embedded System Software Design Resources
Embedded systems span many architectures and run-times, so there is no single definitive resource. This curated list brings together practical embedded-focused books by Elecia White and Jacob Beningo, general design guidance from Robert Martin, and a TDD primer by James W. Grenning, plus concrete advice on BDD-style TDD and off-target testing. Skim the list in a day, then try the techniques hands-on.
Dumb Embedded System Mistakes: Running The Wrong Code
Running the wrong firmware on a board can waste hours. This post shows a practical marking strategy for embedded Linux that embeds searchable proof-of-life strings into kernel, rootfs, overlay, and application code. It walks through choosing early-boot log points, using compile-time timestamps, and a small shell script to set, find, and clear marks so you can verify builds before flashing.
Embedded Toolbox: Windows GUI Prototyping Toolkit
You can prototype and debug complex embedded device user interfaces on Windows using the tiny, free QWin toolkit. It runs the same C code you compile for the target by implementing a Windows BSP, letting you develop UI code quickly with MinGW or Visual C++ and a visual resource editor. The result is far faster compile-run-debug cycles and a simpler path around flaky prototype hardware.
Simulating Your Embedded Project on Your Computer (Part 2)
Having a simulation of your embedded project is like having a superpower that improves the quality and pace of your development ten times over! To be useful, though, it can't take longer to develop the simulation than it takes to develop the application code and for many simulation techniques "the juice isn't worth the squeeze"! In the last article, I showed you how to use the terminal (i.e. printf/getchar) to easily make a completely functional simulation. In this article, we'll take simulation to the next level, either in terms of realism (by using virtual hardware) or in terms of user experience (by using a GUI to simulate our hardware, instead of using the terminal).
Get your microcontroller and PC to talk
Projects often need a quick PC interface for an otherwise standalone microcontroller, but learning VB or Visual C++ can feel like overkill. Jayaraman Kiruthi Vasan shows how Processing, an open source, C like environment with serial and Arduino libraries, gives embedded engineers a fast, low friction way to build GUIs and COM links to chips like the 8051 and Renesas R8C. The post promises a hands on example connecting Processing to a 8051.
Embedded Programming Video Course Teaches RTOS
From basic foreground/background loops to priority-inheritance protocols, this free video course walks you through building and improving an RTOS step by step. Lessons cover manual context switching, round-robin and preemptive priority schedulers, efficient thread blocking, and synchronization primitives. The series finishes with a practical port to a professional RTOS in the QP/C ecosystem, showing semaphores, mutexes, and ways to prevent priority inversion.
Six Software Design Tools
Software design need not be mysterious, these six practical tools give a disciplined way to shape readable, testable, and maintainable code. The post walks through naming (DAMP), duplication control (DRY), complexity metrics (MCC), SOLID principles, API layering, and test-driven development, showing how each idea applies across languages and embedded systems. Use them as checklists for code reviews and design thinking.
The volatile keyword
Although the C keyword volatile is very useful in embedded applications, care is needed to use it correctly and vigilance is required to ensure its correct implementation by compilers.
Coding Step 4 - Design
Articles in this series:
- Coding Step 0 - Development Environments
- Coding Step 1 - Hello World and Makefiles
- Coding Step 2 - Source Control
- Coding Step 3 - High-Level Requirements
- Coding Step 4 - Design
The last article in this series discussed how to write functional high-level requirements: specifications for what your software is supposed to do. Software design is the other side of the coin....
In Memoriam: Frederick P. Brooks, Jr. and The Mythical Man-Month
It is with some sadness that I have read that Fred Brooks has passed away. Brooks (1931 - 2022) worked at IBM and managed a large team developing the IBM System/360 computers in the early 1960s. Brooks was thirty years old at the start of this project. He founded the Computer Science Department at UNC Chapel Hill in 1964, at the age of thirty-three, acting as its department chair for twenty years. He remained at IBM until 1965, however. During this one-year...
