Eu estava errado no meu último artigo, estamos olhando para o nosso futuro substituto

Recentemente publiquei um artigo avaliando se nós, como desenvolvedores, devemos ou não temer que o ChatGPT roube nossos empregos.

No artigo, pedi ao bot para criar um aplicativo To-Do com alguns resultados mistos. Minha conclusão - alerta de spoiler - foi que não estávamos em perigo, o ChatGPT me pareceu mais uma pesquisa no Google sobre esteróides, mas nada para se preocupar.

Hoje voltei a usar o bot, e acho que me enganei, tanto que agora acho que estamos vendo o nascimento de uma nova versão do desenvolvedor de software. Estamos olhando para o desenvolvimento assistido por IA e, potencialmente, o nascimento de nosso substituto.

Deixe-me explicar.

uma conversa interessante

Depois que alguns leitores comentaram em meu último artigo que eu deveria ser mais específico com meus prompts, decidi dar outra chance ao ChatGPT. Desta vez eu queria obter o código de um dos meus próximos artigos, um sobre algoritmos genéticos em JavaScript.

Então pedi ao ChatGPT: me dê o código javascript para resolver o problema do caixeiro viajante usando algoritmos genéticos

O problema do caixeiro viajante é um problema teórico clássico que geralmente é resolvido por meio de algoritmos genéticos, então não fiquei surpreso quando ele tentou me dar uma solução.

Digo “tentei”, porque foi isso que consegui:

const NUM_CITIES = 10; // number of cities in the sales route
const POPULATION_SIZE = 100; // number of individuals in the population
const MUTATION_RATE = 0.1; // probability of mutation
const CROSSOVER_RATE = 0.7; // probability of crossover
const MAX_ITERATIONS = 1000; // maximum number of iterations

// define the distance between each pair of cities
const distances = [  [0, 10, 15, 20, 25, 30, 35, 40, 45, 50],
  [10, 0, 5, 10, 15, 20, 25, 30, 35, 40],
  [15, 5, 0, 5, 10, 15, 20, 25, 30, 35],
  [20, 10, 5, 0, 5, 10, 15, 20, 25, 30],
  [25, 15, 10, 5, 0, 5, 10, 15, 20, 25],
  [30, 20, 15, 10, 5, 0, 5, 10, 15, 20],
  [35, 25, 20, 15, 10, 5, 0, 5, 10, 15],
  [40, 30, 25, 20, 15, 10, 5, 0, 5, 10],
  [45, 35, 30, 25, 20, 15, 10, 5, 0, 5],
  [50, 40, 35, 30, 25, 20, 15, 10, 5, 0],
];

// create the initial population
let population = [];
for (let i = 0; i < POPULATION_SIZE; i++) {
  // generate a random individual
  let individual = [];
  for (let j = 0; j < NUM_CITIES; j++) {
    individual.push(j);
  }
  // shuffle the cities in the individual
  for (let j = 0; j < NUM_CITIES; j++) {
    let k = Math.floor(Math.random() * NUM_CITIES);
    let temp = individual[j];
    individual[j] = individual[k];
    individual[k] = temp;
  }
  population.push(individual);
}

// define a function to calculate the fitness of an individual
const calculateFitness = (individual) => {
  let fitness = 0;
  for (let i = 0; i < NUM_CITIES - 1; i++) {
    let city1 = individual[i];
    let city2 = individual[i + 1];
    fitness += distances[city1][city2];
  }
  return fitness;
};

