Agile Development in Automotive [Pt. 3]

The automotive industry has traditionally been a bastion of structured development. Yet, as the digital age advances, there’s a growing need for more flexible practices. Unlike more traditional development processes, the agile methodology is non-linear and allows for increased adaptability — especially when making last-minute changes.

This is the final article in our three-part series (part 1| part 2) where we explore how AI impacts the automotive industry. In the first, we dove into the need for new tools in the software development process while the second looked at the need for innovation in process as well as technology.

Embracing controlled agility 

Agile development in automotive isn't about recklessly pushing new versions — though it might work that way in other industries. Cars are safety-critical machines, and there's no room for error. But this doesn't mean the industry can't benefit from an agile approach

By implementing controlled agile processes, developers can ensure small updates don't adversely impact the entire vehicle. This approach allows developers to make small, iterative changes while still meeting automotive industry regulations.

Benefits of iterative development 

From a developer's standpoint, the agile approach offers many advantages. Humans find it challenging to tackle large tasks head-on so it’s practical to break things down into more manageable pieces. When presented with a large task, like developing a brand new function, it can feel overwhelming. Breaking this down into smaller, more manageable chunks better fits natural human behavior, allowing for more productivity and flexibility. 

Developers can be more efficient by focusing on specific functions in phases and releasing them in small steps. This iterative process not only increases productivity but also ensures that each function is thoroughly tested before proceeding. This is vital when it comes to vehicle safety.

How AI tools can support the agile development process

Artificial intelligence tools have the potential to streamline the development process. For instance, consider the task of tracking bugs in a system. Traditional systems often require manual searches, leaving developers feeling like they’re looking for a needle in a haystack. 

AI can assist in understanding customer needs, generating tests, and ensuring that these tests align with requirements. This technology can help developers resolve errors more quickly by using AI to map the entire software system and give insights into exactly which lines of code have changed, which need testing, and which are causing issues. This helps to track down bugs, including those from unpredicted scenarios and edge cases that might otherwise be difficult to find.

Automating these aspects allows developers to be more agile in their software development and testing by getting faster quality feedback and enabling them to focus on what they do best: developing innovative solutions for the automotive industry.

The automotive industry is on the cusp of a significant transformation. As software-defined vehicles become the norm, the need for agile development becomes more important than ever. By integrating these methods and leveraging AI tools, developers can better innovate while improving efficiency.

 

Click here for more insights into the future of automotive software development.


Part 1| Part 2

Balancing Innovation and Process in Automotive Software Development [Pt. 2]

As the automotive industry grapples with the challenges of modernization, it's essential to understand that innovation in automotive software isn't just about the development of new features. It's equally about refining and redefining the processes that support it.

This is the second article in our three-part series where we explore how AI impacts the automotive industry. In the first, we dove into the need for new tools in the software development process.

The need for process innovation

Software innovation is undeniably crucial, especially as consumers begin to demand more high-tech features such as autonomous driving capabilities. However, the real challenge lies in ensuring that developers are also innovating the processes used to build automotive software. Changing human behavior, especially in a legacy industry such as this, is no small feat. The serial production of software — which is akin to a manufacturing production line — may offer control but is no longer the most efficient or effective way to approach software development.

What’s needed is a more agile approach (more on this in the third part of this series), one that involves smaller steps and innovative testing methods, such as virtual environments. Complex software demands process innovation, and the industry must rise to meet this challenge.

As we mentioned in our previous article in the series, the traditional way of matching customer requirements with the finished product was through the V-shape model. This is the way things have been done for a long time but it’s time-consuming and, often, inaccurate. Innovation isn’t just about adopting new technologies, it’s about thinking outside of tradition and considering what new processes might be possible with advanced tools such as those using AI.

The cultural shift

The journey to process innovation is as much about culture as methodology. Developers, who are often bogged down by the daily grind of fixing bugs and releasing software, may overlook the need to reevaluate their processes. As more tech-forward companies bring agility and innovation to the table, however, larger OEMs are beginning to take notice. These industry giants are now seeking insights from agile startups, indicating a promising shift toward a more collaborative and innovative future.

