To become productive and proficient enough, junior software application developers often need months or even years of on-the-job training to avoid making dangerous mistakes that put systems at risk. Discerning the true intent of the feature in the code is no small feat, and developers today spend around 75% of their time searching through the source code to identify the code representing the feature that needs to be changed or modernized. .
While code finder tools, linters, and static and dynamic analysis tools can all help developers dramatically improve their efficiency and effectiveness, too many of these tools fall short when it comes to code analysis. ‘Really identify specific lines of code that need attention, especially with how entangled in a system that code often is.
Current approaches used by today’s AI help address this challenge, but they fail in many ways. Fortunately, using a new approach to AI dramatically improves a developer’s ability to effectively identify the specific lines of code relevant to the tasks they spend a lot of time on every day.
The shortcomings of today’s tools
As software repositories continue to grow unchecked to unprecedented sizes, those responsible for maintaining and preserving a system’s functionality say it’s getting harder to find bugs in code without machine assistance. Even worse, debugging consumes about half a developer’s time, and fixing and then committing a single bug fix can take days, weeks, or even longer.
From bug tracking to program repair and code synthesis, current tools can be useful for analyzing millions of lines of code, reporting errors, and suggesting fixes or best practices, but a number of challenges remain in existing code search tools. Navigating code in a tool like Sourcegraph accelerates the rate at which developers can build a mental model of code, helping them understand which parts of the code universe are most relevant and important, but the tool does not actually build the mental model. The tool only brings the developer closer to code that might be relevant to the desired behavior, but the developer has to reconstruct this mental model. With how time-consuming, mentally challenging, and fraught with error this effort can be, humans are ultimately fallible even if they use the best tools available to help them.
For example, security vulnerabilities are easy enough to identify with today’s tools, but focusing on all the relevant code to fix is difficult and time-consuming – much more so than writing the program in the first place. Often the relevant code is scattered across many files, increasing the complexity of the task. When debugging unknown programs, developers typically begin the process with a “why” question about their program’s behavior, but they must conceptualize that question into a series of actions and queries to resolve the problem at hand. As a result, programmers must track multiple aspects of the program’s detailed execution path simultaneously, however, the ability to do so is incredibly difficult for even the most experienced developers.
If a programmer does not understand how changing the code in one area of the code affects the system as a whole, even a minor change can break the whole system. Since it’s important for developers to understand what an app actually does, debuggers are not used as widely as one might expect, especially in functional programming environments.
Unfortunately, even the most advanced static and dynamic analysis tools, search tools, and linters are extremely ineffective at conveying this knowledge. Whether drawing pretty pictures, tracing code, seeing how code behaves with specific input data, or providing a summary of search words followed by complex changes, these tools help developers identify relevant code in different ways, but developers still need to conceptualize to highlight the intent of previous developers coded into the software and reveal the bug they are looking to fix. Ultimately, even with the most advanced tools, human software developers still need to build a mental model of what the code does by cracking the code directly to match the behavior they seek to change so they can Effectively modify complex elements and critical systems.
Leveraging the Power of AI to Overcome Gaps
From Intel to Amazon to Microsoft, some of the biggest tech companies in the world are turning to and creating AI-powered tools that offer code snippets to developers as they code. By leveraging AI, developers see productivity gains, reduced time spent writing code, and risk mitigation.
However, by using AI in a new way, the code repository can become a knowledge repository that represents source code the way a human thinks about the world, cause and effect. When the AI-powered tools know each of the behaviors in the source code, the tools can then “collaborate” with the developers to focus on the code that needs to change, without searching and understanding all the surrounding code. Using AI in this way can increase developer productivity by orders of magnitude.
By allowing developers to query this knowledge repository for specific code for a behavior, AI helps developers process only relevant code, allowing developers to make changes with confidence that they won’t break. not the whole system. Even better, developers are able to “propose” a change while they’re coding without recompiling or checking in the code, so the use of AI mitigates risk by checking if the change is isolated. This capability is also extended to the CI/CD pipeline by having the AI check the code after every build to ensure the behavior will never change in the future.
Using AI in this way focuses a developer on just the code that matters, without the excessive cognitive load of understanding code that is irrelevant to the task at hand. Unlike code search tools, linters, and static and dynamic analysis tools, AI ultimately empowers developers to safely, efficiently and effectively make necessary changes.
