Foto: Something Special - shutterstock.com
Schon die Preview zu GitHub Copilot im Jahr 2021 ließ das Potenzial von generativen KI-Tools im Bereich der Softwareentwicklung erkennen. Zwei Jahre später wird Copilot immer besser, kostet Geld (auch für Einzel-, beziehungsweise Privatpersonen) - und hat außerdem Konkurrenz bekommen.
Letzteres hat auch dazu geführt, dass sich der Anwendungsbereich der Coding-Assistenten auf Generative-AI-Basis signifikant erweitert hat. Und inzwischen können die Tools mehr als nur Code zu generieren, wie unser Test zeigt.
3 Gen-AI-Tools für Entwickler im Test
Zunächst ein kurzer Überblick über die in diesem Artikel getesteten Gen-AI-Coding-Tools:
Amazon CodeWhisperer konkurriert als "Coding Companion" direkt mit Copilot. Das Tool lässt sich ebenso in die IDEs Visual Studio Code und JetBrains integrieren, sowie generiert Codevorschläge als Reaktion auf Kommentare und -vervollständigungen auf Grundlage vorhandenen Codes. Zudem kann das Amazon-Tool Sicherheitsprobleme aufdecken. CodeWhisperer unterstützt fünf Programmiersprachen umfassend und weitere zehn in geringerem Maße. Optional ist CodeWhisperer sowohl in der Lage, seinen Code zu flaggen und protokollieren als auch Codevorschläge zu filtern, die Open-Source-Trainingsdaten ähneln.
Google Bard stellt eine webbasierte Schnittstelle zum Large Language Model LaMDA (Language Model for Dialogue Applications) dar. Bard kann inzwischen bei Programmieraufgaben und angrenzenden Themen unterstützen. Sollte Bard Code ausgeben, der potenziell einer Open-Source-Lizenz unterliegt, werden die Quellen und entsprechenden Informationen mitgeliefert. Darüber hinaus kann Bard auch Code erklären.
GitHub Copilot X ist eine ganze Reihe von Preview-Features, die den ursprünglichen Copilot um Chat- und Terminalschnittstellen, Support für Pull Requests und GPT-4-Integration erweitern. Um auf die Funktionen von Copilot X zugreifen zu können, ist aktuell ein Copilot-Abo obligatorisch. Das ermöglicht es Ihnen, sich auf eine Warteliste setzen zu lassen (in unserem Fall dauerte es circa vier Wochen, bis die Einladung zur Teilnahme erfolgte).
Wie die Tools getestet wurden
Für diesen Test haben wir den drei getesteten Gen-AI-Coding-Tools eine etwas komplexere Scraping-Aufgabe gestellt: die Artikel auf Infoworld.com unter Berücksichtigung verschiedener Kriterien aufzulisten. Dazu bekamen die Tools jeweils ein Outline - aber keine zusätzliche Hilfe. Die Tools, die Code-Erklärungen unterstützen, durften sich dafür zudem an einem Python-Codebeispiel aus einem MIT-Einführungskurs in die Informatik versuchen.
Das Outline für die getesten Generative-AI-Coding-Tools:
Scrape infoworld.com front page:
Open https://www.infoworld.com/
Find all articles by looking for links with 'article' in the href; extract title, author, date from each
List all articles alphabetically by title; eliminate duplicates
List all articles alphabetically by author last name
List all articles latest first
Amazon CodeWhisperer
Geht es darum Code zu generieren, kann Amazon CodeWhisperer Entwickler auf vielfältige Weise unterstützen. Details und Tutorials in Videoform sowie eine umfassende Dokumentation finden Sie auf der Ressourcen-Seite von Amazon Web Services.
Das Large Language Model (LLM), das CodeWhisperer zugrundeliegt, wurde laut Amazon auf Milliarden von Codezeilen trainiert (sowohl Amazon-eigener als auch Open-Source-Code). Das ermöglicht es dem AI-Coding-Tool zum Beispiel, Code-Vorschläge nicht nur auf Grundlage von Kommentaren, sondern auch unter Berücksichtigung des unmittelbaren Code-Kontextes (andere Inhalte, die in der IDE geöffnet sind) zu unterbreiten. Darüber hinaus ist CodeWhisperer in der Lage, Python-, Java- und JavaScript-Code auf Sicherheitslücken zu überprüfen und Maßnahmen vorzuschlagen, um diese zu beheben. Die dafür nötigen Daten beziehungsweise Schwachstellenlisten entstammen unter anderem dem OWASP und verschiedenen Best Practices.
CodeWhisperer generiert am zuverlässigsten Code in den Sprachen:
Java,
TypeScript und
C#.
Diese wurden am häufigsten im Trainingsdatenkorpus verwendet. In geringerem Umfang wurde CodeWhisperer auch trainiert auf:
Einen kurzen Überblick darüber, wie CodeWhisperer Developer im Alltag unterstützen kann, gibt folgender Tweet:
Im Folgenden ein Screenshot des von CodeWhisperer generierten Codes auf Grundlage unseres eingangs gezeigten Outlines:
Foto: Martin Heller / Foundry
Leider funktioniert der ausgegebene Code nicht - und CodeWhisperer lieferte mehrere Funktionen für mehr oder weniger den gleichen Zweck. Aber: das Generative-AI-Tool von Amazon war nahe an einer funktionierenden Lösung dran. Zudem konnte es mit Details überzeugen (Stichwort: Beautiful Soup).
Foto: Martin Heller / Foundry
Im Rahmen des Tests haben wir auch einen Sicherheitsscan für unser Projekt durchgeführt. Überraschenderweise wurden dabei keine Probleme entdeckt, obwohl der CodeWhisperer-Scan ein Ressourcenleck in einer anderen Datei fand (die von GitHub Copilot X generiert wurde).
Diese Datei löste keine Open-Source-Referenzen aus, allerdings findet sich im CodeWhisperer-Referenzprotokoll ein Link zu der Einstellung, die steuert, ob CodeWhisperer Code vorschlägt, der solche Referenzen aufweist. In den Amazon-Beispielen, die wir uns angesehen haben, wurde bei Codevorschlägen mit Referenzen der Lizenztyp angezeigt.
Amazon CodeWhisperer - Fazit
CodeWhisperer generiert Code in einer IDE und führt Sicherheitsüberprüfungen durch, lässt aber ein Chat-Fenster und Code-Erklärungen vermissen. Das Tool funktioniert mehr oder weniger wie beworben und ist für Einzelentwickler kostenlos. Unternehmen bezahlen mit 19 Dollar monatlich denselben Preis wie für GitHub Copilot.
Google Bard
Auch Googles Bard greift seit Ende April 2023 Programmierern unter die Arme. Bard unterstützt dabei - laut eigener Aussage - folgende Programmiersprachen:
Bard kann Code in diesen Sprachen generieren, debuggen und erklären. Darüber hinaus ist Googles Generative AI für Developer auch in der Lage, von einer Programmiersprache in eine andere zu übersetzen:
Die Codegenerierung für den Site Scraper sah auf den ersten Blick relativ glaubwürdig aus, wies aber bei näherer Betrachtung mehrere Probleme auf. Es genügte ein Doppelklick, um den Code in Colab zu öffnen, aber beim Versuch, ihn auszuführen, trat ein Typfehler auf. Anstatt die Probleme zu beheben, haben wir die Codegenerierung erneut ausgeführt - und das Ergebnis machte etwas mehr Sinn. Beim Versuch, den Code in Colab auszuführen, wurde jedoch ein Attributfehler ausgegeben. Nachdem dieser Traceback an Bard zurückgegeben wurde, lieferte das Tool eine Korrektur - die wiederum einen Typfehler an einer anderen Stelle verursachte.
Im Folgenden der von Bard generierte Code für den InfoWorld.com-Scraper:
import requests
from bs4 import BeautifulSoup
def scrape_infoworld():
"""Scrape the InfoWorld front page and return a list of articles."""
# Get the HTML from the InfoWorld front page.
response = requests.get("https://www.infoworld.com/")
soup = BeautifulSoup(response.content, "html.parser")
# Find all articles by looking for links with 'article' in the href.
articles = soup.find_all("a", href=lambda x: "article" in x["href"])
# Extract the title, author, and date from each article.
article_data = []
for article in articles:
title = article.find("h3").text
author = article.find("span", class_="byline").text
date = article.find("time").text
article_data.append({
"title": title,
"author": author,
"date": date,
})
# Sort the articles alphabetically by title.
article_data.sort(key=lambda x: x["title"])
# Remove any duplicate articles.
article_data = list(set(article_data))
# Sort the articles alphabetically by author last name.
article_data.sort(key=lambda x: x["author"].split()[-1])
# Sort the articles latest first.
article_data.sort(key=lambda x: x["date"], reverse=True)
return article_data
if __name__ == "__main__":
articles = scrape_infoworld()
# Print the articles.
for article in articles:
print(article)
Explanation:
This code will first get the HTML from the InfoWorld front page. Then, it will find all articles by looking for links with 'article' in the href. For each article, it will extract the title, author, and date. The articles will then be sorted alphabetically by title, removed of any duplicates, sorted alphabetically by author last name, and sorted latest first. Finally, the articles will be printed.
Und hier das Laufzeitergebnis:
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-1-afbe7808577e> in <cell line: 40>()
39
40 if __name__ == "__main__":
---> 41 articles = scrape_infoworld()
42
43 # Print the articles.
6 frames
<ipython-input-1-afbe7808577e> in <lambda>(x)
10
11 # Find all articles by looking for links with 'article' in the href.
---> 12 articles = soup.find_all("a", href=lambda x: "article" in x["href"])
13
14 # Extract the title, author, and date from each article.
TypeError: string indices must be integers
Geht es darum, Quell- und Programmcode zu erklären, lieferte Bard im Test eine bessere Vorstellung ab. Seine Erklärung des MIT-Codebeispiels war so gut, dass wir uns gefragt haben, ob es Teil seiner Trainingsdaten gewesen ist. Hier der bereitgestellte Code:
import pylab, random
class Stock(object):
def __init__(self, price, distribution, vol):
self.price = price
self.history = [price]
self.distribution = distribution
self.vol = vol
self.lastChangeInfluence = 0.0
def setPrice(self, price):
self.price = price
self.history.append(price)
def getPrice(self):
return self.price
def makeMove(self, bias, mo):
oldPrice = self.price
baseMove = self.distribution(self.vol) + bias
self.price = self.price * (1.0 + baseMove)
self.price += mo*random.choice([0.0, 1.0])*self.lastChangeInfluence
self.history.append(self.price)
change = self.price - oldPrice
if change >= 0:
self.lastChangeInfluence = min(change, oldPrice*0.01)
else:
self.lastChangeInfluence = max(change, -oldPrice*0.01)
def showHistory(self, fig, test):
pylab.figure(fig)
pylab.plot(self.history)
pylab.title('Closing Prices, Test ' + test)
pylab.xlabel('Day')
pylab.ylabel('Price')
class SimpleMarket(object):
def __init__(self, numStks, volUB):
self.stks = []
self.bias = 0.0
for n in range(numStks):
volatility = random.uniform(0, volUB)
distribution = lambda vol: random.gauss(0.0, vol)
stk = Stock(100.0, distribution, volatility)
self.addStock(stk)
def addStock(self, stk):
self.stks.append(stk)
def setBias(self, bias):
self.bias = bias
def getBias(self):
return self.bias
def getStocks(self):
return self.stks[:]
def move(self, mo):
prices = []
for s in self.stks:
s.makeMove(self.bias, mo)
prices.append(s.getPrice())
return prices
class Market(SimpleMarket):
def __init__(self, numStks, volUB, dailyBiasRange):
SimpleMarket.__init__(self, numStks, volUB)
self.dailyBiasRange = dailyBiasRange
def move(self, mo):
prices = []
for s in self.stks:
s.makeMove(self.bias + dailyBias, mo)
prices.append(s.getPrice())
return prices
def simMkt(mkt, numDays, mo):
endPrices = []
for i in range(numDays):
vals = mkt.move(mo)
vals = pylab.array(vals)
mean = vals.sum()/float(len(vals))
endPrices.append(mean)
return endPrices
def plotAverageOverTime(endPrices, title):
pylab.plot(endPrices)
pylab.title(title)
pylab.xlabel('Days')
pylab.ylabel('Price')
def plotDistributionAtEnd(mkt, title, color):
prices = []
sumSoFar = 0
for s in mkt.getStocks():
prices.append(s.getPrice())
sumSoFar += s.getPrice()
mean = sumSoFar/float(len(prices))
prices.sort()
pylab.plot(prices, color)
pylab.axhline(mean, color = color)
pylab.title(title)
pylab.xlabel('Stock')
pylab.ylabel('Last Sale')
pylab.semilogy()
def runTrial(showHistory, test, p):
colors = ['b','g','r','c','m','y','k']
mkt = Market(p['numStocks'], p['volUB'], p['dailyBiasRange'])
mkt.setBias(p['bias'])
endPrices = simMkt(mkt, p['numDays'], p['mo'])
pylab.figure(1)
plotAverageOverTime(endPrices, 'Average Closing Prices')
pylab.figure(2)
plotDistributionAtEnd(mkt, 'Distribution of Prices', colors[test%len(colors)])
if showHistory:
for s in mkt.getStocks():
s.showHistory(test+2, str(test))
def runTest(numTrials):
#Constants used in testing
numDaysPerYear = 200.0
params = {}
params['numDays'] = 200
params['numStocks'] = 500
params['bias'] = 0.1/numDaysPerYear #General market bias
params['volUB'] = 12.0/numDaysPerYear #Upper bound on volatility for a stock
params['mo'] = 1.1/numDaysPerYear #Momentum factor
params['dailyBiasRange'] = (0.0, 4.0/200.0)
for t in range(1, numTrials+1):
runTrial(True, t, params)
runTest(3)
pylab.show()
Und Auszüge der mitunter sehr ausführlichen Antwort von Bard:
The code you have provided is a Python program that simulates a stock market. The program defines three classes:
Stock: This class represents a single stock. It has properties for the stock's price, history, distribution, volatility, and last change influence.
SimpleMarket: This class represents a simple stock market. It has a list of stocks, a bias, and a volatility upper bound.
Market: This class inherits from SimpleMarket and adds a daily bias range property. The program also defines several functions:
• simMkt: This function simulates the market for a given number of days and momentum factor.
• plotAverageOverTime: This function plots the average closing price of the stocks over time.
• plotDistributionAtEnd: This function plots the distribution of prices at the end of the simulation.
• runTrial: This function runs a single simulation and plots the results.
• runTest: This function runs a number of simulations and plots the results.
The program is run by calling the runTest function with the desired number of simulations. The program will then generate three plots:
• A plot of the average closing price of the stocks over time.
• A plot of the distribution of prices at the end of the simulation.
• A plot of the history of prices for each stock.
The program can be used to simulate a variety of different stock markets. By changing the values of the parameters, you can change the volatility of the market, the bias of the market, and the momentum factor. You can also use the program to simulate different trading strategies. For example, you could simulate a strategy that buys stocks when they are undervalued and sells them when they are overvalued.
Google Bard - Fazit
Bard verfügt über eine Chat-Schnittstelle, generiert und erklärt Code, verfügt aber nicht über eine interaktive IDE-Integration. Wenn Sie Code in einer der eingangs genannten Programmiersprachen generieren, debuggen oder erklären wollen, ist Googles vollständig kostenloses Generative-AI-Tool zumindest ein Experiment wert.
GitHub Copilot X
GitHub Copilot X zeigt sich im Vergleich zum ursprünglichen GitHub Copilot stark verbessert und erzeugt (manchmal) korrekte Funktionen und eine Reihe von Tests ohne viel menschliches Zutun. Fehler und Halluzinationen kommen dabei vor, aber nicht mehr so häufig wie früher.
Copilot X unterstützt dabei unter anderem folgende Programmiersprachen:
Python,
JavaScript,
TypeScript,
Ruby,
Java,
C++,
C#,
PHP,
Go,
Swift,
Kotlin,
Rust.
Im Rahmen unserer Tests haben wir hauptsächlich Python verwendet.
Der bemerkenswerteste Misserfolg von Copilot X war der Web-Scraping-Task. Das KI-Tool generierte Code, der oberflächlich glaubwürdig aussah. Ein genauerer Blick machte allerdings klar, dass er niemals funktionieren würde. Schlimmer noch: Nachdem wir diverse Probleme über den Copilot Chat angesprochen hatten, verzettelte sich das Tool zusehends. Wie bei allen KI-Helfern sollten Sie also auch den von Copilot X generierten Code mit Vorsicht genießen - ebenso, wie Sie es bei einem Pull Request eines unbekannten Programmierers tun würden.
Foto: Martin Heller / Foundry
Als Copilot X das MIT-Codebeispiel erklären sollte, gab er eine teilweise korrekte Antwort. Wir mussten dem Tool dabei Einiges an Erklärarbeit aus der Nase ziehen.
Foto: Martin Heller / Foundry
Github Copilot X - Fazit
Zusätzlich zum Codegenerierungs-Feature in einem Programmiereditor (der derzeit nur aktuelle Versionen von Visual Studio und die neueste Insider-Version von Visual Studio Code unterstützt), fügt Copilot X dem Editor auch ein GPT-4-Chat-Panel hinzu. Außerdem bietet es eine Terminalschnittstelle, Support für Unit-Testgenerierung und Pull-Request-Beschreibungen sowie die Möglichkeit, Erklärungen aus der Dokumentation zu extrahieren. Einzelpersonen bezahlen für Copilot (X) 10 Dollar, Unternehmen 19 Dollar monatlich.
Generative KI-Tools für Entwickler - Testfazit
Es bleibt festzuhalten: Keines der vorgestellten Gen-AI-Coding-Tools ist derzeit vollständig ausgereift, auch wenn einzelne Ergebnisse - etwa die Code-Erklärungen von Bard und Copilot X - überzeugen konnten.
Meine Empfehlung an Unternehmen lautet deshalb: Beobachten Sie KI-Coding-Tools und ermutigen Sie Ihre Entwickler dazu, damit zu experimentieren. Um volles Vertrauen in Tools dieser Art zu setzen, ist es hingegen auch für Softwareentwickler noch zu früh. (fm)
Dieser Beitrag basiert auf einem Artikel unserer US-Schwesterpublikation Infoworld.