5 formas de impulsar tu productividad en programación con IA generativa

Como Artesano de Software con años de experiencia en el campo, he sido testigo del impacto de la IA Generativa en el desarrollo de software desde la introducción de ChatGPT en 2023. A través de la aplicación práctica, he identificado cinco formas poderosas de aprovechar esta tecnología para mejorar la productividad.

1. Búsqueda de código mejorada

La forma más frecuente en que utilizo la IA Generativa es para buscar información técnica. Los motores de búsqueda tradicionales requieren terminología precisa, mientras que la IA Generativa entiende conceptos y contexto. Por ejemplo, cuando busco el principio de optimización de parámetros de método, pregunto:

Prompt

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. 

La IA Generativa entiende el concepto que estoy describiendo (Ley de Demeter) y proporciona la respuesta correcta, eliminando la necesidad de múltiples búsquedas.

2. Generación de código eficiente

La IA Generativa destaca en la automatización de tareas de codificación repetitivas. Recientemente, necesitaba convertir un archivo JSON grande en declaraciones de inserción de base de datos. En lugar de escribir código de conversión tedioso, proporcioné los datos JSON a la IA con instrucciones claras para generar declaraciones de inserción de MS SQL Server. Este enfoque ahorró horas de tiempo de codificación manual y redujo la posibilidad de errores.

Prompt:

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

Output:

-- 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. Traducción de código sin problemas

La traducción de código es otra área donde la IA Generativa demuestra ser invaluable. Durante un proyecto reciente para convertir una aplicación C# a Python, utilizamos la IA de dos formas cruciales:

1. Conversión directa de funciones de Python a C#

2. Traducción compleja de ORM de Entity Framework a SQLAlchemy

Esta capacidad aceleró significativamente nuestro proceso de migración y aseguró consistencia en las traducciones.

Convertir Python a C#:

Prompt:

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]

Output:

/// <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. Documentación de código automatizada

La documentación es esencial pero a menudo tediosa. La IA Generativa simplifica este proceso de dos formas:

1. Resumen de código: Analizar código existente y proporcionar resúmenes claros y concisos

2. Generación de encabezados de documentación: Crear documentación completa de métodos que mantenga los estándares de calidad del código

Por ejemplo, al documentar algoritmos de ordenamiento o lógica comercial compleja, la IA puede generar documentación clara y precisa que siga los estándares del equipo y las mejores prácticas.

Prompt:

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_

Output:

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. Andamiaje de aplicaciones

Quizás la aplicación más impresionante de la IA Generativa es su capacidad para generar estructuras iniciales de aplicaciones. Dado un esquema o especificación clara, la IA puede crear:

• Scripts de creación de base de datos

• Asignaciones de ORM

• Puntos finales de API básicos

• Implementaciones iniciales de interfaz de usuario

Esta capacidad reduce significativamente el tiempo dedicado a código repetitivo y asegura una base consistente para el desarrollo posterior.

Prompt:

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

Output:

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

Preguntemos qué podemos hacer para mejorar el diseño inicial.

Prompt 2:

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

Output:
Implementar registro para un mejor debugging y manejo de errores.

logging.py (Opcional)

import logging

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

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

Prompt 3:

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

Output:
También puedes definir manejadores de excepciones globales en tu archivo main.py si deseas manejar excepciones específicas globalmente.

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

Mejores prácticas y consideraciones

Aunque la IA Generativa es poderosa, es importante:

• Revisar y validar el código generado
• Mantener consistencia con bases de código existentes
• Considerar implicaciones de seguridad
• Probar el código generado exhaustivamente
• Usar la IA como asistente en lugar de reemplazo del juicio de ingeniería

Conclusión

La IA Generativa se ha convertido en una herramienta indispensable en el desarrollo de software moderno. Al aprovechar estos cinco enfoques - búsqueda mejorada, generación de código, traducción, documentación y andamiaje de aplicaciones - los desarrolladores pueden aumentar significativamente su productividad mientras mantienen la calidad del código.

La clave es entender las capacidades y limitaciones de estas herramientas y usarlas estratégicamente para mejorar en lugar de reemplazar la experiencia humana. A medida que estas tecnologías evolucionen, su integración en flujos de trabajo de desarrollo será cada vez más valiosa.