The Embedded Frontier

#013 - The Role of AI in Embedded Software Development

• Jacob Beningo

Share episode

In this episode of the Embedded Frontier podcast, Jacob Beningo explores the evolving role of artificial intelligence (AI) in embedded systems development. He discusses the potential applications of AI, including code review, documentation, and generating code, while emphasizing the importance of adopting AI technologies to enhance productivity and efficiency in the field. Beningo also addresses the challenges and risks associated with AI, advocating for its integration into development workflows to stay competitive in the industry.

Takeaways

  • AI has a unique role to play in embedded systems development.
  • Documentation is a critical area where AI can assist developers.
  • AI can help automate code reviews, making them more efficient.
  • Using AI for generating code can speed up the prototyping process.
  • AI can help document architectural decisions and trade-offs.
  • The rapid evolution of AI technology presents both opportunities and risks.
  • AI can serve as an augmentation tool for developers, enhancing their capabilities.
  • Understanding how to effectively prompt AI is crucial for getting desired results.
  • AI can help reduce technical debt by improving documentation practices.
  • The integration of AI into workflows can lead to significant productivity gains.

Jacob Beningo (00:00.514)
Hello and welcome to the Embedded Frontier, the podcast where we dive deep into the ever evolving world of embedded systems. Whether you're an experienced engineer looking to stay ahead of the curve, a newcomer eager to learn, or a director looking to understand the latest industry trends, this podcast is your gateway to understanding the intricate world of embedded systems. I'm Jacob Benigno, CEO and founder of Benigno Embedded Group. We're an embedded software consulting and education company.

dedicated to helping teams and developers modernize their processes and enhance their skills. Our goal? To empower you to succeed in your career and projects by developing affordable, reliable, and secure products efficiently and on time.

In today's episode, we are going to be talking about the role of AI in embedded systems development. Now, for some of you, just that statement, you might say, well, there isn't a role for AI in embedded systems development, right? After all, many people have tried to adopt TDD, right? And for some folks, it works, and for some folks, it doesn't work. Some people love CI-CD, others don't find a place for CD, continuous delivery, in embedded systems, where others find

CI is absolutely critical. Right. And so as we look at the wide spectrum of the way that people develop embedded systems, does AI have a role to play? Well, in today's episode, that's exactly what we are going to be talking about. Now, I can tell you from 20 years of experience and playing with all kinds of different technologies that are on the frontier of embedded systems, sometimes technologies just don't pan out. I'll dive into a technology, be like, my gosh, this is cool. This is going to be the future. And

Lo and behold, you discover a decade or two later that, you know what, it turned out that that wasn't the next big thing, right? I mean, after all, how many times have we over the course of the last several decades said C is dead, C++ or some other language is going to take its place. And yet here we are 50 years after the C programming language was invented and it is still the most dominant embedded systems language out there. Nearly 70 % of teams are still using it, right? And so as we look at future technologies that

Jacob Beningo (02:16.332)
you know, like AI that are going to be available to us to develop embedded systems, there's a couple things that we need to take into account to ensure that it is actually the right technology for us to adopt. Okay? Now, artificial intelligence, it has a lot of buzz around it right now, right? If you just take a look at the stock market, for example, although today it's maybe not in the greatest shape, but if you look at AI companies, right, they have been a huge driver of growth over the last...

several years, right? There's this hype that, hey, AI is here to stay this time, right? There's actually, we're actually in the third phase of artificial intelligence. It was actually created back in the 50s and it had a nice little introduction and then it kind of waned and went away. And then again, in like the late 70s and the 80s, it kind of caught on again and then kind of slowly kind of died off and started to wane away. And then, you know, generative AI,

came out of the scene, right? The transformer models. And that brings us essentially to today where we have lots of very interesting tools, lots of cool technologies, large language models have found their way into all kinds of different areas of our day-to-day lives, right? And the question really is, with this technology out there, does it really apply to embedded systems? And if it does, how can I use it to develop embedded systems? Okay?

Now, to answer this question, we're just going to spend a little bit of time today discussing this, seeing where things go. I will give you a heads up over the course of the next month, there are actually two different AI talks or workshops that I'm going to be running that kind of dive a lot deeper into these topics. OK, the first one is with design news. In that particular course, it's actually going to be here in two weeks in April. Actually, I think it's next week, April 21st through the 25th.

