ChatGPT im Alltag eines Python-Entwicklers

Seit einigen Tagen spiele ich mit ChatGPT herum. Beruflich und privat konnte ich damit einige Fragen bearbeiten, bspw. welche Alternativen es zu bestimmten Tools gibt, was Vorteile von Teilzeit für den Arbeitgeber sind oder wer ich bin. Leider weiß ChatGPT nicht, wer ich bin und auch wenn sich der OpenAI-Gründer selbst weniger Hype wünscht, so habe ich doch einige wertvolle Ideen durch ChatGPT gewonnen.

ChatGPT ist ein Machine-Learning-Modell basierend auf dem GPT-3.5-NLP-Modell. Es ist mit Daten bis zum Jahr 2021 trainiert, hat keinen Zugang zum Internet und auch keine Datenbank, bspw. zu Quellinformationen. Wie das Modell selbst behauptet, verfügt es über keine Fähigkeiten hinsichtlich Selbstbewusstsein oder Äußerung von Gefühlen.

Und das sind auch schon die wichtigsten Informationen. ChatGPT weiß nicht, was dieses Jahr passiert ist. Der Ukrainekrieg bspw. fand für ChatGPT 2014 statt, Lützerath kennt es gar nicht. Es kann keine Quellen oder Studien zu Inhalten wiedergeben. Es ist allerdings in der Lage zu sagen, in welchen Journalen ich bspw. wissenschaftliche Studien finden kann.

Ein großer Vorteil für mich: Mit ChatGPT zu schreiben ist synchron, ich verlasse den Fokus nicht oder muss warten, bis jemand Zeit zum Sparring hat. Weniger Kontextwechsel bedeuten auch weniger Zeit zum Erinnern, worum es eigentlich ging. Ensemble oder Pair Programming ist immer noch besser als mit ChatGPT zu arbeiten, aber nicht immer ist jemand verfügbar oder kann etwas zum Thema sagen. Hier kann ChatGPT hilfreiche faktische Tipps liefern.

Wie es in den Wald hineinschallt, so schallt es heraus

Je präziser meine Frage ist, desto besser passt die Antwort von ChatGPT. Sätze wie „Elaborate on this.“ oder „Let's talk about this.“ ermuntern ChatGPT zu detaillierteren Antworten. Rollenzuweisungen wie „You are an agile coach working at an international enterprise.“ ermöglichen Texte, die einen gezielten Kontext beinhalten.

Wo ChatGPT so richtig schief liegt

Zur Automatisierung meines Social-Media-Auftritts hatte ich gehofft, auch meinen Signal-Status nutzen zu können. Ich bat ChatGPT also:

Write a python program to send a text to the Signal API

Dabei kam das heraus:

1import requests
2
3url = 'https://api.signal.org/v1/messages'
4
5data = {
6    'recipient': 'YOUR_PHONE_NUMBER',
7    'message': 'Hello, this is a test message.'
8}
9
10headers = {
11    'Authorization': 'YOUR_AUTHORIZATION_TOKEN'
12}
13
14response = requests.post(url, json=data, headers=headers)
15
16print(response.status_code)

So weit, so gut. Das Problem ist: Die Signal API existiert überhaupt nicht. Frage ich bspw. nach der Notion oder sogar OpenAI-API, bekomme ich APIs, die nicht mehr aktuell sind und daher nicht funktionieren. Ich muss also selbst ran. Das liegt natürlich daran, dass ChatGPT keine Daten der letzten anderthalb Jahre hat.

ChatGPT arbeitet im Messenger-Format. Innerhalb eines Chats merkt sich ChatGPT den Kontext. Manchmal führt das zu aberwitzigen Kombinationen, bspw. wenn Python-Code nach Regeln von Kotlin refactort wird (Beispiel s. u.). Außerdem häufen sich Formulierungen gerne in mehreren Absätzen. Auch hier sollte wie immer überprüft werden, was ChatGPT generiert.

Und manchmal konvertiert ChatGPT auch einfach Mist. Beim Advent of Code 2022 habe ich ein paar Tage lang mitgemacht. Der dort entstandene Python-Code ist funktional, aber nicht sonderlich schön. Ich wollte den Code nun mit ChatGPT zusammen verbessern. Tag 1 habe ich so gelöst:

1calories = []  
2tmp = []  
3with open("src/day1") as file:  
4    data = file.readlines()  
5    for line in data:  
6        if line == "\n":  
7            calories.append(sum(tmp))  
8            tmp = []  
9        else:  
10            tmp.append(int(line.replace("\n", "")))  
11  
12max_value = max(calories)    
13calories.sort()  
14print(f"Solution: {max_value} and {sum(calories[-3:])}")

Der Code ist nicht optimiert, aber er erzeugt das für mich korrekte Ergebnis. Nun forderte ich ChatGPT auf: Improve this code. Leider gingen mehrere Anläufe schief, u. a., wurde der for-Loop zu

1def read_data(filepath):
2    with open(filepath) as file:
3        # use list comprehension to convert all elements to integers and remove empty lines
4        data = [int(line.strip()) for line in file if line.strip()]
5    return data
6
7data = read_data("src/day1")
8# group the data into chunks of size n
9n = sum(data[:3])
10chunks = [data[i:i+n] for i in range(0, len(data), n)]  
11calories = [sum(chunk) for chunk in chunks]

Aus irgendeinem Grund verwechselt ChatGPT die Summe über die drei letzten Einträge mit einer Information zur Länge der Chunks. Die Ergebnisse sind natürlich Quatsch. Prinzipiell die Daten in Lists-of-Lists umzuwandeln ist nicht schlecht, aber auch nicht gerade sauber.