For developers who are already thinking in this way, it’s a case of looking at requirements, development, and testing, then considering how those processes could be improved using technology or new ways of working. 

A good way to start thinking about this is in terms of the challenges. Within the traditional methods of development, what isn’t working? Perhaps the testing process takes too long or it’s difficult to get updates out on time. Maybe it’s external problems such as supplier deliveries that are causing issues. Whatever it might be, an innovative approach to the process could be the answer, especially when backed up by technology.

For example, if the testing process feels cumbersome, the question should be asked, is running all tests, no matter the software changes, the best way of achieving software quality? Switching to a process that incorporates AI to detect the changes in the software and analyze the potential quality risks could be the solution. For example, Auto Detect from Aurora Labs can efficiently select which tests have the highest probability of failure due to the changes made in the software in the specific build. Rather than running all tests available, this means only the necessary ones will run, significantly reducing time while still ensuring test effectiveness.

Shifting left

The cost, both in terms of money and resources, of detecting and fixing software problems increases as the software progresses through the software lifecycle. For example,  traditional methods of software updates come with certain limitations, especially when it comes to the speed at which manufacturers can release updates. For instance, updating car software traditionally involves inefficient processes that are integrated and implemented after the software has been developed and installed in the vehicle ECU – a cumbersome and data-intensive process that’s far from cost-effective. However, AI technology, such as Aurora Labs’ Auto Update, now allows for software updates to be integrated as an integral part of the software development process and not as an afterthought. 

To leverage the power of this technology, it’s important to build the tools into the Continuous Integration and Continuous Deployment (CI/CD) process. This not only makes the process more efficient but also paves the way for faster and more agile software development.

As the automotive industry continues its journey into the digital age, the balance between innovation and process will remain at its heart. By embracing agile methodologies, creating a culture of continuous improvement, shifting left with new technologies, and integrating AI tools, legacy automakers can ensure they keep ahead of the curve in a rapidly evolving industry. 

If you’d like to learn how artificial intelligence could bring innovation to your software development processes, get in touch here.

Part 1| Part 3

The Need for New Tools in Revolutionizing Automotive Software Development [Pt. 1]

This is part one of our series.

Automotive software is undergoing a technological shift. With evolving architectures and ever-increasing customer expectations, the traditional tools and methodologies that once dominated are now being challenged. As we move to the era of software-defined vehicles, there's a pressing need for a new generation of tools that can keep pace with these changes.

This is the first article in our three-part series on AI software development tools, where we explore how this technology impacts the automotive industry.

V-shape development and AI's role

Historically, the automotive industry has relied on the V-shape development model. This model begins with customer or OEM requirements on one side and culminates in tests to ensure these requirements are met on the other. Traditionally, this process was manual, involving extensive document reviews to ensure tests aligned with requirements.

However, with the advent of AI, this is changing. Large Language Models (LLMs) can now read and comprehend these documents, understanding their context. By training AI on these requirements, it can bridge the gap between what the customer needs and the testing process. This approach not only streamlines the process but also ensures a higher degree of accuracy.

This is an area early on in the development process where AI can have a significant impact. With an understanding of specific requirements, this technology can ensure that the software fits those customer needs at every stage of the development process. This speeds up the time to market by ensuring the project is on track at all times. Without AI traceability, there’s the risk of developers producing software that’s not quite fit for purpose, which could lead to additional time needed to bring the code in line with the original requirements.

Limitations of traditional tools

The traditional approach to updating embedded software in vehicles is cumbersome. For instance, traditional update methods require the previous version of the software to be completely erased in order to make space for the latest version. Given that modern cars have more than 100 ECUs, this method becomes problematic, as well as time and data-intensive. This also makes it difficult to roll back to a previous version should the latest software cause an issue within the vehicle.

The industry's reliance on tools that build these embedded software images is a significant limitation. However, newer technologies are emerging that allow for updating only the changed parts of the software. This approach, while requiring the integration of new tools into the CI/CD process, offers a faster and more agile way to update software.