we're going to be talking about how you build your own AI assisted software intern, essentially, right? And so we're going start looking at some of the technologies of where AI applies. And one example that I go into heavily in that particular workshop is to look at using AI as an intern. And when you stop and think about what exactly an intern does, well, they might be set to do low level tasks, they might do documentation.

Jacob Beningo (04:35.526)
They might review code, right? So they get exposed to a lot of different code, maybe suggest changes that could be made to it to make sure that we comply with whatever style guidelines we're interested in using. And so in that particular workshop, and this is a perfect example of what you can use AI for, is to review code, right? Provide examples. And so that workshop is actually a cool free one through the Design News Continuing Education Center. And we'll dive deeper into that particular topic for that course. But...

Right there, that gives you an interesting use case. You can actually train an AI model, or not even train it, you can use a large language model like ChatGPT, for example, and use their API interface to create Python scripts that will interact with the LLM, and you can load your code up, and it can analyze your code, and then give you feedback on changes that should be made. Okay? So we all know that as engineers and developers, we hate doing code reviews, even though they are probably the most productive and efficient way

to eliminate bugs, right? And so if you are on a team that maybe struggles to do code reviews, you very easily could work with an AI, create an AI application that would allow you when you commit your code into your CI pipeline, your continuous integration server, have it run a script that takes your code, analyzes what has been modified, what has been changed, what's been added, and have it sent to an LLM that will then analyze it based on your own specifications

and then provide you with feedback on what might need to be changed. Okay? There are certainly different ways that you could do that. You could have it suggest changes. If you are a little bit more cavalier, perhaps, what you could do instead is actually let the artificial intelligence make the changes directly for you. Okay? Now, that really is going to depend on how comfortable you are with AI, maybe even how comfortable you are with your revision control system, right? You know, I often think it's not...

necessarily a bad thing to let AI make the changes directly in your Git repository. The nice thing is that you can do the direct comparisons with previous versions and you can see what was actually changed. Now you might say, well, if you have to go back and verify everything yourself anyways, what is really the advantage there to using AI, right? Well, one major advantage is that AI is very good at documentation. Okay. And so an amazing role to leverage AI for is to document things. I know from experience that

Jacob Beningo (06:58.538)
Embedded developers or software developers in general, we don't like to document things, right? We like to code. We like to get the work done. OK, we want to be efficient. And let's be honest, documentation is one of those evils that we have to put up with in the development cycle. And it is very boring, time consuming and inefficient to develop documentation ourselves. Right. But if you can provide code to an AI and it can generate 80 percent of the documentation for you you just have to review it, make sure it's still accurate, maybe make a few adjustments.

That can be a great way not to just get documentation, but to ensure that you are able to have the documentation for newcomers to your project or for upper management or for your customers and do so in a way that's a lot faster. OK, now I've actually been using AI for documentation a lot over the last several months. And what I found is that it actually does a fairly good job of creating documentation. OK, it's not perfect. All right.

Even if you were to take something and hand it to a human, it's not going to be perfect, right? There's always going to be some type of feedback cycle. But what I have found is that it has helped me and several of my customers to accelerate and move a little bit faster, be more efficient in the way that they develop their embedded systems by leveraging that type of technique. All right? So AI on its own can certainly provide feedback, it can document code, it can also document software architectures, it can help you to document

You know, other things that might need to be done as well. You know, whatever you might have around that needs to be documented, maybe prototype code or whatever it happens to be. Okay. So that I think is some really good use cases for artificial intelligence in embedded systems today. And I'm seeing a lot of good traction with that. And it's very capable of doing that today. Okay. This isn't a use case that maybe one day we can use it for that. It's actually here today. Okay. Now, beyond that,

You know, maybe as a secondary example of good documentation it can provide. When it comes to developing a software architecture, one of the things that I find to be extremely important is to document your design decisions. Okay. We're always performing trade-offs and I have found that teams that do not document their architecture or those trade-offs that they're making, oftentimes what happens is new team members come on board, they look at the code and what do they say? They say, you guys don't know what you're doing.

Jacob Beningo (09:23.083)
I can write the code so much better, right? You don't know what you're talking about. And what ends up happening there is it's not necessarily, you know, there's a little bit of not invented here syndrome going on. But I think the root cause of not invented here syndrome is that we don't actually have a documentation trail or a way to share the knowledge of what trade-offs we're actually making in a system. So someone coming into a new project looks at the code, looks at what the system needs to do, and they say, you guys don't know what you're doing, right?