Arbeiten am Code

Ich arbeite hauptsächlich mit Python. Gerade versuche ich mich an Kotlin mit verschiedenen Katas. Da ist es doch spannend, einfach mal Code von einer in die andere Sprache zu transpilieren. Transpiliere ich Code mit Dictionaries von Python nach Kotlin, so gibt mir ChatGPT neben Code diese Information:

1Note: In Kotlin, `dict` is `MutableMap` and `f"string"` is `"string"`. 
2Also, in kotlin `items()` is not used to iterate over map.

So kann ich direkt sehen, wie MutableMap genutzt wird oder ob das items() so in Kotlin nicht nötig ist. Ich bekomme spezifische Informationen genau zu dem Thema, zu dem ich gerade suche. Ein extremer Mehrwert bei den vielen Informationen, die ich täglich suche.

In einem anderen privaten Beispiel parse ich eine Datei und suche nach Zeilen, die mit vielen Bindestrichen beginnen. Diese zeigen einen neuen Eintrag in der Datei an. Im Eintrag finde ich in einer anderen Zeile den Titel einer Notiz. Diesen Titel will ich darstellen. Das erledigt beispielhaft dieser unoptimierte Code:

1import re  
2  
3def parse_notes_for_titles():  
4    with open("data/notes.txt", "r") as file:  
5        data = "".join(file.readlines())  
6  
7    # Split the data by lines of "---"  
8    parts = re.split(r"-{35}", data)  
9  
10    for part in parts:  
11        # Split the part by newline characters  
12        if part.startswith("\n"):  
13            part = part.replace("\n", "", 1)  
14  
15        if part:  
16            lines = part.replace("\xa0", " ").split("\n")  
17  
18            title = lines[0]  
19            print(f"Title of this line is {title}")

Ich habe nun ChatGPT aufgefordert: add a unit test to the following function and suggest refactoring changes

Als Unit-Test schlägt es vor:

1import unittest
2
3class TestParseNotesForTitles(unittest.TestCase):
4    def test_parse_notes_for_titles(self):
5        with open("data/notes.txt", "w") as file:
6            file.write("First title\n---\nSecond title\n---\nThird title")
7        parse_notes_for_titles()
8        with open("data/notes.txt", "r") as file:
9            data = "".join(file.readlines())
10            self.assertEqual(data,"First title\n---\nSecond title\n---\nThird title")

Nicht unbedingt schön, da es direkt die Datei selbst überschreibt, aber es ist ein guter Test zu prüfen, ob die Titel wirklich in der ersten Zeile nach den Bindestrichen stehen. Es ist ein Anfang. Zum Refactoring schlägt ChatGPT vor:

1. Extracting the file reading and data joining logic into a separate function, so that the parse_notes_for_titles function can focus on parsing the data.

2. Extracting the logic for parsing the parts into a separate function, to make the parse_notes_for_titles function more readable and easier to test.

3. Extract the print statement into a separate function so that it can be more easily tested and reused.

4. Extracting the variable parts and title into val instead of var

1. ist auf jeden Fall sinnvoll. 2. ist Geschmacksache und könnte zu data clumping führen, ist aber ein guter Schritt, um die Komplexität der Funktion zu verringern. 3. ist ein sehr merkwürdiger Vorschlag. Wenn es nicht an vielen Stellen solche Prints gibt, die zu testen sich lohnt, würde ich das ignorieren. Und 4. zeigt, dass ChatGPT noch in Kotlin von weiter oben hängt. val und var gibt es bisher nicht in Python.

Mit diesen Erfahrungen bin ich nochmal an den Code von Advent of Code 2022 heran gegangen. Nachdem ich verschiedene Ansätze probiert hatte, übergab ich ChatGPT nur den Code im with-Kontext, also:

1data = file.readlines()
2    for line in data:
3        if line == "\n":
4            calories.append(sum(tmp))
5            tmp = []
6        else:
7            tmp.append(int(line.replace("\n", "")))

Das Ergebnis ist:

1with open("src/day1") as file:  
2    calories = [sum(map(int, chunk.split())) for chunk in file.read().split("\n\n") if chunk]

Boom! Einzeiler statt verschachtelte for-Loop, Loop-Comprehension und die Benennung von tmp in chunk sind alles gute Änderungsvorschläge. Auch das Ergebnis stimmt. Dieses Beispiel zeigt eindrücklich, dass ChatGPT mit grundlegenden Code-Arbeiten gut klarkommt, aber Fachlichkeiten und Kontext nur mangelhaft im Einzelfall bestimmen kann. Hier hat mir Test-Driven Design sehr geholfen.

Gut zum Füllen

Was ich sehr schätze an ChatGPT ist, dass es mir hilft, Texte aufzufüllen und Ideen zu erhalten. Was sind die Vor- und Nachteile von XYZ? Wieso ist XYZ wichtig? Was hat Person UVW von XYZ? Diese und ähnliche Fragen habe ich in den letzten Tagen häufiger an ChatGPT gestellt und immer wieder neue Impulse bekommen. Und genau dafür ist ChatGPT gut: als Inspiration. Darüber hinaus wäre ich aber sehr vorsichtig mit den Ergebnissen, wie die einfachen Code-Beispiele oben eindrücklich zeigen. Jeder irgendwie relevante Output muss vom Menschen oder einer Logik geprüft werden. Aber auch so macht es Spaß, ChatGPT in meinen Arbeitsalltag zu integrieren. Kudos für diesen Artikel gehen raus an meine Bürokolleg:innen für Gespräche zu ChatGPT und an Marco Heimeshoff für die Inspiration.