5 Wege zur Steigerung Ihrer Coding-Produktivität mit Generativer KI

Als Software Craftsman mit jahrelanger Erfahrung in diesem Bereich habe ich die Auswirkungen von Generativer KI auf die Softwareentwicklung seit der Einführung von ChatGPT im Jahr 2023 miterlebt. Durch praktische Anwendung habe ich fünf wirkungsvolle Wege identifiziert, diese Technologie zu nutzen, um die Produktivität zu steigern.

1. Erweiterte Code-Suche

Die häufigste Art, wie ich Generative KI nutze, ist die Suche nach technischen Informationen. Traditionelle Suchmaschinen erfordern präzise Terminologie, während Generative KI Konzepte und Kontext versteht. Zum Beispiel, wenn ich nach dem Prinzip der Methodenparameter-Optimierung suche, frage ich:

Prompt

Wie heißt das Programmierkonzept, bei dem man nur Parameter übergeben sollte, die tatsächlich von der Methode verwendet werden? Das Übergeben von Parametern an eine Methode, die nicht von der Methode verwendet werden, schafft unnötige Abhängigkeiten.

Generative KI versteht das Konzept, das ich beschreibe (Law of Demeter) und liefert die richtige Antwort, wodurch die Notwendigkeit mehrerer Suchvorgänge entfällt.

2. Effiziente Code-Generierung

Generative KI zeichnet sich bei der Automatisierung repetitiver Coding-Aufgaben aus. Kürzlich musste ich eine große JSON-Datei in Datenbank-Insert-Anweisungen konvertieren. Anstatt mühsamen Konvertierungscode zu schreiben, stellte ich der KI die JSON-Daten mit klaren Anweisungen zur Generierung von MS SQL Server Insert-Anweisungen zur Verfügung. Dieser Ansatz sparte Stunden manueller Coding-Zeit und reduzierte die Möglichkeit von Fehlern.

Prompt:

Verwenden Sie die unten bereitgestellten JSON-Daten und generieren Sie Insert-Anweisungen für MS SQL Server, die in die Tabelle dbo.Users eingefügt werden sollen.

[  
{  
"Username": "musiclover87",  
"Lastname": "Smith",  
"Firstname": "Alice",  
"Birthdate": "1987-06-12",  
"Password": "password123",  
"FavoriteIceCream": "Chocolate Chip Cookie Dough",  
"FavoriteSuperhero": "Spider-Man"  
},  
{  
"Username": "bookworm92",  
"Lastname": "Johnson",  
"Firstname": "Bob",  
"Birthdate": "1992-03-21",  
"Password": "securePassword",  
"FavoriteIceCream": "Mint Chocolate Chip",  
"FavoriteSuperhero": "Batman"  
},  
{  
"Username": "gamergirl01",  
"Lastname": "Williams",  
"Firstname": "Carol",  
"Birthdate": "2001-11-05",  
"Password": "gamer4life",  
"FavoriteIceCream": "Strawberry",  
"FavoriteSuperhero": "Wonder Woman"  
},  
{  
"Username": "techieguy95",  
"Lastname": "Brown",  
"Firstname": "David",  
"Birthdate": "1995-08-18",  
"Password": "techmaster",  
"FavoriteIceCream": "Vanilla Bean",  
"FavoriteSuperhero": "Iron Man"  
},  
{  
"Username": "foodiequeen89",  
"Lastname": "Davis",  
"Firstname": "Emily",  
"Birthdate": "1989-04-29",  
"Password": "delicious123",  
"FavoriteIceCream": "Salted Caramel",  
"FavoriteSuperhero": "Captain Marvel"  
},  
{  
"Username": "traveler76",  
"Lastname": "Miller",  
"Firstname": "Frank",  
"Birthdate": "1976-12-02",  
"Password": "adventuretime",  
"FavoriteIceCream": "Coffee",  
"FavoriteSuperhero": "Thor"  
},  
{  
"Username": "fitnessfanatic98",  
"Lastname": "Wilson",  
"Firstname": "Grace",  
"Birthdate": "1998-09-15",  
"Password": "strongandfit",  
"FavoriteIceCream": "Mango Sorbet",  
"FavoriteSuperhero": "Black Widow"  
},  
{  
"Username": "photographylover85",  
"Lastname": "Moore",  
"Firstname": "Henry",  
"Birthdate": "1985-05-23",  
"Password": "pictureperfect",  
"FavoriteIceCream": "Pistachio",  
"FavoriteSuperhero": "Superman"  
},  
{  
"Username": "musicjunkie93",  
"Lastname": "Taylor",  
"Firstname": "Isabella",  
"Birthdate": "1993-02-08",  
"Password": "musicislife",  
"FavoriteIceCream": "Rocky Road",  
"FavoriteSuperhero": "Black Panther"  
},  
{  
"Username": "sportsfanatic88",  
"Lastname": "Anderson",  
"Firstname": "Jack",  
"Birthdate": "1988-10-30",  
"Password": "goteamgo",  
"FavoriteIceCream": "Cookies and Cream",  
"FavoriteSuperhero": "Captain America"  
}  
]