Aurora Labs’ Auto Update technology creates the smallest possible update file to be written to the next free space on the existing flash memory, eliminating the need to overwrite the existing software version and enabling instant rollback if needed. Utilizing AI and advanced algorithms means update files are 6x smaller than alternative differential technologies, directly affecting data transmission and cloud storage costs. In addition to the need for remote software updates during aftermarket service, there are great time and resource efficiencies to be realized during the product development and system testing (/pilot vehicles) stages.

AI's transformative potential

The potential of AI in revolutionizing automotive software development is vast. For many developers, AI is becoming more than an add-on, it’s an integral part of their toolkit. They see opportunities where AI can be used to develop and test code, bringing fresh perspectives and methodologies to the table.

The automotive industry stands at a crossroads. With the rise of software-defined vehicles, the tools and methodologies of the past may no longer suffice. Embracing new tools, such as those that use AI, is not just beneficial; it's essential. As the industry continues to evolve, those willing to innovate will lead the way, shaping the future of automotive software development.

If you’d like to learn more about the Aurora Labs suite of artificial intelligence tools, get in touch today.

 

Part 2| Part 3

Don’t Let The Cost of Over-The-Air Updates Skyrocket

Automakers are delivering more over-the-air (OTA) updates than ever before as they strive to keep up with customer demand and enhance their User experience. Tesla has been leading the way in this respect with one OTA update roughly every four weeks. This is only set to grow, and many automakers are beginning to catch up.

In our new 2022 automotive software survey, we found that over 40% of respondents expect each connected vehicle to receive between two and six OTA updates per year from 2025 onwards and nearly 20% expect between seven and 12 OTA updates per year. This still might be a little way behind Tesla, but it's clear that even more traditional car manufacturers are leaning on OTA updates to deliver new features, fix bugs, and even improve a vehicle's security and safety.

The challenge for automakers, however, is the cost of delivering these updates. Our recent cost consideration guide found that the cost of full image updates could be as much as $2.7 billion when you take into account the cost of data transmission, cloud storage, and dual bank memory for a single large OEM (10m+).

Even though legacy binary updates require endpoint integration costs, they can help an automaker save money. We estimate the cost of these types of updates to be around $1.8 billion per year.

However, there's another type of technology that can reduce costs even further. Line-of-Code Intelligence offers a clientless solution that creates small update files, significantly reducing costs in three key areas.

1. Eliminating the need for dual memory

Even though costs have come down in recent years, the use of dual flash memory can soon add up across thousands of vehicles. It's possible to mitigate $1.7 billion in costs using Line-of-Code Intelligence technology to create the smallest fully executable update file possible.

Where other update types overwrite previous versions and require dual memory to allow for a rollback in case of issues, a Line-of-Code update simply writes to the next free space on the memory, meaning nothing is written over, and all previous versions remain. Not only does this help save on initial hardware costs, but can extend the life of the memory by reducing write-and-erase cycles.

2. Reducing cloud and data needs

Line-of-Code Intelligence technology uses AI and advanced algorithms to make the update files six times smaller than binary diffs. This means automakers could save around $73 million in data transmission and cloud storage costs. On top of this, the smaller file size also improves transmission times, which helps get OTA updates out more quickly.

3. Clientless technology

With Line-of-Code updates, there's no need to integrate proprietary software onto every ECU. Additionally, the updates use the same file format as the original embedded ECU file (ELF, S-Rec, Intel HEX); this guarantees all ECUs can receive the necessary updates without extra integration work.

This can reduce integration costs by as much as $1.4 million but also speeds up the development and delivery process by using technology and file formats that are already integrated into the toolchain. This removes the challenge of adapting testing, production, and maintenance systems.

For vehicle manufacturers that are starting to see the benefits of software as a revenue generation tool and those who are looking to better serve their customers, OTA updates will play a large role in the future. In our new 2022 Automotive Software Survey, we found that 62% expect up to 10% additional revenue for OEMs from selling software features OTA by MY 2027.

In order to manage the costs of these updates and create a more sustainable business model, automakers should look to AI and Vehicle Software Intelligence to help solve the problem of skyrocketing costs. If you'd like to know more about how Line-of-Code Intelligence technology could help save you money, get in touch here.

Continuously Better — a Recipe for Winners

