ChatGPT como ferramenta de compreensão de código

Mar 01 2023
93% dos engenheiros de software relatam documentação insuficiente como fonte de diminuição da produtividade. Se isso não te assusta, tenho outra estatística que vai.

93% dos engenheiros de software relatam documentação insuficiente como fonte de diminuição da produtividade. Se isso não te assusta, tenho outra estatística que vai. A pesquisa mostra que os desenvolvedores gastam 58% de seu tempo em tarefas de compreensão de código.

Isso levanta algumas questões interessantes. E se o ChatGPT pudesse acelerar a compreensão do código, uma tarefa na qual os desenvolvedores gastam mais da metade do tempo?

O que é compreensão de código?

A compreensão do código é o tempo que os engenheiros de software gastam lendo o código escrito anteriormente para entender como ele funciona. Esta é uma parte essencial da engenharia de software porque 99% da codificação depende da utilização de pedaços de código que outra pessoa escreveu.

Como o ChatGPT pode ajudar?

Todos sabem que o ChatGPT pode resumir frases, parágrafos e até artigos. Nem todo mundo está ciente de que isso também funciona para o código. O código é escrito em um formato compreensível por humanos e computadores. O resultado disso é que às vezes o código pode ser confuso para os humanos entenderem sem lê-lo linha por linha. É aqui que entra o ChatGPT. O ChatGPT pode resumir rapidamente um trecho de código e convertê-lo em um formato que seja entendido mais rapidamente por um ser humano. Então, vamos iniciar o ChatGPT e experimentá-lo.

Uma Memória Perdida

Enquanto estava na pós-graduação, escrevi um programa Python e CUDA para processar dados de astronomia. Se você não estiver familiarizado com CUDA, é uma API que permite o processamento paralelo em uma GPU. Depois que minha aula de computação paralela terminou, o projeto foi jogado no armário quando novos projetos de aula começaram. Agora que me formei, decidi retirá-lo e começar a trabalhar nele novamente.

Gráfico de dados astronômicos pós-processados

Imediatamente após abrir o projeto em meu IDE favorito (código VS, é claro), percebi que quase não me lembrava de como o programa foi escrito. Depois de 20 minutos desagradáveis ​​lendo o projeto antigo, tive a ideia de fazer com que o ChatGPT fizesse o trabalho pesado para mim. Mas havia uma preocupação persistente no fundo da minha mente. Eu não sabia se poderia confiar no ChatGPT para essa tarefa. Antes de confiar todo o meu projeto ao ChatGPT, decidi fazer uma experiência facilmente verificável. Peguei um pequeno pedaço de código que já entendi

galaxies = []
with open('GalaxiesWithDistances.csv', 'r') as file:
    reader = csv.reader(file)
    first = True
    for row in reader:
        if first:
            first = False
            continue
        galaxies.append({'Name': row[0], 'RA': row[1], "DEC": row[2], "LY": row[3]})

O ChatGPT levou alguns segundos para pensar e começou a digitar a seguinte explicação

O código lê dados de um arquivo CSV chamado 'GalaxiesWithDistances.csv' e cria uma lista chamada 'galaxies'. Ele usa o módulo 'csv' para ler os dados do arquivo e armazená-los na variável 'leitor'. A primeira linha do arquivo CSV é ignorada usando uma variável booleana 'first'. Para cada linha subsequente no arquivo CSV, um dicionário contendo o nome da galáxia, ascensão reta, declinação e distância é criado e adicionado à lista de 'galáxias'.

Nada mal hein? Isso levou tanto tempo quanto eu levaria para descobrir.