Ausgabe:

-- Einfügen von Datensätzen in die Tabelle dbo.Users

INSERT INTO dbo.Users (Username, Lastname, Firstname, Birthdate, Password, FavoriteIceCream, FavoriteSuperhero)
VALUES 
('musiclover87', 'Smith', 'Alice', '1987-06-12', 'password123', 'Chocolate Chip Cookie Dough', 'Spider-Man'),
('bookworm92', 'Johnson', 'Bob', '1992-03-21', 'securePassword', 'Mint Chocolate Chip', 'Batman'),
('gamergirl01', 'Williams', 'Carol', '2001-11-05', 'gamer4life', 'Strawberry', 'Wonder Woman'),
('techieguy95', 'Brown', 'David', '1995-08-18', 'techmaster', 'Vanilla Bean', 'Iron Man'),
('foodiequeen89', 'Davis', 'Emily', '1989-04-29', 'delicious123', 'Salted Caramel', 'Captain Marvel'),
('traveler76', 'Miller', 'Frank', '1976-12-02', 'adventuretime', 'Coffee', 'Thor'),
('fitnessfanatic98', 'Wilson', 'Grace', '1998-09-15', 'strongandfit', 'Mango Sorbet', 'Black Widow'),
('photographylover85', 'Moore', 'Henry', '1985-05-23', 'pictureperfect', 'Pistachio', 'Superman'),
('musicjunkie93', 'Taylor', 'Isabella', '1993-02-08', 'musicislife', 'Rocky Road', 'Black Panther'),
('sportsfanatic88', 'Anderson', 'Jack', '1988-10-30', 'goteamgo', 'Cookies and Cream', 'Captain America');

3. Nahtlose Code-Übersetzung

Code-Übersetzung ist ein weiterer Bereich, in dem sich Generative KI als unschätzbar wertvoll erweist. Während eines kürzlichen Projekts zur Konvertierung einer C#-Anwendung nach Python nutzten wir KI auf zwei entscheidende Weise:

1. Direkte Funktionskonvertierung von Python nach C#

2. Komplexe ORM-Übersetzung von Entity Framework zu SQLAlchemy

Diese Fähigkeit beschleunigte unseren Migrationsprozess erheblich und stellte Konsistenz über alle Übersetzungen hinweg sicher.

Konvertierung von Python zu C#:

Prompt:

Konvertieren Sie den folgenden Python-Code zu C#.

def reverse_string(text): 
"""
Kehrt einen gegebenen String um. 
	Args: text: Der String, der umgekehrt werden soll. 

Returns: Der umgekehrte String.

""" 
return text[::-1]

Ausgabe:

/// <summary>
/// Kehrt einen gegebenen String um.
/// </summary>
/// <param name="text">Der String, der umgekehrt werden soll.</param>
/// <returns>Der umgekehrte String.</returns>
public static string ReverseString(string text)
{
	return new string(text.Reverse().ToArray());
}

4. Automatisierte Code-Dokumentation

Dokumentation ist essentiell, aber oft mühsam. Generative KI optimiert diesen Prozess auf zwei Arten:

1. Code-Zusammenfassung: Analyse vorhandenen Codes und Bereitstellung klarer, prägnanter Zusammenfassungen

2. Dokumentations-Header-Generierung: Erstellung umfassender Methodendokumentation, die Code-Qualitätsstandards einhält

Zum Beispiel, beim Dokumentieren von Sortieralgorithmen oder komplexer Geschäftslogik kann KI klare, genaue Dokumentation generieren, die Team-Standards und Best Practices folgt.

Prompt:

Generieren Sie einen Doc-Header für die untenstehende Funktion, fügen Sie den Header hinzu und geben Sie die vollständige Funktion mit dem Doc-Header aus.

def bubble_sort(list_):
  n = len(list_) 
  for i in range(n):
    # Flag zur Optimierung, wenn keine Vertauschungen auftreten, ist die Liste sortiert
    swapped = False
    # Die letzten i Elemente sind bereits an der richtigen Stelle
    for j in range(0, n-i-1):
      # Vertauschen, wenn das gefundene Element größer als das nächste Element ist
      if list_[j] > list_[j+1]:
        list_[j], list_[j+1] = list_[j+1], list_[j]
        swapped = True
    # Wenn keine zwei Elemente in der inneren Schleife vertauscht wurden, ist die Liste sortiert
    if not swapped:
      break
  return list_

Ausgabe:

