5 Maneiras de Aumentar sua Produtividade em Codificação com IA Generativa

Como um Artesão de Software com anos de experiência no campo, 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 forma mais frequente como utilizo IA Generativa é para buscar informações técnicas. Os mecanismos de busca tradicionais exigem terminologia precisa, enquanto a IA Generativa compreende conceitos e contexto. Por exemplo, ao buscar o princípio de otimização de parâmetros de método, faço a seguinte pergunta:

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 compreende 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 de codificação repetitivas. Recentemente, precisei converter um grande arquivo JSON em instruções de inserção de banco de dados. Em vez de escrever código de conversão tedioso, forneci os dados JSON à IA com instruções claras para gerar instruções de inserção do MS SQL Server. Essa 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"  
}  
]

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. 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 a IA de duas maneiras cruciais:

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

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

Essa capacidade acelerou significativamente nosso processo de migração e garantiu consistência nas 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]

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

A documentação é essencial, mas geralmente tediosa. A IA Generativa simplifica esse 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étodo que mantém os padrões de qualidade de código

Por exemplo, ao documentar algoritmos de classificação ou lógica de negócios complexa, a IA pode gerar documentação clara e precisa que segue os padrões da equipe e as 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_

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. Scaffolding 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 claro ou especificação, a IA pode criar:

• Scripts de criação de banco de dados

• Mapeamentos ORM

• Endpoints de API básicos

• Implementações iniciais de UI

Essa capacidade reduz significativamente o tempo gasto em código boilerplate 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

Output:

...
I'm saving you from the output, but it generated an entire application using 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?

Output:
Implement logging for better debugging and error handling.

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

Prompt 3:

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

Output:
You can also define global exception handlers in your main.py file if you want to handle specific exceptions globally.

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 o código gerado
• Manter consistência com bases de código existentes
• Considerar implicações de segurança
• Testar o código gerado completamente
• Usar a 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 scaffolding de aplicação - os desenvolvedores podem aumentar significativamente sua produtividade mantendo a qualidade do código.

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