AI As A Future Or A New Reality For Software Developers?

Instead of competing with humans, AI developers may try to use algorithms to augment programmers’ work and make them more productive: in the context of software development, we clearly see AI performing human tasks as well as augmenting programmers’ work.

According to our research, programmers spend 35% of their time understanding code, 5% of their time writing code, 10% on other coding-related activities, and 50% on other non-coding activities — even with advanced computers, we don’t expect such tools to redefine the profession of a programmer anytime soon.

AI can assist programmers in performing small tasks more efficiently: AI can help to complete the code, teach the user how to use new features, and search in the code and beyond.

Unavailability of training data, resource requirements, and the interface between the AI and the user are all barriers to perfect AI.

Companies working on software development tools are rapidly developing the ability to productize AI-powered solutions for small tasks, so we expect to see more of these solutions in the near future.

People are increasingly exposed to AI in their personal and professional lives. JetBrains creates tools for programmers, and we believe the software development industry is no exception to this trend.

People employ AI in two ways:

Replace humans by completely automating some of their tasks.
Enhance humans while keeping them as the central figure in the process.

Algorithms already write code, but human developers don’t have to worry about being replaced. Surprisingly, this is not because it is impossible to teach computers programming skills, but because it is impractical. Three major factors are impeding AI progress:

There is a scarcity of training data.
Computing power is limited.
The interface between algorithms and people is complex.

Many mundane tasks, such as code completion, code search, and bug detection, are now powered by machine learning to augment the work of human programmers.

How Do People See AI?

When most people hear the term “AI,” they envision a computer replacing a human, performing the same task but better in some way: faster, cheaper, with higher quality, or all of the above. Playing chess or Go, writing poetry, and driving a car are examples of such tasks.

Some people are excited about the prospect of computers freeing them from routine tasks, while others are skeptical. The latter may argue that machines are still far from matching what humans are capable of.

“How are you going to teach a computer to do this?” questions frequently imply that you won’t be able to. Here are a few examples of previous similar questions:
In Go, the number of reasonable moves exceeds the computational resources available.

How do you intend to replace human intuition? According to this 1997 article, experts estimated it would take a hundred years.

How do you train a self-driving car to recognize a puddle and slow down? Because computers can already play Go and drive cars, these questions have become obsolete. This gives us reason to believe that unanswered questions of this nature will be addressed in the future. Whatever field we choose, computers are getting closer to matching human abilities.

However, replacing a human being is not always practical. Instead of competing with humans, AI-based technology developers may opt for a different product strategy, attempting to use algorithms to augment programmers’ work and make them more productive.

In the context of software development, we clearly see AI performing human tasks as well as augmenting programmers’ work.

Replacing the Human Programmer

The announcement of GitHub Copilot powered by OpenAI reignited debate over when and if computers will replace human programmers. Skeptics who believed that replacing humans was impossible always asked: How do you explain to the machine what your program should do?

The answer is straightforward. You define what you want in natural language, give the function a name, and, optionally, write a few lines to get it started. The rest is then filled in by Copilot, much like a real programmer would.

Some people are impressed by Copilot’s intelligence. Others have noted the flaws in its work and believe they are significant enough to suggest that human programmers will be required for the foreseeable future. Another group of reviewers notices the same flaws but concludes that Copilot is a terrible and dangerous tool that should not be touched with a barge pole.

What is the main flaw they highlight? Copilot programs are frequently verbose and difficult to read.

R. Minelli, A. Mochi, and M. Lanza estimate that programmers spend roughly 70% of their coding-related time understanding the code, while writing accounts for only about 5%.

Important Takeaways

According to our research, programmers spend 35% of their time understanding code, 5% writing code, 10% on other coding-related activities, and 50% 카지노 on non-coding activities — even with advanced computers, we don’t expect such tools to redefine the programming profession.

Unavailability of training data, resource requirements, and the interface between the AI and the user are all barriers to perfect AI. Companies working on software development tools are rapidly developing the ability to productize AI-powered solutions for small tasks, so we expect to see more of these solutions in the near future.

Verbose and unclear machine-generated programs could make the already difficult “understanding” part even more difficult. The cognitive load on the human side of the tandem remains: the programmer must still comprehend what the algorithm writes. How long can humans keep up with the computer’s pace? Small tasks may be sped up by having AI write code, but large projects may not be.

Consider revision control, which was implemented in the 1970s. The ability to track and undo changes greatly expanded the boundaries of what people could comprehend. It enabled large groups of programmers to collaborate, allowing for the development of more complex systems. That was game changer for the entire industry.