Making devices, processes, and even people continuously better is not a new idea. Case in point -- we were watching a documentary about Henry Ford last week and one of his main business principles was 'good isn't good enough', and he continuously made improvements to an already revolutionary factory floor. He implemented processes and technology -- mainly the conveyer belt - to make sure building the Model T was more seamless, bringing automotive parts to employees instead of employees going to find parts. Fast forward almost 100 years, and the same principle is executed by successful companies.

The browser wars were won because Google ensured Chrome was always being improved with seamless updates increasing speed, enhancing security and introducing new features. In the automotive world, where software is now a driving force, vehicle manufacturers are continuously making the consumer experience better with over-the-air software updates. The problem is they are not always seamless.

For example, a friend recently received a letter from his car manufacturer explaining that an update to fix the infotainment system was available. The options were to take the car to the dealer or to update the vehicle on his own. A link to instructions on how to do the update himself was in the text of the letter. Going to the noted website, he landed on a YouTube page with a video of how to do the update. When he went to his vehicle to follow the instructions -- they were totally incorrect, and the UI in the video didn't even match the UI in the vehicle. Not very seamless.

Tesla is always used as an example of how to best do seamless over-the-air updates offering new features and functions that consumers will look forward to and enjoy. On the other end of the spectrum, there are those that think updates are "Big Brotherish" and should not be allowed at all.

However, continuously better will always win. But, unlike mobile phones and laptops, 'continuously better' for the vehicle requires a great deal more effort on technology testing, quality assurance, third-party certification and regulation. The generation coming up in the world expects their vehicle to mimic their phone, and they want the same user experience. The generation building these solutions today is responsible to make sure 'continuously better' keeps the next generation safe while simultaneously meeting their expectations of personalized and satisfying user experiences.

Ghosts in the machine: why does software misbehave?

"There have always been ghosts in the machine. Random segments of code, that have grouped together to form unexpected protocols. Unanticipated, these free radicals engender questions of free will, creativity, and even the nature of what we might call the soul."

In the movie I Robot, based on the book of the same name by Isaac Asimov, Dr. Lanning coins the term "Ghosts in the machine" and goes on to explain why robots behave in an unexpected way and not as they were programmed.

These ghosts aren't limited to sci-fi. In fact, they're something we deal with every day in software development. As technology has become more complex, we're faced with deviations that mean software doesn't quite behave in the way we expect it to -- just like Dr. Lanning's robots.

We're not quite at the point where autonomous vehicles could develop their own will but it's true that computers, robots, vehicles, and other programmed machines create such ghosts of unexpected behaviour. Understanding why these glitches happen is a vital step in reducing their frequency and handling them when they do show up.

Let's explore some of the common reasons why software deviates from its intended behaviour.

Untested combinations of events

Testing a new vehicle is a very complex task. A vehicle model may have a high number of variations depending on the feature set, country of destination, and other parameters. This results in a variety of different versions of the vehicle software for a single model year, creating complex testing scenarios.

Despite a rigorous testing process, which includes specific combinations of events, caveats still exist. This is because it's difficult to predict all of the different scenarios a vehicle will face as there are so many variables that could affect the software at any one point.

The use of artificial intelligence in the testing process is a potential solution to this as it can help come up with combinations of events a human might not think of. The AI can create new scenarios based on the expected interactions of the code. This helps developers find new edge cases they may not have come across during a manual testing process.

 

Testing doesn't always reflect real life

As well as an untested combination of events, there's also the chance that a test suite might not cover a real-life situation. Tests might cover a very specific and narrow band of scenarios that can be predicted and controlled in laboratory testing, but life out on the road is often unpredictable -- especially when you take into account weather conditions, road type, number of passengers, etc.

After production, continuous monitoring of the software behavior, while the vehicle is on the road, can give information about real-life situations. This gives the tester a more accurate view and insight into the running code instead of a birds-eye view. AI technology can support this as the car is in use.

Glitches are often incorrectly written software

What the world refers to as a computer glitch or a software bug is often an incorrectly written piece of software. This can cause unforeseen behaviour that could lead to a software update or recall.

The reason for the incorrect software may vary. It's not because of bad developers, but because writing software for a vehicle is incredibly complex and can incorporate a lot of factors that can collide with each other. Perhaps a developer or architect neglects to take into account a specific input or measurement that may affect the behaviour of the specific function or module.

