Nachdem wir uns in den letzten Beiträgen intensiv mit den Erweiterungen des Microsoft 365 Copilot beschäftigt haben, kommt zum Schluss dieser Serie noch mein persönlicher Lieblingsassistent: der Github Copilot :-)
Als Entwickler habe ich ihn täglich im Einsatz und bin damit deutlich effizienter. Wobei unterstützt dieser Copilot?
Codegenerierung
Wenn ein:e Entwickler:in eine neue Funktion implementieren muss, kann GitHub Copilot helfen, indem es Vorschläge für den Code liefert. Zum Beispiel kann ein Developer, der eine Funktion zum Berechnen der Fibonacci-Folge schreibt, einfach den Funktionsnamen und die Signatur eingeben, und Copilot schlägt den Code für die Berechnung der Fibonacci-Folge vor.
// Beispiel für die Verwendung von GitHub Copilot zur Generierung von Code für die Fibonacci-Folge in C#
using System;
using System.Collections.Generic;
public class Fibonacci
{
public static List<int> GenerateSequence(int n)
{
List<int> sequence = new List<int>();
if (n <= 0)
return sequence;
if (n >= 1)
sequence.Add(0);
if (n >= 2)
sequence.Add(1);
for (int i = 2; i < n; i++)
{
sequence.Add(sequence[i - 1] + sequence[i - 2]);
}
return sequence;
}
}
Codevervollständigung
Während eines Codierungsprozesses kann Copilot kontextbezogene Vorschläge machen, um den Entwicklungsprozess zu beschleunigen. Wenn ein:e Entwickler:in beispielsweise eine Methode in einer Klasse implementiert, kann Copilot Vorschläge für Methodenparameter, Rückgabetypen und implementierten Code liefern.
// Beispiel für die Verwendung von GitHub Copilot zur automatischen Vervollständigung von Code in C#
using System;
public class Calculator
{
public int Add(int a, int b)
{
return a + b;
}
public int Multiply(int a, int b)
{
return a * b;
}
// Copilot könnte automatisch die folgende Methode vorschlagen, wenn der Entwickler "Divide" eingibt
public double Divide(int dividend, int divisor)
{
if (divisor == 0)
{
throw new DivideByZeroException("Division by zero!");
}
return (double)dividend / divisor;
}
}
Refactoring
GitHub Copilot kann auch bei der Refaktorisierung von Code helfen, indem es Vorschläge für verbesserte Implementierungen oder alternative Lösungsansätze liefert. Zum Beispiel kann Copilot Vorschläge machen, um redundante Codefragmente zu entfernen oder ineffiziente Algorithmen zu optimieren.
// Beispiel für die Verwendung von GitHub Copilot zum Refactoring von C#-Code
using System;
using System.Linq;
public class ArrayOperations
{
public static int SumArray(int[] arr)
{
int sum = 0;
for (int i = 0; i < arr.Length; i++)
{
sum += arr[i];
}
return sum;
}
// Copilot könnte eine verbesserte Implementierung vorschlagen, die LINQ verwendet
public static int SumArray(int[] arr)
{
return arr.Sum();
}
}
UnitTests
GitHub Copilot kann auch bei UnitTests von Code helfen, indem es Vorschläge für die Implementierung macht. In diesem Beispiel wird eine Klasse CalculatorTests erstellt, die verschiedene UnitTests für die Methoden der Calculator-Klasse enthält. GitHub Copilot kann automatisch Vorschläge für die Implementierung von Unit-Tests machen, basierend auf den vorhandenen Methoden und erwarteten Ergebnissen. Die Assert-Anweisungen werden verwendet, um sicherzustellen, dass die tatsächlichen Ergebnisse der Methodenaufrufe mit den erwarteten Ergebnissen übereinstimmen.
// Beispiel für die Verwendung von GitHub Copilot zur Generierung eines Unit-Tests in C#
using NUnit.Framework;
using System;
public class CalculatorTests
{
[Test]
public void TestAdd()
{
// Arrange
Calculator calculator = new Calculator();
int a = 5;
int b = 3;
int expectedResult = 8;
// Act
int result = calculator.Add(a, b);
// Assert
Assert.AreEqual(expectedResult, result);
}
// Copilot könnte automatisch den folgenden Testvorschlag für die Multiply-Methode machen
[Test]
public void TestMultiply()
{
// Arrange
Calculator calculator = new Calculator();
int a = 4;
int b = 6;
int expectedResult = 24;
// Act
int result = calculator.Multiply(a, b);
// Assert
Assert.AreEqual(expectedResult, result);
}
[Test]
public void TestDivide()
{
// Arrange
Calculator calculator = new Calculator();
int dividend = 10;
int divisor = 2;
double expectedResult = 5.0;
// Act
double result = calculator.Divide(dividend, divisor);
// Assert
Assert.AreEqual(expectedResult, result);
}
}
Diese Beispiele verdeutlichen die vielfältigen Möglichkeiten der Nutzung von GitHub Copilot während des Entwicklungsprozesses.
Der Vollständigkeit halber sei an dieser Stelle noch darauf hingewiesen, dass es Grundvoraussetzung ist, ein solides Verständnis von Softwareentwicklung zu haben, um die Vorschläge von GitHub Copilot effektiv nutzen zu können. Copilot ist ein leistungsstarkes Werkzeug, das Entwickler:innen bei der Codegenerierung und -vervollständigung von einfachen Aufgabenstellungen sowie beim Refactoring unterstützen kann, aber es ist keine perfekte Lösung und liefert nicht immer die richtigen Ergebnisse. Die Vorschläge von Copilot müssen vor Verwendung sorgfältig überprüft werden, um sicherzustellen, dass sie den Anforderungen entsprechen. Das gilt im Übrigen für alle KI-generierten Ergebnisse. Aber das wissen Sie mit Sicherheit schon… ;-)
