As 2022 creeps to a close, many of you probably reflect on what went right and what didn’t. You’re probably looking to the future and considering what 2023 will look like. Technology constantly evolves, creating new methodologies and techniques to improve software quality, cost, and delivery timelines. In 2022, we saw many exciting trends surface, some that were expected and others that weren’t. This post will explore several embedded software trends that will be prevalent in 2023 and that you should keep tabs on.
Trend #1 – Container Adoption
Embedded developers often encounter a couple of problems that create real issues. First, each developer installs their development toolchain separately on each development computer. Minor toolchain and library differences can produce different results, creating bugs that are a nuisance to track down. Second, embedded software applications, particularly microcontroller-based systems, are monolithic, single-binary images that are all or nothing. Creating updates, adding new features, etc., requires flashing the entire application, and even in development, it can make it difficult to separate the workload.
Containers are a popular tool that has helped to revolutionize the web, server, and distributed applications. However, there are quite a few different ways that they can also help embedded software developers ease some of their pain points. For example, instead of having each developer install their development environment, they can create a container that automatically installs the correct version of the tools and libraries. In addition, using a container helps guarantee that each developer has the same tools and that their host operating system or configuration is eliminated from the problem cause chain.
Containers can also play a role on the device. Yes, you read that correctly. Containers and container runtimes are getting small enough to run on a mid-sized microcontroller. When this is done, developers can take advantage of a completely abstracted microcontroller. The application can become service-oriented, allowing more modern architectures to be used. Updating the application no longer requires a full device flash but replacing individual services or adding them.
I expect to gain momentum in the coming year because it’s an interesting technology.
Trend #2 – Reignition of the Programming Language Wars
When I started developing embedded systems in the late 1990s, the industry was ablaze with a war between developers advocating for C or C++. It was a heated debate with good points on each side and a lot of misunderstanding. Over time, the discussion simmered, and developers moved forward with whichever language made the most sense, and even today, the debate is mostly mute.
Over the last several months, I’ve witnessed a reignition of the programming language wars for embedded devices; However, this time, it isn’t a debate between C and C++ but between C++ and Rust. Rust advocates have been growing in number, partially because of Rust memory safety model, which has the potential to improve the security of devices.
I suspect we will see a growing number of embedded developers interested in using Rust and the debate as to whether Rust is ready or not for production devices. In the meantime, I’ve seen a significant shift away from C in the industry to C++. So while the debate will rage on what language is the right one, the truth will be that it depends on what the goals of your system are, what language your team has expertise in and the level of risk associated with the language you use.
Trend #3 – A Focus on Security
There is a big push within many industries to connect embedded systems. The IoT is growing quickly and opening a wide range of business cases that provide value to businesses and customers. The most widely used form of device attack is a remote attack. Any device connected to the internet is a potential target. Every IoT device needs security, and many industries that have ignored security in the past are or will be forced to consider how to secure their systems. In the coming year, I think that you’ll find that several technologies will be vital to securing embedded systems.
First, you’ll see a big push to use memory-safe programming languages such as Rust. You may find that using a memory-safe language doesn’t make sense for you based on the cost of learning the language and even due to the risk of using the language from a maintenance or evolution standpoint. When you see the pressure to move to a memory-safe programming language, remember that you can achieve similar results by following best practices in languages like C/C++. A memory-safe language will just make it much more manageable.
Next, you will continue to see an evolution in the microcontroller with more and more features targeting security. Embedded software developers typically don’t have experience with security, so microcontroller vendors are making it easier by adding on-chip capabilities and backing up those features with software frameworks. These capabilities will ease the security burden, but developers will still have an uphill battle to ensure they are correctly used and can secure the device and data to their specific needs.
Finally, I think we will see a security refitting trend where device manufacturers who ignored security from the start will be legally forced to implement security on their devices to protect user data.
Trend #4 – Adoption of Agile Methodologies
Agile values have been around for more than two decades. Over that time, more than 40 different methodologies and systems have been developed to help software developers adopt and employ those values to help them deliver more robust software “on time”. Unfortunately, while it’s not uncommon to see embedded teams adopting techniques like SCRUM, they are behind on adopting other helpful tools like DevOps.
A trend you will see in 2023 and beyond is the adoption of more advanced Agile methodologies. Teams worldwide are leveraging concepts like continuous integration and deployment in their process flow. CI/CD can help automate builds, software analysis, unit testing, hardware-in-loop testing, deployment, and more.
I think it’s essential for you to note that these improvements are incremental. Start slow if you adopt the latest Agile methodologies in 2023. For example, minor enhancements to a DevOps pipeline over a year can result in a significant pipeline. Trying to rush it will likely result in a poor pipeline and frustrated developers deciding that “it doesn’t work”. You’ll then be worse off than when you started.
Trend #5 – Multicore Microcontrollers
There are more and more applications that are requiring the need for parallel processing in an embedded system. For example, an IoT application might have one processing core to execute as a secure processor while the other core manages standard application code. A team might use one core as a real-time processor that collects sensor data while the other core runs a display or maybe a machine learning inference.
Multicore processors allow a team to create execution domains beyond just the single domain embedded developers are used to. Even running a network stack separately from the application code can help a product meet real-time deadlines and simplify debugging and software development for the team.
Over the next year or more, I expect we will see more multicore microcontrollers at lower and lower price points, especially once we get through the chip shortages. The potential for multicore microcontrollers and how they improve the value provided by a product is astounding.
Embedded Software Trend Conclusions
We’ve just explored five trends prevalent to embedded software developers in 2023. These trends come from a generic perspective of the embedded software industry. Our industry, though, is not isolated. Where embedded software goes in the future depends on where the business pressures and the more significant software industry is going. In addition, different teams will have various needs. So, it’s essential to look at your specific team and where they need to get in the new year to be successful.