As vehicles transition to a set of computers (ECUs) on wheels, it's clearer than ever how real life can throw up surprises that just can't be replicated manually in the lab. Mistakes happen, making it vital that automakers adopt more testing and debugging capabilities. Data also plays a role here and it's crucial to be able to receive as much information as one can throughout the software lifecycle, all the way from development to maintenance.

Incorrect data

With incorrect data from the network, a car's software might behave strangely. This is because it's expecting specific types of data so it can react accordingly. If the data is incorrect, the car will be unable to respond in the manner it was originally designed. The reason for the incorrect data could be faulty flash memory, a sensor malfunction, or a bit error in a message on the network.

Some mitigation mechanisms are in place to overcome the problem of misinformation due to bit error -- such as code correction algorithms, CRC data validation algorithms, ECC flash integrity checks, and more. More types of data range limitations and checks are suited to verify the correctness.

Although these types of mechanisms are in place, even with the "correct" data, an error may arise from an unfamiliar combination of information. This could be something that seems so illogical to the human eye that it would have never been considered during the testing process. So even though the code is written correctly and was tested successfully, an error can still occur.

Data reception issues

A problem with data reception can cause lags in a system, which consequently causes operational delays. This can also be fatal if a safety system doesn't engage in the time it should. Such a scenario may cause brakes not to work when they should or airbags that don't deploy in time to ensure occupant safety.

Latency and lag in the propagation of data over the network are issues that are hard to overcome and may pose a grave danger to the vehicle, passengers, and bystanders.

Million Lines of Code -- Information is Beautiful

Modern vehicles are software on wheels, and they're getting more complex all the time. The average vehicle currently has 100 million lines of code (LOC), but this is forecasted to grow to 600 million LOC for a Level-5 autonomous vehicle. With more LOC, the chance of encountering ghosts in the machine becomes even greater. Understanding how these glitches occur and what vehicles are commonly recalled for can help us solve these problems before they get out of hand.

Leaning on artificial intelligence technology to support the development process is key when it comes to automotive software. Presenting new ways to debug and get a clearer view of what's happening in real-time is becoming imperative in order not just to develop a better, safer vehicle but also to shorten the time from when a software bug occurs to the point of finding a solution and deploying it to the cars on the road, incorporating it with the ability for fast deployment is even better.

Glitches don't always present a safety concern, but they should be treated seriously. Instead, they manifest as small issues that can cause frustration for drivers. Reducing the effect of these glitches on the end-user is vital for manufacturers. Even in cases where a glitch does appear, an over-the-air update is often enough to fix the problem. It's also important that automakers are able to quickly roll back the software to a previous version should a glitch appear following an update.

If you'd like to learn about how Aurora Labs can help you identify potential issues and improve the testing process during development, book a demo here.

 

Speed up Software Testing with Artificial Intelligence

On a complex piece of automotive software, testing newly deployed code is vital. With so many interdependencies between each function, those tests ensure any changes don't negatively affect other areas of the system. However, with the amount of code and its complexity increasing with every build, running every single test for every version of the software can take hours.

While this is a necessity for the system software before it is released for production or before OTA updates are to deployed, running all the tests for daily builds while still in development is hugely inefficient -- especially if only a specific function has been updated.

Identify all affected systems

Even when a new version of the software seems to only update one specific function, it's important to identify which other systems could be affected. The Line-of-Code IntelligenceTM technology developed by Aurora Labs maps all interdependencies to better understand the effect of any changes on other functions within the vehicle.

 

Eliminating test execution redundancy

To identify these dependencies, Aurora Labs' Auto Detect adds a layer of artificial intelligence (AI) to the software testing process. This helps to detect exactly which tests are needed for each software function, enabling the tester to focus on and only run the required tests, eliminating the need to re-run all tests every time a new version is committed to the software repository.

For example, if a system has 100 tests, Auto Detect will be able to select the right ones based on exactly what's been changed by an update -- including which other functions might be affected by the new code. This means that of those 100 tests, only 20 might need to run. This saves valuable time by ensuring only the necessary tests are performed.