Well, if you actually were to stop and create architectural design records, basically saying, hey, these are the trade-offs we're making. This is the decision we made. This is why we made that decision. Those types of things can help you have the trail so that when someone new comes on and says, yeah, you guys don't know what you're doing, you say, go look at these architectural design records. And they can go and review the trade-offs you're making. And suddenly, why your code is written the way it is and why the system is architected the way it is makes a lot of sense.

Now, what does that do? Well, that prevents not just the non-invented here syndrome. It prevents developers from having to go back and say, no, I need to rewrite all of this from scratch. Okay. Once they understand the project, what it's doing, what the trade-offs were, a lot of times they're more on board with the way things are being done and they understand why. And then that prevents extra costs from having to go back and rework code. It saves time because you're not redoing the same thing over and over and over again. I've seen customers where they...

This type of thing happens and they will go back and redo the exact same project three, four times because they keep swapping out developers. Now, of course, that could be a leadership problem, right? With the company. It's not necessarily a technical problem per se, but there is this documentation trail that's missing. Now, Jacob, where am I going with this? You might be wondering. Okay. Well, if you need to keep track of your architectural decisions and you want to create good records for them,

You can use AI as well to help you create the drafts, the templates for those types of records, right? You can very easily just type out a few things of here's the decision we're making, here is the reason why we're doing it. And yes, you can throw it in your own markdown, right? But if you needed a little bit more of a both detail, you can let AI generate the draft for you, go back, update that and make sure that it has everything you need. And what you'll find is that you end up with documentation with more detail.

Jacob Beningo (11:42.731)
and perhaps better analysis because some of these AIs can actually do deep research nowadays. So can actually get references that help back up the decision that you're making, right? And that type of thing can ensure again that you have a really good trade-off record that helps make sure that your team is on the same page. Okay. So documentation is certainly a great direction for you to go when you are looking at using artificial intelligence. Okay. Now,

What are some other areas that we might use artificial intelligence for? Certainly there's for generating code. I've had some pretty good success with generating code for an embedded system, generating graphical user interfaces to talk to them, to talk to a system, plotting data. I've seen uses of it for decoding communication interfaces and standards. Lots of really cool types of use cases there where if you need to prototype something or you need to talk to a system very quickly,

or just prove that something is going to work, using artificial intelligence to generate that code for you can really help move you down the field a lot faster and prove things out. All right? So I don't necessarily look at this as, hey, artificial intelligence doesn't have a role to play in embedded systems development. I look at it as artificial intelligence has a unique role to play in embedded systems development for us. Okay? And it's a technology that, yes, today it is evolving at a very

rapid pace. Okay. And that inherently adds risk to adopting artificial intelligence. That means that any scripts that I create today that leverage large language models, they may work great today. And then some breaking change may occur in the future with those APIs that require me to go back and completely change the way that I'm using artificial intelligence. Okay. That might then mean that I end up with completely different results in the future than what I'm getting today. Right.

Even if the API stay the same, if the model changes or its behaviors or it's trained or a new model is released and I try to update to it, the results are going to be different. One of the things I found playing with documentation as an example, you know, in my CEC course, I have an example where we go through and we basically have a horribly written C++ module, something really simple. All it has is like some add, subtract and some comparison functions in it.

Jacob Beningo (14:06.987)
but it's written in a way that doesn't follow any C++ standard. And I use AI to go through and actually clean up the code, make it meet the style guide, and provide DocsGEN documentation. Now, what's interesting about that is that in that, and as I ran the material over and over and tested things and ran it and all that kind of stuff, what I discovered, as you can imagine, is that an AI model

even if you set it the exact same prompt over and over and over and over and over again, the output that you're going to get back from even the same piece of code is going to be a little bit different each time. Okay. And so there is actually a, to some degree, a consistency concern there. Now the parts of the coding module that I'm talking about here, it wasn't the code that necessarily changed all the time. All right.

A lot of times it was just a documentation. It was the same documentation, but it was worded slightly differently. Okay. That's a, that's a trivial change. Okay. Sometimes I've noticed that the code generator would add in, you know, extra error handling code. Other times it wouldn't. Other times it would try to insert its own main function and actually exercise the code in the module. Right. Because there wasn't anything that was exercising. It was just a standalone module. And then other times it wouldn't. Okay.