Mas estou ansioso por resultados e não tenho paciência para fazer uma função de cada vez. Destaco todo o projeto Python (encontrado emhttps://github.com/Tyler-Hilbert/SpaceTripPlanner/blob/master/EdgeCreator.py)

import csv
import math

MAXIMUM_DISTANCE = 1 # The maximum number of light years a spaceship can travel before needing a refuel
GRAPH_NUMERIC = False # If the output GV file should output id number instead of galaxy names

# Get the X, Y, Z cordinates of a galaxy
def getCord(gal):
    theta = 15 * (int(gal['RA'].split(" ")[0]) + float(gal['RA'].split(" ")[1])/60)
    phi = int(gal['DEC'].split(" ")[0]) + int(gal['DEC'].split(" ")[1])/60
    x = float(gal['LY']) * math.cos(math.radians(theta)) * math.cos(math.radians(phi))
    y = float(gal['LY']) * math.sin(math.radians(theta)) * math.cos(math.radians(phi))
    z = float(gal['LY']) * math.sin(math.radians(phi))
    cord = (x, y, z)
    return cord


# Calculates the distance between 2 galaxies
def calcDistance(startGal, endGal):
    startCord = getCord(startGal)
    endCord = getCord(endGal)
    return math.sqrt(
        (startCord[0] - endCord[0]) ** 2 +
        (startCord[1] - startCord[1]) ** 2 +
        (startCord[2] - startCord[2]) ** 2
    )

# Counts the number of edges with the given start node
# This is used for outputting the length in cuda
def getStartCount(edges, start):
    count = 0
    for edge in edges:
        if edge['start'] == start:
            count += 1
    return count

# Cleans up galaxy name so it will work with DOT
def cleanName(name):
    replacements = [
        (".", ""),
        ("/", "_"),
        ("'", ""),
        ("=", "_"),
        ("-", ""),
        (" ", "_"),
        (" ", "_"),
        ("_", "")
    ]
    for repl in replacements:
        while repl[0] in name:
            name = name.replace(repl[0], repl[1])
    return name


# Read in galaxy data
galaxies = []
with open('GalaxiesWithDistances.csv', 'r') as file:
    reader = csv.reader(file)
    first = True
    for row in reader:
        if first:
            first = False
            continue
        galaxies.append({'Name': row[0], 'RA': row[1], "DEC": row[2], "LY": row[3]})

# Calculate edges
edges = []
for startGalIndex in range(len(galaxies)):
    for endGalIndex in range(len(galaxies)):
        if startGalIndex != endGalIndex and calcDistance(galaxies[startGalIndex], galaxies[endGalIndex]) < MAXIMUM_DISTANCE:
            edge = {'start':"{0:0=2d}".format(startGalIndex), 'end':"{0:0=2d}".format(endGalIndex)}
            edges.append(edge)

# Print
print ("********** \n EDGES \n******* \n ")
for edge in edges:
    print (edge)

# Print graph in CUDA code
f = open("graph_variables.cu", "w")
f.write ("// THIS IS A GENERATED FILE USING EdgeCreator.py\n")
f.write ("// Number of lightyears a spaceship can travel: ")
f.write (str(MAXIMUM_DISTANCE))
f.write ("\n")
f.write("Node node[")
f.write(str(len(galaxies)))
f.write("];\n")

completedStart = []
for i in range(len(edges)):
    if edges[i]['start'] not in completedStart:
        completedStart.append(edges[i]['start'])
        startS = "node[" + str(edges[i]['start']) + "].start = " + str(i) + ";\n"
        f.write (startS)
        lengthS = "node[" + str(edges[i]['start']) + "].length = " + str(getStartCount(edges, edges[i]['start'])) + ";\n"
        f.write (lengthS)


for i in range(len(galaxies)):
    nameS = 'node[' + str(i) + '].name = "' + galaxies[i]['Name'].replace("'", "") + '";\n'
    f.write (nameS)
    id0 = str( (int)((i - (i%10))/10))
    id1 = str(i % 10)
    idS = "node[" + str(i) + "].id[0] = '" + id0 + "'; node[" + str(i) + "].id[1] = '" + id1 + "';\n"
    f.write (idS)


f.write("int edges[")
f.write(str(len(edges)))
f.write("];\n")

for i in range(len(edges)):
    edgeS = "edges[" + str(i) + "] = " + str(edges[i]['end']) + ";\n"
    f.write (edgeS)

f.close()


# Print graph in regular C++ datastructure for sequential BFS (for comparison to CUDA)
f = open("graph_variables.cpp", "w")
f.write ("// THIS IS A GENERATED FILE USING EdgeCreator.py\n")
f.write ("// Number of lightyears a spaceship can travel: ")
f.write (str(MAXIMUM_DISTANCE))
f.write ("\n")

# Add nodes
for i in range(len(galaxies)):
    nameS = 'graph.AddNode("' + galaxies[i]['Name'].replace("'", "") + '");\n'
    f.write (nameS)

# Add edges
for edge in edges:
    edgeS = "graph.AddEdge(" +  edge['start'] + "," + edge['end'] + ");\n"
    f.write(edgeS)

f.close()

# Graph (dot) creator
f = open("output.gv", "w")
f.write("strict graph G {\n")
for edge in edges:
    if GRAPH_NUMERIC:
        eStr = edge['start'] + " -- " + edge['end'] + "\n"
    else:
        eStr = cleanName(galaxies[int(edge['start'])]['Name'])
        eStr += " -- "
        eStr += cleanName(galaxies[int(edge['end'])]['Name'])
        eStr += "\n"
    f.write(eStr)
f.write("}")
f.close()

O ChatGPT mais uma vez levou alguns segundos para pensar antes de começar a digitar uma resposta

O código lê dados sobre galáxias de um arquivo CSV, calcula a distância entre cada par de galáxias e cria arestas entre aquelas que estão dentro de uma certa distância máxima. O código então gera dois arquivos de saída: “graph_variables.cu” e “graph_variables.cpp”, que contêm estruturas de dados para uso em programas CUDA e C++ regulares, respectivamente. Os arquivos de saída incluem informações sobre os nós (isto é, as galáxias) e as arestas do grafo. O código também inclui várias funções para calcular as coordenadas de uma galáxia, contar o número de arestas com um determinado nó inicial e limpar os nomes das galáxias.

Uau. Isso foi muito mais rápido do que se eu tivesse feito isso sozinho.

Mas ainda não terminei. É hora de passar para a parte difícil do projeto. Este projeto complicado tem mais de 500 linhas de código CUDA escritas em C. Como sou uma pessoa gentil, não vou postar todas neste artigo, mas se você estiver interessado, sinta-se à vontade para vê-las no meu GitHub (https://github.com/Tyler-Hilbert/SpaceTripPlanner/blob/master/ParallelBFS.cu).

Vamos conectá-lo ao ChatGPT e ver como funciona

Mais uma vez, o ChatGPT levou alguns segundos para pensar e começou a digitar uma explicação.

Este é um programa CUDA que realiza busca em largura (BFS) em um gráfico. Ele primeiro define uma estrutura Nodecom campos para o índice inicial de arestas, número de arestas e ID do nó. Em seguida, ele define uma função de kernel Bfs_Kernelque executa o BFS usando uma matriz de vértices, arestas, fronteiras, nós visitados, distâncias e caminhos. A função principal inicializa os dados do gráfico definindo o índice inicial e o comprimento das arestas para cada nó e, em seguida, chama a função kernel.

Uau, isso foi um código de GPU feio de baixo nível e o ChatGPT apenas o explicou como um campeão. Agora estou pronto para começar a adicionar novos recursos ao meu programa e estou feliz que o ChatGPT tenha economizado meu tempo para começar.

Próximos passos

Agora que contei minha história de uso do ChatGPT para ajudar a trazer de volta um projeto antigo, gostaria de encorajá-lo a fazer o mesmo. Vá em frente e experimente seus próprios programas e veja como eles funcionam. Além disso, se você quiser ajuda para usar o ChatGPT para melhorar a compreensão do seu código, sinta-se à vontade para entrar em contato comigo em [email protected]