ChatGPT als Code-Verständnis-Tool
93 % der Softwareentwickler geben an, dass unzureichende Dokumentation eine Ursache für verminderte Produktivität ist. Wenn Ihnen das keine Angst macht, habe ich eine andere Statistik, die Ihnen Angst macht. Untersuchungen zeigen, dass Entwickler 58 % ihrer Zeit mit Code-Verständnisaufgaben verbringen.
Dies wirft einige interessante Fragen auf. Was wäre, wenn ChatGPT das Code-Verständnis beschleunigen könnte, eine Aufgabe, mit der Entwickler mehr als die Hälfte ihrer Zeit verbringen?
Was ist Codeverständnis?
Beim Codeverständnis handelt es sich um die Zeit, die Softwareentwickler damit verbringen, bereits geschriebenen Code zu lesen, um zu verstehen, wie er funktioniert. Dies ist ein wesentlicher Bestandteil der Softwareentwicklung, da 99 % der Codierung auf der Verwendung von Codeteilen beruht, die jemand anderes geschrieben hat.
Wie kann ChatGPT helfen?
Jeder weiß, dass ChatGPT Sätze, Absätze und sogar Artikel zusammenfassen kann. Nicht jedem ist bewusst, dass dies auch für Code funktioniert. Code wird in einem Format geschrieben, das sowohl für Menschen als auch für Computer verständlich ist. Dies hat zur Folge, dass Code manchmal für Menschen verwirrend sein kann, ohne ihn Zeile für Zeile zu lesen. Hier kommt ChatGPT ins Spiel. ChatGPT kann einen Code schnell zusammenfassen und in ein Format konvertieren, das für einen Menschen schneller verständlich ist. Starten wir also ChatGPT und probieren es aus.
Eine verlorene Erinnerung
Während meines Studiums habe ich ein Python- und CUDA-Programm zur Verarbeitung von Astronomiedaten geschrieben. Wenn Sie mit CUDA nicht vertraut sind: Es handelt sich um eine API, die die parallele Verarbeitung auf einer GPU ermöglicht. Nachdem mein Parallel-Computing-Kurs beendet war, wurde das Projekt in den Schrank geworfen, als neue Unterrichtsprojekte begannen. Nachdem ich nun meinen Abschluss gemacht hatte, beschloss ich, es wieder herauszuholen und erneut mit der Arbeit daran zu beginnen.
Unmittelbar nachdem ich das Projekt in meiner Lieblings-IDE (natürlich VS Code) geöffnet hatte, wurde mir klar, dass ich mich kaum daran erinnern konnte, wie das Programm geschrieben wurde. Nachdem ich 20 Minuten lang das alte Projekt durchgelesen hatte, kam mir die Idee, ChatGPT die Arbeit für mich erledigen zu lassen. Aber in meinem Hinterkopf schwebte eine anhaltende Sorge. Ich wusste nicht, ob ich ChatGPT diese Aufgabe anvertrauen konnte. Bevor ich mein gesamtes Projekt ChatGPT anvertraute, beschloss ich, ein leicht überprüfbares Experiment durchzuführen. Ich habe einen kleinen Codeblock herausgeholt, den ich bereits verstanden habe
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]})
ChatGPT brauchte ein paar Sekunden zum Nachdenken und begann dann mit der Eingabe der folgenden Erklärung
Der Code liest Daten aus einer CSV-Datei mit dem Namen „GalaxiesWithDistances.csv“ und erstellt eine Liste mit dem Namen „Galaxies“. Es verwendet das Modul „csv“, um die Daten aus der Datei zu lesen und in der Variablen „reader“ zu speichern. Die erste Zeile der CSV-Datei wird mithilfe einer „ersten“ booleschen Variablen übersprungen. Für jede nachfolgende Zeile in der CSV-Datei wird ein Wörterbuch mit dem Galaxiennamen, der Rektaszension, der Deklination und der Entfernung erstellt und der Liste „Galaxien“ hinzugefügt.
Nicht schlecht, oder? Das hat ungefähr so lange gedauert, wie ich brauchte, um es herauszufinden.
Aber ich bin gespannt auf Ergebnisse und habe nicht die Geduld, diese eine Funktion nach der anderen auszuführen. Ich hebe das gesamte Python-Projekt hervor (zu finden unterhttps://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()
ChatGPT brauchte erneut ein paar Sekunden zum Nachdenken, bevor es mit der Eingabe einer Antwort begann
Der Code liest Daten über Galaxien aus einer CSV-Datei, berechnet den Abstand zwischen den einzelnen Galaxienpaaren und erstellt Kanten zwischen denen, die innerhalb einer bestimmten maximalen Entfernung liegen. Der Code generiert dann zwei Ausgabedateien: „graph_variables.cu“ und „graph_variables.cpp“, die Datenstrukturen zur Verwendung in CUDA bzw. regulären C++-Programmen enthalten. Die Ausgabedateien enthalten Informationen zu den Knoten (dh den Galaxien) und Kanten des Diagramms. Der Code enthält außerdem verschiedene Funktionen zum Berechnen der Koordinaten einer Galaxie, zum Zählen der Anzahl der Kanten mit einem bestimmten Startknoten und zum Bereinigen von Galaxiennamen.
Wow. Das ging viel schneller, als wenn ich es selbst gemacht hätte.
Aber ich bin noch nicht fertig. Es ist Zeit, mit dem schwierigen Teil des Projekts fortzufahren. Dieses knorrige Projekt umfasst über 500 Zeilen CUDA-Code, die in C geschrieben sind. Da ich ein freundlicher Mensch bin, werde ich sie nicht alle in diesem Artikel veröffentlichen, aber wenn Sie interessiert sind, können Sie sie sich gerne auf meinem GitHub ansehen (https://github.com/Tyler-Hilbert/SpaceTripPlanner/blob/master/ParallelBFS.cu).
Schließen wir es an ChatGPT an und sehen wir, wie es funktioniert
Auch hier brauchte ChatGPT ein paar Sekunden zum Nachdenken und begann dann, eine Erklärung einzutippen.
Dies ist ein CUDA-Programm, das eine Breitensuche (BFS) in einem Diagramm durchführt. Zunächst wird eine Struktur Nodemit Feldern für den Startindex der Kanten, die Anzahl der Kanten und die ID des Knotens definiert. Anschließend wird eine Kernelfunktion definiert Bfs_Kernel, die BFS mithilfe eines Arrays aus Scheitelpunkten, Kanten, Grenzen, besuchten Knoten, Entfernungen und Pfaden ausführt. Die Hauptfunktion initialisiert die Diagrammdaten, indem sie den Startindex und die Länge der Kanten für jeden Knoten festlegt, und ruft dann die Kernelfunktion auf.
Wow, das war ein hässlicher Low-Level-GPU-Code und ChatGPT hat es einfach wie ein Champion erklärt. Ich bin jetzt bereit, neue Funktionen zu meinem Programm hinzuzufügen und freue mich, dass ChatGPT mir beim Einstieg Zeit sparen konnte.
Nächste Schritte
Nachdem ich Ihnen nun meine Geschichte erzählt habe, wie ich mit ChatGPT ein altes Projekt wieder zum Leben erweckt habe, möchte ich Sie ermutigen, dasselbe zu tun. Probieren Sie Ihre eigenen Programme aus und sehen Sie, wie sie funktionieren. Wenn Sie außerdem Hilfe bei der Verwendung von ChatGPT zur Verbesserung Ihrer Codekohäsion benötigen, können Sie sich gerne an mich unter [email protected] wenden
![Was ist überhaupt eine verknüpfte Liste? [Teil 1]](https://post.nghiatu.com/assets/images/m/max/724/1*Xokk6XOjWyIGCBujkJsCzQ.jpeg)