But the interesting thing was that as you ran that code on that same module over and over and over again, you got different results. Okay. And so from that perspective, there is a danger to using artificial intelligence because you don't know what result you'll get. You might run something on your code one time and get really good results and say, all right, this is rock solid. We're good to go. But then, you know, two months from now when you run that exact same, you know, maybe run that again over that same code because

the white space changed or you added a new function to that particular module, the results could vary greatly. Okay? And so does that mean that we should throw artificial intelligence away because the repeatability of it isn't very good? I think the answer to that is no. If you give the same code to a couple different humans, or even if you gave me the same code and you gave it to me today and then two months from now, I might write it slightly differently.

Jacob Beningo (16:28.683)
two months from now, right? The thing we need to be concerned with is does it provide accurate and good results? Does the system still perform the way that's supposed to? Do we still have good performance, efficiency? Is the end result still the same? Okay? And if the answer to those questions is yes, then small variations really ultimately come down most likely to the prompts that we are using, okay? How we're talking to the large language model, how we're asking for things. Even the...

input validation before we talk to the LLM, and then our output validation, right? And this is where it's interesting because there's technologies now that many of you have probably heard about, right? Agents. Agents are all the rage this year. Everything is about agents, agents, agents, okay? And the idea here is that with an agent, we could actually write some, we could actually create an agent that checks the output of the large language model.

validates it for whether it is consistent or not. And if it isn't, have it feed it back through the LLM again until we get the consistent result that we're looking for. Okay? And so the cool thing about agents is that we can adjust them to do that type of thing. We can actually give them much larger problems, have them break it down into smaller steps, have them interface with external tools. So for example, we could have an agent that is designed to run with our static, to drive analysis of our code that might go through and run static analysis or MISRA checks or...

style guideline checks and that sort of thing. And then based on those results, we could spawn off other agents that then go through and make changes to our code based on what the results of those analyses are. All right? And so as you can imagine here, ultimately, you can see that wherever you have a need for automation is where AI might make a lot of sense to add into your development cycle and into your workflow. Okay?

Now, obviously in a short podcast like this, I can't go into all the details about agents and how all of these types of things work and where you might want to use them in an embedded system. But one of the things that I can kind of point you to is that in the near future at the Embedded Online Conference, I'm actually going to be running a workshop on embedded AI, leveraging AI agents for smarter development. All right. And in that workshop, we're actually going to go through, I'm going to fully explain what an AI agent is, how it applies to embedded systems.

Jacob Beningo (18:51.509)
how you connect an AI agent to GitHub or even a GitLab if you want. You can basically connect to any of your Git repositories, but how you can actually spawn one off and have it kind of go to work for you. I'm going show you some tools that you can leverage for agents that can do a lot of the heavy lifting for us, the automated stuff, okay, that then alleviates us as embed developers or even as managers to be able to allow us to get more done because we're essentially tasking it out to...

an agent, okay? Kind of cool stuff. It'll give you some hands-on experience with AI-driven code generation optimization, which I think are actually really important ideas and concepts that need to be adopted into the embedded systems industry and how we build embedded systems. Now, I know that there are certainly a lot of arguments on where AI should be used and shouldn't be used in embedded systems. Certainly, people who are working in safety-critical systems are saying, no, no, no, we shouldn't be using it there, right?

And initial instincts are probably, yeah, no, we really shouldn't be using it there. But then again, look at the automotive industry today. Look at all of the AI assisted vehicles out there, self-driving vehicles or semi-self-driving or driver assisted vehicles. These are all using artificial intelligence. We know that they aren't 100 % accurate, right? But they can help offload things that humans are normally doing that are kind of mundane and repetitive, right?

like keeping the car between these two lines, right? Or hitting the brake pedal when someone in front of you is braking, right? It can kind of preemptively kind of start to slow the vehicle down for you automatically, right? Well, we can do these types of things as well with our embedded system workflows, okay? And those are going to be some of the things that I will talk about in this leveraging AI talk as part of the Embedded Online Conference. And certainly there's all kinds of other cool talks that are going to be part of that conference as well.

But for us today, we're trying to figure out what is the potential role of AI in embedded systems. And what I want to leave you with to think about today is that we shouldn't just abandon AI because it's inconsistent, it's changing too quickly, and maybe it just doesn't fit. Okay? I've seen statistics, and I don't know where they're getting these statistics from, but they claim that 70 % of companies and businesses have already started to adopt. They actually say they've adopted AI.