def bubble_sort(list_):
    """
    Sortiert eine gegebene Liste mit dem Bubble Sort Algorithmus.

    Args:
        list_: Die Liste der zu sortierenden Elemente. Elemente müssen vergleichbar sein.

    Returns:
        Eine neue Liste mit allen Elementen aus der ursprünglichen Liste in aufsteigender Reihenfolge.
        
    Example:
        >>> bubble_sort([64, 34, 25, 12, 22, 11, 90])
        [11, 12, 22, 25, 34, 64, 90]
    """
    n = len(list_) 
    for i in range(n):
        # Flag zur Optimierung, wenn keine Vertauschungen auftreten, ist die Liste sortiert
        swapped = False
        # Die letzten i Elemente sind bereits an der richtigen Stelle
        for j in range(0, n-i-1):
            # Vertauschen, wenn das gefundene Element größer als das nächste Element ist
            if list_[j] > list_[j+1]:
                list_[j], list_[j+1] = list_[j+1], list_[j]
                swapped = True
        # Wenn keine zwei Elemente in der inneren Schleife vertauscht wurden, ist die Liste sortiert
        if not swapped:
            break
    return list_

5. Anwendungs-Gerüstbau

Vielleicht die beeindruckendste Anwendung von Generativer KI ist ihre Fähigkeit, initiale Anwendungsstrukturen zu generieren. Bei einem klaren Schema oder einer Spezifikation kann KI erstellen:

• Datenbank-Erstellungsskripte

• ORM-Mappings

• Grundlegende API-Endpunkte

• Initiale UI-Implementierungen

Diese Fähigkeit reduziert die Zeit, die für Boilerplate-Code aufgewendet wird, erheblich und stellt eine konsistente Grundlage für die weitere Entwicklung sicher.

Prompt:

Sie sind ein Software Engineer, der in einem großen Unternehmen arbeitet. Verwenden Sie das folgende Datenbankschema und generieren Sie die SQL-Skripte, die notwendig sind, um diese Tabellen in Postgres zu erstellen. Generieren Sie dann die SQL Alchemy Mapping-Dateien für die Verwendung mit FastAPI. Erstellen Sie schließlich eine einfache Web-UI mit FastAPI, um die Bestellungen aufzulisten.

User
- UserId
- FirstName
- LastName
- Address
- Address2
- City
- State
- ZipCode
- Username
- Password
- IsActive

Client
- ClientId
- Name
- Address
- Address2
- City
- State
- ZipCode
- IsActive

Order
- OrderId
- OrderDate
- InvoiceNumber
- DueDate
- ClientId
- UserId

OrderDetail
- OrderDetailId
- OrderId
- Description
- Rate
- Quantity
- LineTotal

Ledger
- TransactionId
- Debit
- Credit
- OrderId
- TransactionDate

Ausgabe:

...
Ich erspare Ihnen die Ausgabe, aber es hat eine vollständige Anwendung mit FastAPI generiert.
...

Lassen Sie uns fragen, was wir tun können, um das ursprüngliche Design zu verbessern.

Prompt 2:

Das ist ein großartiger Anfang. Was können wir tun, um das Anwendungsdesign zu verbessern?

Ausgabe:
Implementieren Sie Logging für besseres Debugging und Fehlerbehandlung.

logging.py (Optional)

import logging

logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)

def log_error(error):
    logger.error(f"Ein Fehler ist aufgetreten: {error}")

Prompt 3:

Können Sie Ihren Vorschlag zur Verwendung von Fehlerbehandlung implementieren und den Code für mich generieren?

Ausgabe:
Sie können auch globale Exception Handler in Ihrer main.py Datei definieren, wenn Sie spezifische Exceptions global behandeln möchten.

main.py

from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse
import app.routers.order_router as order_router
from .exceptions import OrderNotFoundException, InvalidInvoiceNumberException

app = FastAPI()

# Router einbinden
app.include_router(order_router.router)

@app.exception_handler(OrderNotFoundException)
async def order_not_found_exception_handler(request: Request, exc: OrderNotFoundException):
    return JSONResponse(
        status_code=exc.status_code,
        content={"detail": exc.detail},
    )

@app.exception_handler(InvalidInvoiceNumberException)
async def invalid_invoice_number_exception_handler(request: Request, exc: InvalidInvoiceNumberException):
    return JSONResponse(
        status_code=exc.status_code,
        content={"detail": exc.detail},
    )

Best Practices und Überlegungen

Obwohl Generative KI mächtig ist, ist es wichtig:

• Generierten Code zu überprüfen und zu validieren
• Konsistenz mit bestehenden Codebasen zu wahren
• Sicherheitsimplikationen zu berücksichtigen
• Generierten Code gründlich zu testen
• KI als Assistent und nicht als Ersatz für Engineering-Urteilsvermögen zu verwenden

Fazit

Generative KI ist zu einem unverzichtbaren Werkzeug in der modernen Softwareentwicklung geworden. Durch die Nutzung dieser fünf Ansätze - erweiterte Suche, Code-Generierung, Übersetzung, Dokumentation und Anwendungs-Gerüstbau - können Entwickler ihre Produktivität erheblich steigern und gleichzeitig die Code-Qualität beibehalten.

Der Schlüssel liegt darin, die Fähigkeiten und Grenzen dieser Tools zu verstehen und sie strategisch zu nutzen, um menschliche Expertise zu erweitern, anstatt sie zu ersetzen. Während sich diese Technologien weiterentwickeln, wird ihre Integration in Entwicklungsworkflows zunehmend wertvoll werden.