// define a function to select individuals for the next generation
const selection = (population) => {
  // calculate the fitness of each individual
  let fitnesses = population.map(calculateFitness);
  // normalize the fitness values
  let totalFitness = fitnesses.reduce((a, b) => a + b, 0);
  let probabilities = fitnesses.map((fitness) => fitness / totalFitness);
  // select individuals for the next generation
  let nextGeneration = [];
  for (let i = 0; i < POPULATION_SIZE; i++) {
    // choose two individuals based on their probabilities
    let individual1 = Math

Sim, o código está incompleto, o que resolvo mencionar: o exemplo de código anterior não está completo

Ao que respondeu:

Você está correto, o exemplo de código anterior não está completo. Aqui está o código completo para resolver o problema de vendas itinerantes usando algoritmos genéticos em JavaScript:

E então passou a me dar uma versão incompleta, mais uma vez. Estou assumindo aqui que estou enfrentando algum tipo de bug (afinal, este é um beta) ou limitação.

Mas como ele tem uma grande compreensão do contexto da nossa conversa, decidi arriscar ainda mais: por favor, continue escrevendo o código

Observe que não mencionei qual era o código, ou o que estou tentando resolver, o bot lembra de tudo isso, como uma pessoa faria, e passou a me fornecer o código que faltava antes. Ignorando, é claro, a função inacabada:

// define a function to perform crossover between two individuals
const crossover = (individual1, individual2) => {
  // choose a random crossover point
  let point = Math.floor(Math.random() * NUM_CITIES);
  // create the offspring by combining the two individuals
  let offspring = individual1.slice(0, point).concat(individual2.slice(point));
  // return the offspring
  return offspring;
};

// define a function to perform mutation on an individual
const mutation = (individual) => {
  // iterate over the cities in the individual
  for (let i = 0; i < NUM_CITIES; i++) {
    // with probability MUTATION_RATE, swap this city with another city
    if (Math.random() < MUTATION_RATE) {
      let j = Math.floor(Math.random() * NUM_CITIES);
      let temp = individual[i];
      individual[i] = individual[j];
      individual[j] = temp;
    }
  }
  // return the mutated individual
  return individual;
};

// define a function to evolve the population
const evolve = (population) => {
  // select individuals for the next generation
  let nextGeneration = selection(population);
  // create the new generation by performing crossover and mutation
  for (let i = 0; i < POPULATION_SIZE; i++) {
    // with probability CROSSOVER_RATE, perform crossover
    if (Math.random() < CROSSOVER_RATE) {
      let individual1 = nextGeneration[i];
      let individual2 = nextGeneration[Math.floor(Math.random() * POPULATION_SIZE)];
      nextGeneration[i] = crossover(individual1, individual2);
    }
    // perform mutation on the individual
    nextGeneration[i] = mutation(nextGeneration[i]);
  }
  // return the new generation
  return nextGeneration;
};

// run the genetic algorithm for a specified number of iterations
for (let i = 0; i < MAX_ITERATIONS; i++) {
  population = evolve(population);
}

// sort the population by fitness
population.sort((a, b) => calculateFitness(a) - calculateFitness(b));

// print the best individual
console.log(population[0]);

O código também usa as funções, portanto, se eu tivesse minha selectionfunção completa, poderia apenas copiar e colar.

Então eu perguntei: por favor me dê o código completo para a função de seleção

E aconteceu, peguei o código completo que estava faltando. Agora eu decidi juntar tudo e executá-lo.

Não fiquei surpreso quando não funcionou , o mesmo aconteceu comigo na minha tentativa anterior. Houve pequenos erros de digitação ou palavras-chave retiradas de outras linguagens, como um intao declarar uma variável, mas nada que um humano irritante como eu não pudesse resolver.

Depois de resolver tudo, tentei o código e funcionou. Bem, executou, mas a solução não estava certa.

O algoritmo fornecido estava errado. Em particular, o primeiro problema que encontrei foi a selectionfunção fornecida. A função precisava escolher 2 soluções diferentes e retornar a melhor, mas o código fornecido estava sempre escolhendo a mesma solução duas vezes.

Então disse: a função de seleção tem um problema , pode escolher o mesmo indivíduo duas vezes para a mesma iteração populacional

Observe as palavras em negrito, erros de digitação incluídos. Essa é a linguagem que eu esperaria usar com um colega trabalhando no mesmo código que eu. Não é assim que estou acostumado a lidar com um computador. Mas para minha surpresa, ele respondeu:

Você está correto, a implementação anterior da _selection_função tinha um problema em que poderia escolher o mesmo indivíduo duas vezes para a mesma iteração da população. Aqui está uma implementação revisada da _selection_função que corrige esse problema:

E passou a me dar um pedaço de código, que de fato corrigiu o problema . Não estou colando o código aqui, porque o código não é o ponto. O fato de ele ter entendido como resolver seus algoritmos originais com base em minhas informações é uma conquista incrível aqui.

Agora, o código não estava completo, eu ainda não estava obtendo os resultados que esperava. Se você já resolveu esse problema, saberia que tem um gráfico que representa um conjunto de cidades e as distâncias entre elas. A solução é uma lista de cidades que determina a ordem em que o vendedor deve visitá-las para conseguir o caminho mais curto entre todas elas.

Mas eu estava repetindo a mesma cidade várias vezes, então disse ao bot:

este código permite que a mesma cidade seja repetida como parte da solução

Leia novamente se quiser, mas, neste ponto, estou tratando o ChatGPT como um colega desenvolvedor. Este sou eu dizendo ao meu colega que há um bug em seu código, em algum lugar . Mas não tenho ideia de onde está o bug ou como resolvê-lo .

Ao que o bot respondeu:

Você está correto, a implementação anterior do código do algoritmo genético permite que a mesma cidade seja repetida como parte da solução. Para corrigir esse problema, você pode adicionar uma verificação à _crossover_função para garantir que a descendência não contenha cidades duplicadas

E então passou a me dar o código certo para a crossoverfunção. Eu nunca disse que o problema estava lá, nem mencionei os descendentes em qualquer lugar em minhas entradas.

A coisa conseguiu encontrar o problema, resolvê-lo e “decidiu” usar uma linguagem que fosse relevante dentro do contexto desse problema.

Desnecessário dizer que o código funcionou após essa alteração e consegui preparar meu código de amostra.

O que isso significa para a comunidade de desenvolvimento, então?

O ChatGPT não vai roubar nossos empregos, pelo menos ainda não.

No entanto, capacitará uma nova geração de desenvolvedores: o dev assistido por IA.

No momento, o bot não pode gerar código perfeito (o que é irônico se você pensar bem), nem compilar e executar aplicativos para você. Mas pode dar-lhe o ponto de partida para a solução que procura.

Ele pode fornecer o protótipo da sua ideia ou um algoritmo funcional que resolva um problema que você não conseguiu resolver.

É definitivamente uma ferramenta que pode ajudá-lo a desenvolver uma solução como se estivesse trocando ideias com um colega, só que pode fazer isso muito mais rápido .

Não é apenas uma pesquisa no Google sobre esteróides como eu pensava. É muito mais.

E é assustador.

A parte assustadora é o que vem a seguir

Por que o próximo passo é assustador?

Porque, se o ChatGPT pode gerar código com base em entrada humana como esta, quanto tempo você acha que levará para outra IA gerar um aplicativo básico com base em entrada semelhante?

A geração do código — que é a parte mais difícil — está quase 100% pronta (eles precisam descobrir como remover os erros de digitação e os bugs). Depois disso, basta vinculá-lo a um compilador e publicá-lo na nuvem.

E então, alguém sem conhecimento de desenvolvimento pode solicitar a criação de um aplicativo e publicá-lo.

E então, sim, ficaremos sem emprego.

Ou, pelo menos, será muito mais difícil conseguir um emprego porque o mercado de tarefas simples e aplicativos básicos será dominado por ferramentas de geração de IA.

Teremos que nos limitar a desenvolver os aplicativos que são realmente difíceis de codificar, aqueles que requerem muitas células cerebrais humanas, se é que você me entende.

Mas esse mercado também será dominado pela IA eventualmente.

O que faremos então? Essa é a pergunta que temos que começar a responder agora.