Jacob Beningo (21:17.419)
in their business. Now, what exactly does that mean? Of course, the studies don't tell you, right? They're trying to drive you to adopt a technology that may or may not be ready for what you're trying to do. But I will leave you with this. First of all, you shouldn't just say, no, AI isn't good enough for us yet, and we're just going to ignore it. OK, if you ignore AI, you will be left behind. OK, I've been spending months and months and months exploring the technology, what it can be used for, where does it fit? All right. I've actually been in

enough with it, and I know it's not perfect, but I see this actually when I look at, when I go in and I help companies modernize their embedded software skills and processes and workflows, AI is one of the things on my list that I go in and help folks with. Okay, it's on my list. We're going to be talking about this actually in the future. I have a seven step modernization framework that I'm going to be sharing with you, and we're going to go through each step and give you a feel for what you can do to modernize your embedded systems. We're going to be kicking that off here in the near future. Okay.

So that's kind of a spoiler alert there for you. But AI is a critical piece of that. Okay. And so that first step is don't ignore it. You at least had to be trying to figure out how can I leverage these things. All right. Even if it's for nothing more than saying, hey, I have a piece of code here. Let me drop it into my favorite LLM and just ask it, what does this piece of code do? How can it be improved to be more efficient? I'm using it on this architecture. How would you adjust it? Okay.

Hey, can you document this for me? All right. Those simple things right there are just really low hanging fruit on what you can use artificial intelligence for. All right. And so you shouldn't just ignore it. And I suspect as embedded systems developers, as managers, directors, I suspect all of you are thinking about how can I leverage this new tool to help me be more efficient, to get more work done, to make my systems higher quality, perhaps to make them safer. Okay.

So the role of AI right there is that we can't ignore it. It definitely has a role in embedded systems. And I think the biggest roles that we're going to see short term is for documentation, for helping us learn about the systems that we're building, helping us prototype things very quickly. There's nothing like being able to go and literally ask a machine to generate a function that has X functionality.

Jacob Beningo (23:42.071)
as Y inputs and Z outputs. And within a few seconds, you have a result, right? It might not be perfect. You might have to make hand adjustments. But I have found that in general, if I prompt in the right way, I can get code out of my system that is extraordinarily close to the way I would code things. Okay. Now, the LLM doesn't know how I like to code things until I tell it to do that. Okay. And so this might bring me to my next point.

If AI isn't working for you today, it's because you probably don't understand it well enough to understand what inputs to give it so you can get your desired outputs. All right. Just like in software engineering 101, garbage in equals garbage out. Right. And so what did we do there? We checked our inputs and our outputs. Right. Well, for working with AI, we certainly should check our inputs and outputs, right, validate them. But more importantly, we need to be very careful what inputs were actually

asking for, right? Sometimes we have to tell the AI the exact role we want it to play, the level of experience it has. We need to actually give it some details of what we're actually looking for, right? Because yes, it's a trained model, but it's been trained in such a generic way on lots of open source code that sometimes that's just not good enough. One of the techniques that I like to use when I'm working with an LLM is I keep my own coding styles. I keep examples of how my driver code looks.

I keep examples essentially in a folder that I vectorize and make available to the AI so that when I say generate a spy driver for me, it can actually go and look at my style guidelines, how I like to architect, not how I like to architect, but how my APIs are designed, how I use configuration tables, and so on and so forth. And so it can generate code that looks and feels a lot like Jacob Benigno's code.

except it's auto-generated and it can generate tables and those functions much faster than I can. And then I can come back behind it and just make sure that it's correct. And to some degree, that's almost a disappointment as a developer because some of the reasons we get into developing embedded systems, yes, we want to do great things in the world and everything else, but we love the code. And we have to almost change our mindsets that

Jacob Beningo (26:06.957)
At some point, we might just become code reviewers, right? Now, for me as an embed systems consultant, someone who works at the system level, helps people architect their systems, improve their processes, improve their skills. I do a lot of code reviews anyways, okay? So whether I'm reviewing a customer's code or code generated by an AI, it almost doesn't make any difference, right? Because I already am reviewing so much code as it is, right?

