Leases on cars stand way up, mainly because people need the latest and greatest tech and thus don’t want to buy a car to keep right now. That’s fueling quite a bit of development in the industry, not to mention the electrification of automobiles. The large number of systems required to make those a reality. The communication between them will make embedded GUI developers more aware of operating in a complex system.
Also, we think that medicare will observe quite a bit of development thanks to the pandemic. Developers will be making smaller, more convenient devices to diagnose infections rather than having to send things off to a large-scale lab. In my mind, the moon-shot would be to have equipment that could take a virus profile, which would accordingly get uploaded into a database.
Such a database would be used in a handheld device that can provide you positive or negative results against that profile in seconds. It would take a lot of creativeness. But I think embedded GUI developers are already at the forefront of making that a reality. We’ll possibly have to take that in stages, making detection smaller and cheaper.
Thus, we can have one lab unit per testing area that can only detect COVID-19 and probably a few other conditions. Ideally, it would be prepared to detect the next pandemic by making the detector reprogrammable. It’s simple to say and hard to do, but embedded GUI developers are greatly creative, and they’re going to figure out how to do it!
The rapid growth of the IoT, 5G, AI, and cloud/edge computing
The tremendous impact of this development, which will resume in 2021, is the sensation of continuous integration/continuous deployment. Companies are pushing out software updates rapidly than ever.
This needs a rigorous set of tools to inspect code quality for potential pitfalls. It requires automated testing to verify that the software conforms to the software specifications. The complicated part is capturing all of the requirements in these tests to make sure that what gets pushed out doesn’t break things or make a system unreliable.
That’s why continuous integration inspects source code to make sure it conforms to safe and durable coding practices. Then it subjects the code to a rigorous battery of tests embedded GUI design by the engineers to make sure that it’s doing the right things. The push to provide things faster is tricky in embedded software. If you get something wrong, it can render the system nonfunctioning.
There’s an old axiom that time is wealth. When you have to read through reams and reams of web pages to find small nuggets to help you get a fix or workaround, it goes for quite a bit of money as well as time.
Furthermore, if your code isn’t running rapidly enough for your needs, you wind up hand-optimizing it, which can cost a lot of time. Sometimes people resort to writing assembler code, which usually isn’t very convenient. Plus, the code gets confused and makes static analysis of the source less effective.
When you use quality development devices, it puts the onus of addressing these difficulties on the tools and not on you. Plus, when you run into problems, you have specialized experts you can call for help. Hence, you spend a little more money upfront. But you save a lot of time and money in the end analysis.
Now we see automated testing rolling out even to customer devices. It’s evident that subjecting code to more formalized and computerized testing puts more eyes on the code. It used to be that code analyses were rare. As long as your code didn’t have bugs, you could be as sloppy as you needed, putting spaghetti code here, there, and everywhere.
With continual automated integration, you can’t get away with that anymore. You have to write your code using best practices. If you don’t, everyone can see it in the outcome of the continuous integration system. As people, we find new and better ways to add to automated testing. It will compel people to use local copies of code analysis while desk-checking their code before it goes into a formal build.
They will like to know if their code will pass muster before everyone else sees the continuous integration outcome. Research like the ACM paper, which we referred to in a white paper by IAR Systems. They have shown that the sooner you put that kind of feedback in front of a developer, the more greatly they treat it.
If you leave it as part of a nightly build procedure where the developer gets feedback the next day, such problems are treated less seriously due to the “survivor effect.” But as the checking gets more strict, people are going to like to check their code more quickly