Home > On-Demand Archives > Keynote Presentations >
The Embedded Frontier: Modern Trends and Practices
Jacob Beningo - Watch Now - EOC 2024 - Duration: 01:41:37
Embedded systems development has dramatically changed over the last decade. Navigating today's trends and where you need to be tomorrow can impact whether you’ll be successful or struggle to deliver your products on time. The latest trends can lead to best practices that help you develop more reliable embedded devices faster and within customer budgets.
In this session, we will explore the current state of the embedded software industry, the trends, and the practices that are helping teams be successful. We will look at the dynamics between C, C++, and Rust adoption. The impact that AI and ML are having on how we develop and debug embedded systems. We’ll look at changes to how systems are architected and the improvements in build systems and lifecycle processes that help teams manage complexity.
Attendees will walk away, understanding where the industry is at today, where it’s going, and the changes they need to make to stay up to date.
Topics covered in this talk will include:
- Programming Language Trends
- AI & ML Development Techniques
- Lifecycle Automation with DevOps and CI/CD
- Build Systems and Configuration
- Testing and simulation
- Modern Software Architectures
What did Jacob Beningo recommend developers do now regarding Rust?
I have heard of it, but I don't use it personally. So, I can't give my thoughts specifically on it.
In general, depending on the industry you are in, you'll find that there are frameworks like this that are designed to help you develop quickly.
For example, the auto industry uses Autosar; more space systems are being built with JPL's F'.
I hope that helps!
Hi Jackob, would you kindly upload the slides. Thanks.
It's been uploaded. Enjoy!
Thanks for the talk! Could you share a good configuration management example (C and C++)?
On second thought, look in the EOC archive and you will see some talks I did on Reusable Firmware and a Driver Techniques workshop I did.
Those would be some possible "free" resources for you to check out too. (Free being you already paid for them!).
Thanks for the question.
Unfortunately, I don't have a public one that I could point to other than what is in my Embedded Software Design Book in Chapter 13, Configurable Firmware Techniques
Thanks, that was a great keynote and Q&A! I would certainly agree that when you think you’ve learnt something, then it all changes and there’s always more to learn im our industry!
The list of positives from AI was useful. I had only thought of using it for generating code. How can firms leverage AI to do all this, without risking leaking all their valuable IP? When I tried ChatGPT to solve a problem for me, I had to think up a contrived example and do it from my own non-work computer just to be sure.
Your discussion and then questions from Ali about top-down design was something I’ve never thought about before. I can see the real advantages in focussing on what adds value to the customer. I can imagine them having difficulty visualising the end product though. They want to hold it, push buttons etc, even though the top-down design could be demo’d on a laptop.
I think one of the reasons these modern practices haven’t truely taken off in the embedded world is maybe the human element. We tend to do things how they’re always done, because it’s what we know. Not everyone reads textbooks, blogs, attends conferences or want to spend time exploring new tools and practices, so there’s an inertia to change. We book work to a project and focus on requirements, which doesn’t allow time to stop and think if there are better ways. Every time I read about your proper HAL, I wish I’d have gone down that route so I could stop debugging on target!
Thanks for the comment and great observations!
There are ways to use ChatGPT and other generative AI's where they don't take your input and use it elsewhere. You typically don't use the Web interface but pay for access to the backend API's that allow you to write your own apps and protect your business data.
As far as the HAL goes, it's never too late to put one in place! You might have to create a wrapper or make some other adjustments, but decoupling it can be well worth the effort! (and a fun project).
Hello Jacob, very interesting talk! Thank you very much! I would appreciate that if you could provide your perspectives on why rust language is the main contender for embedded system, but not other languages like C#, Go, or Swift.
You're welcome!
I think it's definitely between C/C++ and Rust. Although right now it really is a C/C++ "game".
Thanks for the keynote, Jacob!
My question:
In my team, we have new developers, and most of them are interns. Thinking about our developments, we intend to write a manual with good practices and design partners. For you, what's the best way that we can do this? What's the most important that we can't forget?
Thanks.
You're welcome.
Having a document like that is a great thing to do. To get things moving fast, I would use generative AI to give me a rough draft and rough outline that could then be filled in and edited. It's usually far faster to edit than to create something from scratch.
I wouldn't forget to document what your design philosophy and goals are. If that's clear, then even if someone doesn't read the document, they should have an idea of what principles to use to design and write the code.
Great, tks.
Thanks for this very informative and wide-topic talk, Jacob.
The top-down approach yields many advantages over the bottom-up in the current context. I have a question on the design/implementation of the interface. Indeed, it is usually straightforward to extract the core function from a device (GPIO_on / GPIO_off), while factorizing the initialization/configuration is much more complicated. I see two possible approaches move initialization in the application code or do the initialization inside the component.
Each implementation has a custom configuration/initialization function in the first case. This can be called from the application code, so you can pass around a ready-to-use component instance. This approach has the disadvantage of moving platform-specific code in the application layer (even if in a very confined way).
The other approach is to hide the initialization/configuration inside the component, hidden behind a generic "init" method. This hides away specific code but makes components less flexible to use since they are bound to specific hardware resources.
What approach do you suggest?
Thank you.
Thanks for the question.
With most of this, unfortunately, the answer is that it depends. What you are trying to achieve, goals for design, etc, come in to play to trade-off which approach will work the best for you. It may even change from one project to the next.
There is a third approach where use approach one but hide the details behind API's in your application code so that the application still doesn't know the low-level objects or details.











Hi Jacob, really great talk- I took so much from it. I'd like to ask if you've heard of the QP framework? Miro Samek and his team have produced a very comprehensive solution for developing embedded systems in C/C++ and I think it's gaining traction. What are your thoughts on it and on the future of projects using this or other frameworks similar to it?