But what that will do, I think, is help elevate a lot of folks to be able to make sure that they're asking the right questions when they are reviewing code, right? Unless people find another use or role of AI is to allow one LLM to generate code and then use a completely different independent LLM to then review and validate that code, right? And we end up with a chain of AIs all watching each other to get a final result, right? And perhaps that is a future trend or somewhere where

you know, the embedded frontier is actually going, right? But for so long, we've felt that as embedded software developers, we're isolated. These technologies and things that are happening in the general embedded, in the general software engineering field doesn't affect us. But AI is one of those technologies that is not beyond what we are doing. It actually very much affects how we develop systems and where we're going to be going with our workflows in the future. OK. And so the role of AI is not to cast it aside. I think it is to adopt it.

Perhaps fervently, it may fail short term. You may try to do things with AI and find this just isn't working the way I want it to. It's not ready yet, but that's okay. What it will do is get you thinking about where this can be applied in your workflows. And when the time is right then, you will have already thought through where you might be able to use it, where you can apply AI to automate your development cycle further. And then those things will naturally just come into your workflows and you will become faster.

you'll become more efficient, you'll get to market a lot quicker, and overall, you'll be able to do more for less expense in the business, right? Perhaps instead of requiring a team of 30 to develop a new product, you'll just require a team of 15, okay? And to maintain a product, you don't need to hire a bunch of people to maintain it and have a whole bunch of technical debt, right? And so ultimately, the idea here is that AI should become an augmentation tool for you.

Jacob Beningo (28:28.513)
is Rola is going to make you as a developer the equivalent of a super programmer, right? know, years ago when I was coming up in the email systems industry, there was always these talks of super programmers, right? Guys who could generate 10 times as much code as everybody else or 50 times as much code, right? These were the people you kind of pushed off the side and just let them do their thing, right? You know, you didn't interrupt them because they were so productive, right? Well, this is kind of where with AI...

Every developer is going to have a team of agents that they can work with and manage to help them be super programmers and get the job done quicker. Now, that doesn't necessarily mean that we're going to lose the role of an embedded software developer, right? I actually think it's going to become an augmentation tool. There's already not enough technologists today, not enough people who can write code, who can write good code. And so all of this is technology is going to do is it's going to help elevate everybody's skill level and move us to the next level so that when we have that, you know, hey, we're

adding 200,000, 300,000 new tech jobs a month or something like that, and there just aren't enough people with the right skill sets, suddenly that offsets that. Okay? It's not a replacement necessarily. You're not necessarily going to lose your job, but you will become more valuable to your employer, to the businesses, to your customers because of AI and what it can do for you. So, with that in mind, if you have ideas of what AI might be used for,

feel free to shoot me an email or least some comments below if you're watching this on YouTube. There's certainly a lot of stuff that AI can do for you. And if you want to dig a little bit deeper into the role of AI in embedded systems development, attend my free workshop on design news related to creating your own software AI intern, and certainly help support the embedded online conference by attending my Leveraging AI in Embedded Systems talk.

That's going be a hands-on workshop, which will be a lot of fun, along with a whole bunch of other great speakers and talks and workshops that are going to be part of that conference. It's super inexpensive to attend. In fact, if you use the code BANINGO25, I think that gives you a $50 discount to be able to register. So please take advantage of that. And if for some reason that code doesn't work, email me at jacobatbaningo.com and I will get you the right code. Because the whole point of that conference is to get embed developers, managers, directors together to see

Jacob Beningo (30:50.789)
what the state of embedded systems development is. And I want you to be able to do that without having to travel around the world and be out of the office for five days to be able to do that. I want you to able to sit at your desk. And if you miss a talk, I want you to be able to go and watch the recording. Or three months from now, if you go, oh, there was a talk about this and I need that skill set now and I need to go watch that, but the conference is over. The cool thing about the Invented Online Conference, you can go and watch that on demand at any time.

Okay, so or if you need to refresh or anything like that. And we do that in a way that keeps it very inexpensive. Okay. It works out to less than 20 or $25 per month, I think. And that's if you buy it without, you if you attend the conference without a discount. Okay. So really something very inexpensive to be able to continue your education as a developer, a manager and a director, and maybe even as a business person. Right. So as a technologist.

So, all right, with that in mind, hopefully this podcast has given you some ideas on where you can apply AI today and its role in embedded systems. Okay, there's lots of other roles, but we'll have to save those for another time. All right, thanks. Happy coding. And I look forward talking with you next time.


People on this episode

Head Shot

Jacob Beningo

Host