5 Maneiras de Aumentar Sua Produtividade de Programação com IA Generativa

Como um Artesão de Software com anos de experiência na área, testemunhei o impacto da IA Generativa no desenvolvimento de software desde a introdução do ChatGPT em 2023. Através da aplicação prática, identifiquei cinco maneiras poderosas de aproveitar essa tecnologia para aumentar a produtividade.

1. Busca de Código Aprimorada

A maneira mais frequente que utilizo IA Generativa é para buscar informações técnicas. Mecanismos de busca tradicionais requerem terminologia precisa, enquanto a IA Generativa entende conceitos e contexto. Por exemplo, ao buscar pelo princípio de otimização de parâmetros de método, pergunto:

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. 

A IA Generativa entende o conceito que estou descrevendo (Lei de Demeter) e fornece a resposta correta, eliminando a necessidade de múltiplas buscas.

2. Geração de Código Eficiente

A IA Generativa se destaca na automação de tarefas repetitivas de programação. Recentemente, precisei converter um arquivo JSON grande em instruções de inserção de banco de dados. Em vez de escrever código de conversão tedioso, forneci os dados JSON para a IA com instruções claras para gerar instruções de inserção do MS SQL Server. Esta abordagem economizou horas de tempo de codificação manual e reduziu a possibilidade de erros.

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

Saída:

-- Inserindo registros na tabela 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. Tradução de Código Perfeita

A tradução de código é outra área onde a IA Generativa se mostra inestimável. Durante um projeto recente para converter uma aplicação C# para Python, utilizamos IA de duas maneiras cruciais:

1. Conversão direta de função de Python para C#

2. Tradução complexa de ORM do Entity Framework para SQLAlchemy

Esta capacidade acelerou significativamente nosso processo de migração e garantiu consistência entre as traduções.

Convertendo Python para 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]

Saída:

/// <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. Documentação de Código Automatizada

A documentação é essencial, mas frequentemente tediosa. A IA Generativa simplifica este processo de duas maneiras:

1. Resumo de código: Analisando código existente e fornecendo resumos claros e concisos

2. Geração de cabeçalho de documentação: Criando documentação abrangente de métodos que mantém padrões de qualidade de código

Por exemplo, ao documentar algoritmos de ordenação ou lógica de negócio complexa, a IA pode gerar documentação clara e precisa que segue padrões da equipe e melhores práticas.

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_

Saída:

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. Estruturação de Aplicação

Talvez a aplicação mais impressionante da IA Generativa seja sua capacidade de gerar estruturas iniciais de aplicação. Dado um esquema ou especificação clara, a IA pode criar:

• Scripts de criação de banco de dados

• Mapeamentos ORM

• Endpoints básicos de API

• Implementações iniciais de UI

Esta capacidade reduz significativamente o tempo gasto em código padrão e garante uma base consistente para desenvolvimento 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

Saída:

...
Estou poupando você da saída, mas gerou uma aplicação inteira usando FastAPI.
...

Vamos perguntar o que podemos fazer para melhorar o design inicial.

Prompt 2:

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

Saída:
Implementar logging para melhor depuração e tratamento de erros.

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?

Saída:
Você também pode definir manipuladores de exceção globais no seu arquivo main.py se quiser lidar com exceções 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},
    )

Melhores Práticas e Considerações

Embora a IA Generativa seja poderosa, é importante:

• Revisar e validar código gerado
• Manter consistência com bases de código existentes
• Considerar implicações de segurança
• Testar código gerado minuciosamente
• Usar IA como assistente em vez de substituto para julgamento de engenharia

Conclusão

A IA Generativa se tornou uma ferramenta indispensável no desenvolvimento de software moderno. Ao aproveitar essas cinco abordagens - busca aprimorada, geração de código, tradução, documentação e estruturação de aplicação - desenvolvedores podem aumentar significativamente sua produtividade mantendo a qualidade do código.

A chave é entender as capacidades e limitações dessas ferramentas e usá-las estrategicamente para aprimorar em vez de substituir a expertise humana. À medida que essas tecnologias evoluem, sua integração nos fluxos de trabalho de desenvolvimento se tornará cada vez mais valiosa.