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 beobachtet. Durch praktische Anwendung habe ich fünf leistungsstarke Wege identifiziert, um diese Technologie zur Steigerung der Produktivität zu nutzen.

1. Verbesserte 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. Wenn ich beispielsweise nach dem Prinzip der Optimierung von Methodenparametern suche, stelle ich folgende Frage:

Eingabeaufforderung

What's the name of the programming concept where you should only pass parameters that are actually used by the method? Passing parameters to a method that aren't used by the method creates unneeded dependencies. 

Generative KI versteht das Konzept, das ich beschreibe (Law of Demeter), und liefert die richtige Antwort, wodurch mehrere Suchen entfallen.

2. Effiziente Code-Generierung

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

Eingabeaufforderung:

Use the JSON data provided below and generate insert statements for MS SQL Server to be inserted into the dbo.Users table.

[  
{  
"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:

-- Inserting records into dbo.Users table

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 wertvoll erweist. Während eines kürzlichen Projekts zur Konvertierung einer C#-Anwendung nach Python nutzten wir KI auf zwei entscheidende Weisen:

1. Direkte Funktionskonvertierung von Python zu C#

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

Diese Fähigkeit beschleunigte unseren Migrationsprozess erheblich und gewährleistete Konsistenz bei den Übersetzungen.

Python zu C# konvertieren:

Eingabeaufforderung:

Convert the following Python code to C#.

def reverse_string(text): 
"""
Reverses a given string. 
	Args: text: The string to be reversed. 

Returns: The reversed string.

""" 
return text[::-1]

Ausgabe:

/// <summary>
/// Reverses a given string.
/// </summary>
/// <param name="text">The string to be reversed.</param>
/// <returns>The reversed 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 rationalisiert diesen Prozess auf zwei Wegen:

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

2. Generierung von Dokumentations-Headern: Erstellung umfassender Methodendokumentation, die Codequalitätsstandards einhält

Beispielsweise kann KI bei der Dokumentation von Sortieralgorithmen oder komplexer Geschäftslogik klare, genaue Dokumentationen generieren, die Team-Standards und Best Practices befolgen.

Eingabeaufforderung:

Generate a doc header for the below function adding the header and printing the complete function with the doc header.

def bubble_sort(list_):
  n = len(list_) 
  for i in range(n):
    # Flag to optimize, if no swaps occur, the list is sorted
    swapped = False
    # Last i elements are already in place
    for j in range(0, n-i-1):
      # Swap if the element found is greater than the next element
      if list_[j] > list_[j+1]:
        list_[j], list_[j+1] = list_[j+1], list_[j]
        swapped = True
    # If no two elements were swapped in inner loop, the list is sorted
    if not swapped:
      break
  return list_

Ausgabe:

def bubble_sort(list_):
    """
    Sorts a given list using the Bubble Sort algorithm.

    Args:
        list_: The list of elements to be sorted. Elements must be comparable.

    Returns:
        A new list containing all elements from the original list in ascending order.
        
    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 to optimize, if no swaps occur, the list is sorted
        swapped = False
        # Last i elements are already in place
        for j in range(0, n-i-1):
            # Swap if the element found is greater than the next element
            if list_[j] > list_[j+1]:
                list_[j], list_[j+1] = list_[j+1], list_[j]
                swapped = True
        # If no two elements were swapped in inner loop, the list is sorted
        if not swapped:
            break
    return list_

5. Anwendungs-Scaffolding

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

• Datenbankenerstellungsskripte

• ORM-Zuordnungen

• Grundlegende API-Endpunkte

• Initiale UI-Implementierungen

Diese Fähigkeit reduziert die Zeit für Boilerplate-Code erheblich und gewährleistet eine konsistente Grundlage für weitere Entwicklung.

Eingabeaufforderung:

You are a Software Engineer working at a large corporation. Using the following database schema, generate the SQL scripts necessary to create these tables in Postgres. Then, generate the SQL Alchemy mapping files to use with FastAPI. Lastly, generate a simple web UI using FastAPI to list the orders.

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:

...
I'm saving you from the output, but it generated an entire application using FastAPI.
...

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

Eingabeaufforderung 2:

That's a great start. What can we do to improve the application design?

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"An error occurred: {error}")

Eingabeaufforderung 3:

Can you implement your suggestion to use Error Handling and generate the code for me?

Ausgabe:
Sie können auch globale Exception-Handler in Ihrer main.py-Datei definieren, wenn Sie bestimmte Ausnahmen 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()

# Include the router
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

Während generative KI leistungsstark ist, ist es wichtig zu:

• Generierten Code überprüfen und validieren
• Konsistenz mit bestehenden Codebasen wahren
• Sicherheitsauswirkungen berücksichtigen
• Generierten Code gründlich testen
• KI als Assistent nutzen, nicht als Ersatz für technisches Urteilsvermögen

Fazit

Generative KI ist zu einem unverzichtbaren Werkzeug in der modernen Softwareentwicklung geworden. Durch die Nutzung dieser fünf Ansätze – verbesserte Suche, Code-Generierung, Übersetzung, Dokumentation und Anwendungs-Scaffolding – 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 einzusetzen, um menschliche Expertise zu verbessern, nicht zu ersetzen. Mit der Weiterentwicklung dieser Technologien wird ihre Integration in Entwicklungs-Workflows zunehmend wertvoll.