Embedded Software Engineering Trends

December 20, 2024

Blog

As devices become increasingly intelligent and interconnected, the demand for sophisticated embedded systems also continues to soar, with a natural knock-on effect across the embedded software industry as developers step up to embrace new technologies and methods.

This article delves into the top five trends shaping the future of embedded systems, including the rise of AI, advances in CI/CD, the growing popularity of Rust and the increasing adoption of Visual Studio Code and navigating the complex landscape of today’s device development. ByteSnap Design engineers have identified these as key trends in the future of embedded software development, and reshaping design, development and deployment.

Implementing AI

AI is appearing in many software development products, from planning apps that can recommend information and links between issues, to meeting apps that can generate a transcript from a recorded meeting. Within the core software development tools there’s been two major improvements that have changed how many of us work, often without realising it.

The first improvement is to auto-complete. Development tools such as Visual Studio are now starting to use AI to predict users’ intentions beyond just finishing the word they are currently typing.

Take the below C# method call as an example; this is quite a long call that may be used hundreds of times throughout an application.

await logger.WriteLineAsync("My log message").ConfigureAwait(false);

With traditional autocomplete, as you start typing each word it would suggest some options for that word alone: logger, WriteLineAsync, ConfigureAwait. While this does save some time it’s still cumbersome and leads to a lot of copy/pasting, which can cause errors.

With smarter autocompletes, from the moment you start typing the logger portion it will suggest the entirety of the line, available with a single press of the Tab key. All that needs to be done is to change the log message and over the course of an entire project this could save a significant amount of time.

The second improvement is the introduction of ChatGPT or similar AI models into our working life. While some developers might directly use ChatGPT to ask questions about issues they are facing, it has also started appearing within search engines to provide summaries about topics.

A very common development skill is knowing how to effectively search something that isn’t known; this could be how to do something like implementing database access or specifics about an API that’s being used. AI backed search engines provide more direct answers that pull information from several sites at once, reducing how much time is spent digging for that one forum post that answered the problem.

Going forward it’s inevitable that we’ll be using AI in day-to-day development as a behind the scenes assistant, gently optimising our repeated tasks and nudging us towards the information needed to effectively complete our work.

Improvement to CI/CD processes

Continuous Integration and Development (CI/CD) is a DevOps workflow that’s become an industry standard practice following years of refinement. 

CI/CD automates the process of building, testing and deploying software products and can significantly improve code quality and time to market when utilised correctly. Any professional development company will implement CI/CD at a minimum for its testing policies, but in larger companies such as PlayStation or Microsoft it will be the core backbone of their development pipeline.

One of the biggest improvements to CI/CD is the use of containerisation technologies, most notably Docker and Kubernetes. These work to answer the question “What environment do I need for this product?” by providing scalable and deployable development environments.

For example, when working on a C++ project it may be tested with GoogleTest, a CI/CD environment can quickly spin up a Linux container that has g++ and GoogleTest installed within seconds, run the tests and then destroy itself once the reports are published. So there is no more need for expensive virtual machines (VMs) or dedicated manifest build machines that are always on as CI/CD workflows often prioritise being lightweight and scalable especially within the cloud.

Most importantly CI/CD workflows are automated, meaning that developers need not remember what tests or build setup is specifically required. When paired with a source control solution, every time they check in their code or request a review, CI/CD begins and notifies them if there are any issues. This reduces long-term load on team leaders and project managers having to constantly review every change or release in detail.

Within ByteSnap we’ve caught countless small bugs in complex products with CI/CD that would have not been caught by traditional methods until much later in the pipeline, where identifying them may require hours of debugging and analysis.

One notable example was a small copy paste error in a device that registered 16 services. The service with the error was a minor one used infrequently and not immediately obvious that it wasn’t online. CI/CD however enforced a strict test policy that identified the missing service at the time of the error, allowing it to be corrected before it ever became a problem.

The rise of Rust in embedded applications

Rust has emerged as a promising alternative in embedded systems, challenging the long-standing dominance of the C programming language. Rust offers features such as memory safety, zero-cost abstractions and a robust type system. These attributes make Rust particularly attractive for developing secure and reliable embedded applications, especially in safety-critical domains.