By adding this AI layer to your development process, it's possible to decrease the time it takes to run tests. On top of the increased efficiency, you improve quality by ensuring dependent functions are also tested alongside those that have been directly updated -- without the need to run redundant tests.

If you'd like to find out more about how Auto Detect can improve the automotive software testing process, find out more here.

Improve Quality with 100% Test Coverage

Quality control is a vital part of vehicle software and it's even more vital when you consider the different sources that may be contributing to the code base. Code can come from your internal development team as well as through open-source software and third-party developers. While much of the code might seem stand-alone, this isn't the case and every new line could have a significant impact across the system.

These interdependencies present a challenge for quality assurance (QA) teams. Even when additional code might seem straightforward, there could be multiple dependencies that need to be tested as part of the QA process. Line-of-Code IntelligenceTM supports both developers and quality teams by delivering detailed insights into the coverage of your tests.

The road to 100% test coverage

In something as complex and as safety-critical as vehicle software, it's vital you have 100% test coverage. With so many interdependencies, this is often hard for a human to do alone. Auto Detect uses Line-of-Code Intelligence, which as the AI sets run, will be able to map all the software functionality paths and see which are being tested. With this visibility into your code base, you can begin to see what's covered by tests and, crucially, what's not.

In building this picture of the code base as a whole, the AI layer will give you greater visibility into test coverage as well as the behavior and performance of the software as the tests run. It's from this information that it's clear to see which functions have been activated with the current test suite as well as those that haven't.

Seeing the functions that haven't been activated allows your development team to see where additional tests might be required - or, potentially, see instances of superfluous code. This insight into a rapidly changing code base can help you achieve and maintain 100% test coverage reducing the risk of releasing untested software to production.

 

Improving software quality with AI

With an efficient path to 100% test coverage, you can improve the quality of your software. With all dependencies covered across numerous functions, you'll increase software development and functional safety compliance. This removes hurdles to productivity and can greatly improve time-to-market for new features.

Proper testing of software is vital in any industry but as vehicles continue to increase in complexity in a heavily regulated sector, 100% test coverage is crucial. To find out more about Line-of-Code Intelligence and how it might help your business, read more and book a demo of Auto Detect here.

Will open standards transform the automotive industry?

The automotive industry is at a pivotal point in its evolution. With software-defined vehicles transforming the way cars are built, we're likely to see innovation in this area increase over the coming years. This will affect the way we buy cars as well as how new features and updates are delivered.

OEMs and suppliers are starting to use open-source software in the development of a vehicle, and its use will continue to grow, but open standards and APIs are going to disrupt the industry in new ways. This is something I've seen happen in finance, which has led to a rise of new businesses entering the market, shaking up a mature industry. The same could happen in automotive.

The building blocks of automotive software

Going forward, manufacturers will likely lean on open standards to build their own platforms -- much like using Lego bricks one by one to create something custom. This means they'll be able to take a component from an existing piece of software and connect it to other software from tier one suppliers. From this, they can build their own architecture while improving interoperability and enabling new avenues for innovation.

The use of open standards has numerous benefits to the automotive industry as a whole. These include:

  • Fewer limitations: With open standards, manufacturers won't be locked into a single technology, giving them a wider choice of suppliers to work with.
  • Improved interoperability: A set of standards makes applications more functional and interoperable, streamlining product development.
  • Less chance of becoming obsolete: File types in proprietary applications may become obsolete, and are often hard to convert. Open standards protect against this.
  • More chances to innovate: With more suppliers working to the same standards, this gives manufacturers the chance to be more innovative in the way they build their software.
  • Competition can flourish: With fewer barriers to entry new suppliers and, potentially, manufacturers, can enter the market.

There are already standards and initiatives in automotive that support interoperability, such as AUTOSAR, ECLIPSE SDV, and SOAFEE, as well as those that govern adjacent technologies (such as the Open Charge Point Protocol for the smart charging of electric vehicles). However, there's still a lot of potential for the automotive industry to adopt more of these standards.

Taking inspiration from FinTech

I come from a FinTech payment background, an area that is flourishing thanks to open standards. Over the last seven years, finance has gone through a lot of changes with young tech companies disrupting a mature industry. These new businesses have been able to succeed thanks to open standards and open APIs.

