1
$\begingroup$

Artificial intelligence techniques have been successfully applied in many scenarios and to automate several jobs.

When will an artificial intelligence system do the job of a software developer or tester? Is this possible (for example, in the next 10 years)?

$\endgroup$
4
$\begingroup$

The ultimate goal of machine learning is to bypass the developer... When we will have a "master algorithm" that can learn how to generalize any function or algorithm from examples, it can essentially replace any developer, skip the 'development" stage, going from problem directly to algorithm.

We can't know when this will happen, but as we surrounded with multiple creatures (humans and animals) which can demonstrate learning algorithms and predictive model learning without any "developer" - we can assume that such an algorithm is possible.

If I would have to guess, I would say that we are probably very near the point where "developers" and "testers" will be replaced by learning algorithms. We could be a decade or two away from the point where people will not write any code or any testing at all. Programs and automation will be derived directly from describing the problems themselves in a natural language, visualizations or data collections. However, we still need some breakthroughs in combining feature learning with active memory, unsupervised learning, and artificial common sense.

| improve this answer | |
$\endgroup$
1
$\begingroup$

Artificial intelligence and, in particular, machine learning (ML) and evolutionary algorithms are already being used to automate the task of software development and, in particular, software testing. For example, take a look at the paper An empirical evaluation of evolutionary algorithms for unit test suite generation (2018). There are other examples, such as the Neural Programmer-Interpreter (2016), which is an ML model that can learn to write (very simple) programs or algorithms (e.g. it learns to perform addition).

Nevertheless, we are far from creating an AI system that is as capable as an average human software developer of developing software. In fact, I conjecture that this AI needs to be an artificial general intelligence (AGI), an AI that can solve as many tasks a human (at least approximately). In other words, software development is probably an AI-complete problem (i.e. a problem that probably requires an AGI to be solved, i.e. a narrow AI is not sufficient). Why do I say that? Because software development is a very complex and high-level task, even for humans, which not only includes writing code, but it requires the analyses of a problem (that is often very complex or novel), finding possible solutions, devising a plan to execute those solutions, etc., so it requires some form of creativity, and also common-sense knowledge, given that this artificial software developer would need to interact with other general intelligences (in particular, humans), which share some knowledge and assumptions.

When will an artificial intelligence system do the job of a software developer or tester? Is this possible (for example, in the next 10 years)?

So, AI techniques are already being developed to automate some tasks that a human software developer or tester does. However, it is very improbable that in the next 10-20 years an AI will completely replace the human in this very complex task. Maybe in 100-200 years an AI system will completely replace the human, but some radically important innovations or breakthroughs need to be made for this to happen. In any case, I do not think that machine learning (i.e. a data-driven approach) is sufficient to solve this problem because software development is not just about pattern recognition and stuff like that, but it also requires logical reasoning and planning.

| improve this answer | |
$\endgroup$
0
$\begingroup$

Imho - manual testers - yes.

Developers & automated testers are safety.

All tasks that can be described in a sequence of steps - algorithmically can be automated.

eg. Tricentis - the company already has technology - that can automate the work of manual testers.

Let's analyze this piece of code:

public class LoginTest {

    private LoginPage loginPage;

    @Before
    public void setUpTest() {
        loginPage = new LoginPage(DRIVER);
    }

    @Test
    public void shouldLogin() {
        loginPage.login(getProperty("ai.stack.username"), getProperty("ai.stack.password"));
    }

functions of this type can be easily presented in UI the form of a diagrams - adding algorithms to it - they will find generic use for many applications:

__

enter image description here source: https://www.researchgate.net/publication/338441733_Usage_of_Machine_Learning_in_Software_Testing

Where are the individual pieces are dockerized EC2 instances?


The more detailed algorithm, which can be use in automating software testing:

**Static Attributes Imbalance learning

Ensemble learning - is a process using which multiple machine learning models (such as classifiers) are strategically constructed to solve a particular problem. (eg.data passed by KNN + SVR + RF - and aggregate prediction)

Multiple Classifiers - aggregate clasiffier algorithms*(eg. Decision tree classifier, SVM, KNN,)*

Resampling** - mainly refers to Cross-validation and Bootstrap.

  • Cross-Validation - evaluating models by splitting into k smaller sets

  • Bootstrap - bagging - It also reduces variance and helps to avoid overfitting.

| improve this answer | |
$\endgroup$
  • $\begingroup$ Machine learning and evolutionary algorithms are already being used to generate tests for other software. I think that this answer could be improved if you search for research articles that propose ways of generating tests using machine learning or evolutionary algorithms. $\endgroup$ – nbro Sep 23 at 23:30
  • $\begingroup$ Sure - i’ill find some algorithms $\endgroup$ – Piotr Żak Sep 24 at 7:59

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.