Book Review: Practical Debugging for Embedded ARM Systems

Debugging embedded systems is one of the most expensive activities in software development, yet it rarely appears as an explicit line item in a project budget.

It’s not uncommon for development teams to spend 20-40% of their time debugging. If an embedded engineer earns roughly $129,000 per year and spends 40% of their time debugging, more than $50,000 of that salary is tied up in debugging activities alone. Add benefits, payroll taxes, equipment, and overhead, and the actual cost to the business is considerably higher.

Of course, debugging can’t be eliminated. Good architecture, coding standards, static analysis, code reviews, and automated testing can prevent many defects from reaching the debugger, but some bugs will always get through.

When they do, developers need to know how to find them efficiently.

That’s where Nino Vidović’s Practical Debugging for Embedded ARM Systems: Core Techniques for Tracing, Profiling, and Fixing System-Level Faults comes in, and it is the subject of this Practical Debugging book review.

Before diving into the details, here’s the general information about the book:

Field	Details
Author	Nino Vidović
Published	April 2026
Publisher	Packt
Target Audience	Entry-level Engineers (Yes, I disagree with Packt’s description)
Jacob’s Rating	3.8 / 5 Stars
Book Link	Amazon.com

The Good

The most important thing to understand about this book is right there in the title: Practical Debugging.

Nino does a good job taking developers from the fundamentals of embedded debugging through the core techniques needed to diagnose real problems on ARM-based systems.

If you’ve used a debugger primarily by clicking the “Debug” button in your IDE, setting a breakpoint, and stepping through some code, there’s quite a bit in this Practical Debugging book review to help you better understand what is actually happening underneath those buttons.

For example, the book walks through debug states, disassembly, debug symbols, and how the debugger connects what’s happening inside the processor back to the source code you’re looking at on your screen.

Those are important concepts that developers often use every day without really understanding how they work.

The book also spends considerable time on tracing and profiling techniques. I particularly enjoyed the discussion around ITM and ETM. These are powerful capabilities available on many ARM systems, but I still find that they are underutilized by embedded development teams.

Nino also does a great job discussing printf debugging.

Most embedded developers have used printf to figure out what their system is doing. The problem is that adding a printf can change the timing of the system you’re trying to debug. Suddenly the bug disappears, moves somewhere else, or behaves differently.

The book doesn’t simply tell developers not to use printf. Instead, it explores ways that it can still be used while minimizing its impact on the real-time behavior and determinism of the system.

That’s exactly the type of practical discussion I like to see in a good debugging book.

Learn by Doing

One of the strongest aspects of the book, and a big reason it earned a positive Practical Debugging book review from me, is the hands-on material.

There is source code available that allows readers to experiment with the concepts being discussed rather than simply reading about them.

I think this is where the book really earns the word Practical in its title.

Nearly every chapter gives you something that you can take back to the debugger and try yourself. That’s important because debugging is difficult to learn purely from reading.

You can read about breakpoints, watchpoints, trace, memory faults, and profiling all day long. You don’t really understand these tools until you put a processor into a particular state, inspect what happened, and work your way backward toward the cause.

The book also walks through several common problems embedded developers encounter, including memory leaks, buffer overflows, and null pointers.

Given that most embedded systems are still written in C and C++, these remain extremely relevant problems. For an engineer early in their career, seeing how these faults manifest themselves and then learning how to track them down can be extremely valuable.

There are also plenty of diagrams, code examples, and screenshots throughout the book. The screenshots occasionally switch between monochrome and color, which feels a little inconsistent, but there are enough visuals that it’s generally easy to follow what Nino is demonstrating.

Where I Wanted More From the Practical Debugging Book

There are several places where I would have liked the book to go deeper.

That’s also where I had to catch myself while writing this Practical Debugging book review.

I was initially looking at this book through the lens of, “What would I put in a book about embedded debugging?” My answer would probably result in a considerably larger book covering advanced breakpoint techniques, watchpoints, automated debugging environments, build and debug containers, hardware-in-the-loop automation, and increasingly, AI-assisted debugging.

But that’s not necessarily the book Nino set out to write.

The subtitle promises core techniques for tracing, profiling, and fixing system-level faults, and I think the book delivers on that promise.

There are still areas that could make a future edition even stronger. For example, LLMs are briefly mentioned, but the book doesn’t explore how AI agents are starting to interact with debuggers, analyze logs, control hardware, and participate in hardware-in-the-loop debugging workflows.

Those capabilities are developing quickly, though, and publishing timelines make bleeding-edge topics particularly difficult to capture in a technical book.

I also would have liked to see some of the more advanced breakpoint and watch capabilities covered in greater depth.

Finally, many of the examples naturally use SEGGER resources and tools. That’s understandable given Nino’s background at SEGGER, and the underlying concepts generally transfer to other debugging environments. Still, showing a few more alternative tools would have helped readers separate the ARM debugging concepts from the particular tools being used to demonstrate them.

These aren’t reasons to avoid the book. They’re simply areas where more experienced developers may find themselves wanting additional depth from a Practical Debugging book review perspective.

The Ugly

My biggest frustration with the book actually has very little to do with Nino’s technical content. It’s the publisher’s presence throughout the book.

Packt repeatedly promotes its learning platform, and at times I found the promotion distracting. The final chapter, in particular, feels less like another chapter of Practical Debugging for Embedded ARM Systems and more like an encouragement to continue onto the publisher’s platform.

I understand the business side of this. Publishers need to sell books, subscriptions, and other products. I’ve certainly been known to “occasionally” promote my own work. As one of my mentors likes to say, “If you don’t blow your own horn, who will?”

Still, when I buy a technical book, I want the pages to be focused primarily on teaching the subject.

I would have preferred less promotion and more room for Nino to expand on some of the debugging topics.

That’s unfortunate because the technical material that is here is good.

Final Recommendation From This Practical Debugging Book Review

If you’re new to embedded systems, or you’ve been developing firmware for a few years but never really learned how the debugger works underneath the IDE, I recommend Practical Debugging for Embedded ARM Systems.

Nino does a good job covering the fundamentals while giving readers opportunities to actually apply what they’re learning. I particularly enjoyed the material around processor startup, tracing, profiling, debug symbols, and technologies such as ITM and ETM.

More experienced developers may wish some subjects went deeper. I certainly did.

But that’s also worth putting into perspective.

This isn’t trying to be a 1,000-page encyclopedia of every embedded debugging technique available today. It’s a practical guide to the core techniques developers need to trace, profile, and debug ARM-based embedded systems.

At that, I think Nino succeeds.

If you’re early in your embedded career and want to become more effective with the debugging tools already sitting on your desk, this Practical Debugging book review recommends keeping Practical Debugging for Embedded ARM Systems on your shelf. You can find it on Amazon here.

---

Want embedded engineering insights like this delivered to your inbox? Sign up for my Embedded Bytes newsletter to get the latest posts, insights, and hands-on tips delivered straight to your inbox.