I recently talked with a colleague about a blog I had published entitled “Mastering Embedded Build Systems: Exploring the 5 Essential Configurations”, and he commented interestingly: “Embedded developers don’t need a release build”. To some degree, this makes sense. Developers often develop and test their software in a debug configuration, and they should ship what they test; However, skipping the use of a release build can have a negative consequence on a system. This post will explore five reasons you need a release build.

Reason #1 – Performance Optimizations

When you build software for debugging, the build optimization levels are often set at a lower level. When debugging, you may need to step through code or set break points to investigate what the software is doing. A lower optimization level prevents the compiler from rearranging instructions and performing other optimizations that would be confusing for a human to work through. If you deploy your debug build, you’re going to miss out on optimization that can improve the execution speed of your software and the size of your software.

A debug build should only be used if you are actively debugging your software. Builds in your CI/CD pipeline for hardware-in-loop testing, unit tests, etc., should all be done using a release build. The release build will most accurately represent the firmware you will ship, it’ll be optimized, and you’ll have tested what you ship.

Reason #2 – Memory Efficiency

Release builds can help reduce the memory footprint of your embedded software by optimizing data structures, removing unnecessary code, and applying memory-saving techniques. Memory efficiency is crucial in an embedded system where resources are often constrained. Compiling for a release build that will apply memory optimizations could potentially shrink the memory size small enough that a less expensive microcontroller could be used. Or it may make enough room for future features to be added to the product.

Reason #3 – Security Enhancements

When you build for a debug configuration, you’ll find that there is often far more information included in the build that can be used to help debug the system. For example, you might find that debug symbols are included or other details that make it easier to reverse engineer the software if someone were to pull it from flash. When you build for debugging, you’ll often find that robust security measures are kept out of the firmware to make debugging easier. The ease of the debug build may leave breadcrumbs that make hacking the system easier.

When you perform a release build, you’ll often enable additional security features like stack protection, code obfuscation, stricter warning checks, address sanitation, and other enhancements. If you skip the release build, you may include more than you need to, making it easier for an adversary to exploit your system.

Reason #4 – Improved Power Performance

Several more optimizations go into place when you build your software for release. These optimizations often make your software run faster. One of the secondary benefits of software that runs faster is that if you take advantage of low-power modes, your system will also use less energy! Less energy means you can run on a battery longer, or if you are on continuous power, your device will just operate greener.

The general idea is that optimizing for performance will take fewer clock cycles to do practical work. That enables your system to reach those low-power states faster and spend more time in them. The result is less energy usage and improved power performance for your system.

Reason #5 – Professionalism

Software developers often get a bad rap for writing buggy, low-quality software. Taking the time to define and test an optimized release build shows that you and your team are not just another group of developers hacking code together. Instead, the release is well thought out, efficient, and well-tested. It shows that you are a professional and go above and beyond what a hobbyist or maker does to “just make their code work”.

Conclusions

Release builds can have a lot of benefits to embedded software developers. You will have better performance, a smaller memory footprint, improved security, and a less energy device. When creating a release build, you don’t necessarily have to remove monitors or tools that help you debug your system in the field. However, it should distinguish between firmware configured to run in the lab for development and a polished release.