Streamlining Development by Mastering Modern Development Practices

Modern embedded software development demands precision, adaptability, and efficiency. Projects often span diverse hardware platforms, each with unique needs, and must meet strict real-time requirements. Best practices like containerized environments, streamlined CI pipelines, and incremental refactoring, often provide the edge needed to deliver reliable, high-performance solutions. Let’s look at these practices to help enhance your development processes and overcome some common challenges in embedded workflows.

Building in isolation

Containers are revolutionizing embedded software development by providing a controlled and consistent environment for builds. This approach prevents conflicts between your local development environment and the build environment, offering much-needed clarity and stability. Three key reasons why containers matter in embedded development:

• Consistency across teams: Developers working on different platforms can rely on identical, preconfigured environments. This eliminates discrepancies caused by local setup variations and ensures reproducibility. For example, you could use a container to encapsulate your development toolchain so that every team member compiles with identical compiler versions and configurations.
• CI/CD integration: Containers enable rapid deployment of isolated build instances within CI pipelines. This means you can spin up a new container for each build and run tests in parallel without interfering with other processes.
• Simplified onboarding: New developers can pull a container image and start building without manually configuring dependencies, saving hours of setup time.

While containers add overhead during setup, the long-term gains in reliability and scalability make them a great fit for embedded workflows. For a deeper dive on containers, check out the Developer’s Guide to Containers by my colleague, Andrew Hayzen.

Managing dependencies

Most embedded projects rely on numerous dependencies, including runtime libraries, open-source components, and developer tools. It’s important to manage these dependencies effectively to keep your builds stable and your CI pipelines smooth.

One approach is to build all critical dependencies from source. For smaller, fast-moving dependencies, this approach provides flexibility and ensures alignment with project requirements. However, for more stable, less frequently updated dependencies, using package managers or pre-built binaries to distribute precompiled packages can save time and reduce the overall burden on your team. Striking the right balance between the two approaches depends on the complexity and size of your specific stack.

CI done right

When CI works well, it’s a developer’s best friend. Automated builds, testing, static analysis, and code sanitizers provide fast feedback and improve code quality. However, CI is more challenging in embedded development due to hardware constraints, cross-compilation requirements, and resource limitations. Yet, a well-tuned CI pipeline can transform how teams work. Here are a few ways to optimize your pipeline:

1. HIL testing: Integrating physical hardware into your CI pipeline is a great way to test firmware against real-world conditions. While emulators are useful, they can miss hardware-specific bugs like race conditions and timing issues – things you might be able to catch with a cluster of low-cost boards like Raspberry Pis in your test framework.
2. Parallelized builds and tests: Leveraging cloud services or dedicated build servers to run parallel jobs, can reduce feedback time. This approach is useful for tasks like testing multiple product configurations by distributing the workload across several nodes.
3. Static and dynamic analysis tools: Tools like clang-tidy or Google Sanitizers can be integrated into the CI pipeline to catch potential issues early. Static analysis ensures code adheres to best practices, while dynamic analysis detects runtime errors.

Iterative improvements without stalling development

Refactoring is essential for long-term maintainability of clean, manageable code, but it must be handled carefully to avoid disrupting ongoing development. Instead of halting production for massive rewrites, adopt a trunk-based development approach using ‘atomic commits’ where changes for small, self-contained updates are merged into the main branch at least once a day. Atomic commits work because short-lived branches and incremental changes keep the codebase current while avoiding the pitfalls of stale, long-lived branches and minimizing integration headaches. Plus, every commit is tested via CI pipelines and static analysis, catching issues early.

However, sometimes you can’t avoid working with large-scale changes, particularly in big codebases. Examples include migrating hardware abstraction layers and rewriting critical middleware. In these cases, you may want to create parallel APIs that allow old and new implementations to coexist temporarily. This approach enables incremental migration of refactored modules to the new API while maintaining the legacy API for unaffected components. Both APIs should coexist only for as long as it takes to confidently migrate and validate all dependent modules, Validation should include unit, integration, and hardware tests. Once all refactored modules have been integrated into the new API, the legacy API should be deprecated.

By refactoring incrementally in this way and maintaining stability, teams can avoid the risk of system-wide disruptions, turning what is often considered a very disruptive process into a seamless part of development.

Key takeaways

By embracing modern development practices tailored to the unique challenges of embedded systems, teams can achieve faster cleaner, more maintainable codebases without sacrificing productivity. Strategies discussed in this blog include:

• Leveraging containers for consistent build environments
• Building dependencies wisely, balancing flexibility with efficiency
• Optimizing CI pipelines for fast, actionable feedback
• Approaching refactoring incrementally for minimal disruption

These practices are just the tip of the iceberg in creating a robust development environment. For those looking to delve deeper into optimizing their development workflows, our full whitepaper on General Development offers more insights and additional strategies tailored to modern software teams.