Despite Rust's advantages, C remains deeply entrenched in the embedded world. Many existing codebases, development tools and hardware platforms rely on C, making a wholesale transition to Rust a substantial undertaking. The simplicity of C and its widespread familiarity among developers continue to be valuable assets. Although Rust presents compelling benefits, it also comes with a steeper learning curve and may require significant investment in retraining and retooling.

Looking ahead, the future of embedded programming will likely involve both Rust and C coexisting rather than one language replacing the other. Rust may gain traction in new projects and specific applications where its strengths can be fully leveraged. Meanwhile, C will continue to dominate in legacy systems and resource-constrained environments. Ultimately, the choice between Rust and C will depend on project requirements, team expertise and the specific constraints of each embedded system.

Increased popularity of Visual Code

The customisability and flexibility of VS Code (Visual Studio Code) makes it a very attractive option for software developers. If a feature that you would like doesn’t exist, you have the freedom to create it yourself and share that with others.

In the embedded world, popularity has been increasing in part due to major silicon manufacturers creating their own extensions allowing engineers to not only use VS Code as a text editor, but become a fully-fledged Integrated Development Environment (IDE) with debug capability and access to configuration tools. VS Code has been in use for quite a while with Espressif, Raspberry Pi, Pico and others. The usability, flexibility, extensibility, performance and community support of VS Code has seen its popularity grow and that popularity is due to increase further with vendors looking to migrate new versions of their IDEs to VS Code instead of Eclipse. As an example, Silicon Labs Simplicity Studio 6 will be VS Code based in contrast to their previous versions being based on Eclipse.

From a development perspective, it’s also incredibly useful to have all your workflow tools in one place simply by installing the extension; there are linters, static analysis, build system tools, container management, test runners, compilers, repository and project management tools - the list is endless.

VS Code will only get better in the future as more developers and companies contribute to its success.  Extensions integrating AI already exist; Microsoft provides an extension for its Copilot AI pair programming tool, with other companies and developers providing access to ChatGPT and other AI tools directly within VS Code.

Navigating the complex landscape of today’s device development

As technology advances, consumer expectations for basic device functionality has also evolved. Twenty years ago, a simple device that performed only its job might have been acceptable. However, today, the minimum expectations from such devices have increased, with consumers demanding more features and capabilities. A timer plug for instance may have been entirely mechanical on what is effectively an egg timer. Now, however, consumers expect it to be connected to the internet, controllable from their phone anywhere in the world, able to schedule on/off times and even provide power usage reports.

This increases the amount of work required to produce even fairly simple products and, in turn, increases the risk that developers might introduce bugs. However, it’s not all doom and gloom, with the advent of complex requirements exceptional libraries have been created, especially in the Open Source space.

Where software licences permit it, large amounts of modern development are backed by community-lead library projects for everything from common utilities such as C++’s Boost library to entire web frameworks like Node.JS. Within the embedded space, it’s difficult to find a product that isn’t running some kind of Real Time Operating System such as FreeRTOS or ThreadX.

Implementing these libraries into products requires a fundamental understanding on how to design abstracted, loosely coupled and cohesive software. On a recent ByteSnap product, we designed a system that had three possible network configurations and an optional display. By carefully abstracting the network and display layers we were able to focus on and test the various parts of the configuration in isolation, with only a small amount of work needed at the end to ensure they all came together in the main application without issue. Working this way also ensures that in the future we could add more displays or network options with ease and potentially reusing some of the network configurations in other products.

With increasing regulations as well as consumer expectations it’s unlikely our devices will ever get simpler. To that end, its important developers are comfortable knowing when to lean on a library versus when they should design their own solution.

Complexity leads to more interesting products; by knowing what the common industry libraries and practices are, developers can embrace this in their designs.

Conclusion

As the embedded software industry evolves, developers are tasked with adapting to a fusion of technological advances, trends and industry standards. The integration of AI into development tools, optimising CI/CD pipelines, the rising popularity of Rust, and the adaptability of Visual Studio Code are collectively transforming the industry landscape as we move beyond 2024 and into the latter part of the decade. With a solid foundation in software design principles and being ready to embrace these trends, developers can create more advanced, secure, and reliable embedded systems which will benefit billions worldwide.

Additional Contributors:

Graeme Wintle, Director

Liam O’Donnell, Senior Software Engineer