5 Embedded Software Trends to Watch in 2024

As 2024 begins, you may find yourself reviewing what went well in 2023 and what didn’t. Yearly reflection can help you and your development team fine-tune your direction so that you can have a successful year. An excellent exercise to perform is to look at the embedded software industry and determine what trends will affect you, your customers, and your company. 

Embedded software can run anything from an 8-bit microcontroller to complex multicore FPGA-based systems running microcontroller and application cores. While our industry is vast, and a lot is going on, several general trends will be essential to watch in 2024 and beyond. Let’s look at several industry trends focusing on microcontroller-based systems. 

Embedded Software Trend #1: Leveraging AI

Artificial Intelligence (AI) is a significant and obvious trend, so let’s get it out of the way right away. AI technologies are developing at an exponential rate and have the potential to revolutionize how you create embedded software completely. AI will find its way into numerous areas of your software development lifecycle, including in areas such as:

There is already a wide variety of tools adopting the “CoPilot” designation to help assist in software development. For example, Github CoPilot integrates with Visual Studio Code to provide code generation recommendations that developers can accept. While the technology is still new, I have found it to have reasonable suggestions about half the time. I suspect this will only get better with time. 

Related:Beware! 3 Toxic Software Engineering Habits to Avoid

The question isn’t whether you should be using AI technologies in embedded software development but how you should use them to accelerate and improve your embedded software. 

Embedded Software Trend #2: Improving CI/CD Processes

Embedded software teams are adopting DevOps at a rapid pace. It provides teams with methodologies to automate their build, test, and deployment processes. These concepts and techniques can help a team to develop higher-quality software faster. However, I have seen embedded teams struggle to implement reasonable pipelines for their embedded products, especially small- and medium-sized companies. 

CI/CD technologies have reached a maturity level, and the techniques are in place for embedded teams to leverage CI/CD better. I’m seeing teams adopt DevOps and CI/CD more readily and expect an uptrend in the coming year. Teams that do have pipelines implemented are not fully utilizing them, which means they are not getting the full benefits from their efforts. The potential improvements in quality and observability in the development process are now too significant to ignore. 

Related:5 Tips for Creating an RTOS Abstraction Layer (OSAL)

Embedded Software Trend #3: Phasing Out C for C++ and Rust in 32-Bit Applications

The programming language wars will continue this year. I believe that we will continue to see the C programming language start to be phased out and replaced by more modern languages such as C++ and Rust. C won’t be replaced entirely in our lifetimes; it will hang around like Cobol has in the financial systems. However, I am seeing more teams starting new projects drop C with a preference for using C++. 

I think it’s important to note that this transition is occurring in the 32-bit microcontroller space. These parts have become so powerful that they push the boundary between microcontrollers and application processors. They are now so complex that they border on general computing applications. Adopting a modern language like C++ or Rust makes much more sense in these applications.

Rust has a lot of interest, but its adoption could be faster-moving in the embedded space. That isn’t necessarily surprising, given how slowly new technologies are adopted into embedded products. We won’t see a big push to adopt Rust until it is supported by silicon vendors that provide crates for their hardware. Until that happens, the dominant trend will be using the C libraries they provide with C++. 

Embedded Software Trend #4: Developer Centric Workflows

Developers have often just accepted the tools that their silicon vendor provides them. The team adapts its development workflow to how the vendor architected their tools. For example, for years, teams have used Eclipse-based IDEs for embedded software development. While convenient, it doesn’t readily integrate well with modern development processes, CI/CD, AI tools, etc. 

With tools like Visual Studio Code, developers can fully customize their workflow for what works best for them. While this may seem like a minor trend, it has the potential to improve developer efficiency and help teams deliver on time. If each developer working on a project can customize their tools to develop in a way that fits their needs, rather than adopting some general process, they’ll be able to develop code faster. Faster delivery can mean more time to focus on quality and the ability to save costs or deliver more features.  

I suspect we’ll see a greater focus on developer-centric workflows as the year progresses. After all, a company's greatest asset is its employees, so helping them work in the way that fits is logical. 

Embedded Software Trend #5: Moving to Higher Levels of Abstraction

Moving to higher levels of abstraction is nothing new in the embedded software industry. Abstractions provide us with a mechanism to simplify complex software and interactions. Edsger Dijkstra noted that “Simplicity is prerequisite for reliability.” If you want to develop reliable software, you must keep it simple. As software grows more complex, the need for higher levels of abstraction becomes not a luxury but a necessity! 

The complexity of microcontroller hardware and IoT applications has pushed the boundary of embedded software to the point that it now intersects with general computing. It has been there for a while, but companies now realize how to leverage this intersection successfully. 

For example, a team traditionally might pick an RTOS but still write all their low-level drivers. Instead, a team today would abstract those details by selecting an RTOS that supports POSIX and already has drivers and HALs in place. Their application will leverage these abstractions so that knowledge of the underlying hardware and middleware is minimal. Instead of a team being filled with embedded software developers, which are hard to find, any intern who understands general computer science techniques can get a system up and running. 

We can expect a big push to general computing capabilities and abstractions and an increase in no-code solutions.  

Embedded Software Trend Conclusions

These five trends are forcing many embedded software teams to rethink how they develop and build their embedded systems. It’s important to note that while these are more significant industry trends, every industry and team is different. You may find that some of these trends do not affect your day-to-day development efforts. Others may force you to change how you develop your software dramatically. 

In any case, it would be wise to stop and consider changes in the embedded systems industry in 2024 so that you don’t find yourself left behind or scrambling to play catch-up.