Copilot is an excellent research result that demonstrates AI’s potential. It accomplishes what many thought was impossible. Nonetheless, we do not anticipate such tools.

When you start typing a search query in Google, it takes the characters you’re typing and begins to suggest full query options. Source code editors offer very similar functionality to programmers.

The first code completion versions appeared in the XX century and calculated the frequencies of the words in the project. They displayed the most frequently occurring words that began with the characters entered by the user. A frequency-based approach like this worked well enough to boost productivity. People improved the algorithm over time by adding heuristics on top of the frequency idea, but the desire to provide the exact word the user desired drove us to use machine learning to sort the suggestions.

The amount of information available to us to determine the best suggestion is so vast that it is impossible to create a deterministic algorithm that takes it all into account. We’d have to deal with far too many exceptional cases.

For example, consider the following general rules. The closer the token is defined to the location where the programmer is currently editing, the more likely it is. Furthermore, the standard language libraries can be sorted by popularity, and tokens from the least popular libraries can be deprioritized. All of this being said, imagine you’re working on a Java source code editor (which is exactly what we do at JetBrains) and you start typing “Co”. Which of the two suggestions below do you prefer?

On the one hand, red-black trees are used in the editor. On the other hand, the java.awt package is rarely used in industry. However, when we say “Color,” we most likely mean java.awt.

We have over a hundred factors that influence the ordering of suggestions. Is the suggestion a user-defined symbol, a standard language library, or an imported third-party library? Is the suggestion to be inserted at the beginning or in the middle of a line? Is there a dot in front of this location? How many hours per day does the user work on average? Do they have the suggestion definition open in a different editor tab right now?

A source code editor is a difficult piece of software to use. There are hundreds of operations that can be used to increase productivity. Unfortunately, programmers cannot possibly know them all.

We can promote certain functionality by displaying tips on startup, but remembering these tips when it comes time to use them may be difficult. Most programmers have a set of fifty favorite commands. We must present a user with two or three actions that will be especially beneficial to them based on their work patterns and habits when using intelligent tips.

These personalized recommendations can be generated using AI. For example, if the user frequently performs cut/paste operations within the same screen, we may want to inform them about the code move operation:
The simplest method for accomplishing this is known as “collaborative filtering.” It is used in modern music, video, book, and product recommendation systems. There are two fundamental steps:

Find the users “similar” to the given one.
Find what these users do that the given user doesn’t do yet and base our recommendation on that difference.

Finding similar users for content recommendations is fairly simple: if our target person likes the same ten movies as a group of other people, but hasn’t seen one more that everyone in this group likes, it’s a pretty safe bet. The only caveat is to avoid overly popular films that almost everyone praises. Likes for “The Godfather” or “Forrest Gump” don’t reveal much about the user’s tastes.

It’s a little more difficult with the source editor features. Because there are no features of the same genre or cast, we must examine smaller behavioral patterns. How long does the user spend debugging? How frequently do they modify existing code? How quickly can they type? Do they write tests before or after coding, if at all? Taking these factors into account will determine user similarity and recommend tools that will be useful given the known behavior patterns.

Exploring the Code and Beyond

Many software products, from web search engines to online stores, include search functionality. This functionality is also available in source code editors: developers frequently need to find something in their code, documentation, and tool configuration options. These are two very different types of information, and software development tools usually look for them in separate places.

We intend to provide a single search function within the source code editor that can be used to find any of the above domains while accounting for synonyms and typos. Because so many people work on search algorithms, one would think that a standard reusable solution would exist, but each domain has unique details that necessitate the development of the search functionality separately.

When different item types with similar names are available in the project, complications arise. If a user types “format” into the search box while their project contains a file named Formatter.java, are they looking for that file, standard formatting library functions, or IDE functionality to reformat their project’s code?

Machine learning works by combining search results from various sources and weighing them against one another. Text matching, the user’s search history and previous preferences (for example, do they ever click on the file search results? ), the content of the user’s project, and what the user was editing immediately before issuing the search query are all factors influencing the decision. Writing a deterministic algorithm that takes all of these factors into account does not appear feasible, whereas machine learning methods extract patterns automatically.

The Cost Of Introducing AI

The sum of all minor AI-powered improvements in user productivity can result in a significant overall increase. It does, however, come at a cost. AI-based systems work well in most cases, but there are some situations where they can provide weird results. Providing such results to the users costs us some of their trust. Each time we replace strict rules with an AI-powered decision-making system, we have to decide whether to make a tradeoff. We can improve our average decision quality, but we may lose some user trust in the process. It would be ideal to design flawless systems in which trust is not lost due to poor suggestions, but there are several obstacles.