5 façons d'augmenter votre productivité en codage avec l'IA générative

En tant qu’artisan logiciel avec des années d’expérience dans le domaine, j’ai été témoin de l’impact de l’IA générative sur le développement logiciel depuis l’introduction de ChatGPT en 2023. Grâce à l’application pratique, j’ai identifié cinq façons puissantes de tirer parti de cette technologie pour améliorer la productivité.

1. Recherche de code améliorée

La façon la plus fréquente dont j’utilise l’IA générative est de rechercher des informations techniques. Les moteurs de recherche traditionnels nécessitent une terminologie précise, tandis que l’IA générative comprend les concepts et le contexte. Par exemple, lorsque je recherche le principe d’optimisation des paramètres de méthode, je pose la question :

Invite

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. 

L’IA générative comprend le concept que je décris (Loi de Déméter) et fournit la bonne réponse, éliminant le besoin de plusieurs recherches.

2. Génération de code efficace

L’IA générative excelle dans l’automatisation des tâches de codage répétitives. Récemment, j’ai eu besoin de convertir un grand fichier JSON en instructions d’insertion de base de données. Au lieu d’écrire du code de conversion fastidieux, j’ai fourni les données JSON à l’IA avec des instructions claires pour générer des instructions d’insertion MS SQL Server. Cette approche a économisé des heures de codage manuel et réduit la possibilité d’erreurs.

Invite :

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"  
}  
]

Résultat :

-- 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. Traduction de code transparente

La traduction de code est un autre domaine où l’IA générative s’avère inestimable. Lors d’un récent projet de conversion d’une application C# en Python, nous avons utilisé l’IA de deux façons cruciales :

1. Conversion directe de fonctions de Python à C#

2. Traduction complexe d’ORM de Entity Framework à SQLAlchemy

Cette capacité a considérablement accéléré notre processus de migration et assuré la cohérence entre les traductions.

Conversion de Python à C# :

Invite :

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]

Résultat :

/// <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. Documentation de code automatisée

La documentation est essentielle mais souvent fastidieuse. L’IA générative rationalise ce processus de deux façons :

1. Résumé du code : Analyser le code existant et fournir des résumés clairs et concis

2. Génération d’en-têtes de documentation : Créer une documentation de méthode complète qui maintient les normes de qualité du code

Par exemple, lors de la documentation d’algorithmes de tri ou de logique métier complexe, l’IA peut générer une documentation claire et précise qui suit les normes d’équipe et les meilleures pratiques.

Invite :

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_

Résultat :

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. Génération de structure d’application

L’application la plus impressionnante de l’IA générative est peut-être sa capacité à générer des structures d’application initiales. Compte tenu d’un schéma ou d’une spécification clairs, l’IA peut créer :

• Scripts de création de base de données

• Mappages ORM

• Points de terminaison API de base

• Implémentations d’interface utilisateur initiales

Cette capacité réduit considérablement le temps consacré au code passe-partout et assure une base cohérente pour un développement ultérieur.

Invite :

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

Résultat :

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

Demandons ce que nous pouvons faire pour améliorer la conception initiale.

Invite 2 :

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

Résultat :
Implémenter la journalisation pour un meilleur débogage et gestion des erreurs.

logging.py (Optionnel)

import logging

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

def log_error(error):
    logger.error(f"An error occurred: {error}")

Invite 3 :

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

Résultat :
Vous pouvez également définir des gestionnaires d’exceptions globaux dans votre fichier main.py si vous souhaitez gérer des exceptions spécifiques au niveau mondial.

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},
    )

Meilleures pratiques et considérations

Bien que l’IA générative soit puissante, il est important de :

• Examiner et valider le code généré
• Maintenir la cohérence avec les bases de code existantes
• Considérer les implications de sécurité
• Tester le code généré en profondeur
• Utiliser l’IA comme assistant plutôt que comme remplacement du jugement d’ingénierie

Conclusion

L’IA générative est devenue un outil indispensable dans le développement logiciel moderne. En tirant parti de ces cinq approches - recherche améliorée, génération de code, traduction, documentation et génération de structure d’application - les développeurs peuvent augmenter considérablement leur productivité tout en maintenant la qualité du code.

La clé est de comprendre les capacités et les limitations de ces outils et de les utiliser stratégiquement pour améliorer plutôt que de remplacer l’expertise humaine. À mesure que ces technologies évoluent, leur intégration dans les flux de travail de développement deviendra de plus en plus précieuse.