For example, open banking standards have allowed consumers to securely connect their bank accounts with third-party providers. This allowed a raft of businesses to enter the space offering tools and products that can do anything from analyzing your finances to facilitating payments between bank accounts across different countries and currencies.

Open standards work in established markets, which is why they've transformed the finance space. The automotive industry is likely to be next as it's mature enough to withstand the disruption while, arguably, being ready for a fresh shake-up.

If the automotive industry can take inspiration from what's happening in the finance space or, at least, do something similar, we could see some big changes in the coming years. Already, open standards and open-source software are making an impact on how OEMs develop their software, but with more buy-in and as open standards evolve, there's the opportunity for increased innovation, more choice, and ultimately, better vehicle software.

AI insights increase software quality in the automotive industry

While many people associate artificial intelligence (AI) in the automotive industry with autonomous vehicles, it's actually a powerful tool that's driving software development too. I recently joined James Carter and David Fidalgo on the Byte Off Podcast to talk about the impact AI is having across the industry.

AI has the potential to improve the outcomes for quality and support engineers during the automotive software development process. Here at Aurora Labs, we're using AI to recognize patterns in the behavior of the software, as how it behaves indicates how it runs. By identifying these patterns, you can begin to predict when and how a piece of software might fail before it actually does.

Using the right AI tools (such as Vehicle Software Intelligence) we're able to help car manufacturers find problems in their vehicles before they cause failures. This allows them to focus on improving quality instead of running around trying to fix problems.

The challenge in using AI tools across these areas is correctly identifying when it's appropriate. A lot of people see this technology as a silver bullet that will fix all sorts of problems, but it's actually most powerful in areas where the inputs are unknown or the variables are great.

This is why it's so often associated with autonomous driving because the technology has to be smart enough to understand that every road, every car, and every tree looks different and still be able to identify them as such. The technology needs to be able to recognize these patterns and learn from the information it is fed.

The shift left

What we're seeing now is a shift left, which means we're starting to use AI much earlier in the development process. The idea is to catch problems earlier as this makes them easier to fix, keeps costs down, and saves valuable time. It's similar to the process of building a house. If you find a problem in the construction of the walls and identify this early on, it's much cheaper to fix the issue than if the issue had been discovered after the house was complete.

The shift left in the automotive development world is similar. It's about moving your quality tools and insights earlier in the process so you're not leaving everything until the end. Fixing issues early on is much less expensive than patching them with over-the-air updates or worse, recalling your vehicles.

There are other trends influencing this shift. Both the move to CI/CD and agile software development methodology play a role. This means a car that might have been designed over six years, for example, can now be designed in a much shorter period. With these shorter development cycles, it's vital manufacturers are testing their software early enough in the process so as not to cause delays further down the line.

Another trend is the move toward the software-defined vehicle. With the software disconnected from the hardware platform and any specific model year, there needs to be more focus on the quality of that technology as it's driving so much within a vehicle - even across different models and generations, in some cases. With this, CI/CD, and agile workflows, there's an openness to try new AI tools to improve quality and give actionable insights early on at a much lower cost than you might have with more traditional development methods.

Testing the modern vehicle

Because of the complexity of a modern vehicle and now, the option to add features via a subscription, existing testing methods become far more difficult. If you're trying to write test scenarios for every permutation of variation and in every configuration, you can very quickly get to a point where an engineer physically can't write all these tests - and you certainly don't have enough time to run them, even with automation tools.

AI algorithms, however, can monitor the behavior of the software as it's being run and pick up on deviations automatically. Without any manually defined thresholds, the AI is able to detect changes in behavior. This allows engineers to focus their attention on what is changing and what could potentially affect the vehicle quality and performance.

This benefits both end-users and OEMs. The customer gets their update or subscription feature immediately and can trust that the new software isn't going to affect something else in the vehicle. Manufacturers, on the other hand, are able to improve quality quickly and more affordably while keeping customer satisfaction high.

Artificial intelligence is a powerful tool and something the industry is becoming increasingly open to. If you'd like to find out more about automotive software quality assurance take a look here.