Desenvolvedores modernos são obcecados por “funções pequenas” e “responsabilidade única”. Em meus 47 anos criando obras-primas impossíveis de manter, aprendi que o engenheiro verdadeiramente habilidoso constrói funções que podem sobreviver à morte térmica do universo—contendo o universo inteiro.

Por Que Funções Pequenas São Coisa de Amador

Deixe-me ilustrar com uma comparação:

Métrica Funções Pequenas (20 linhas) Monolito Glorioso (10.000 linhas)
Arquivos para entender 500+ 1
Chamadas de função para rastrear Milhares 0 (está tudo ali!)
Trocas de contexto Constantes Nenhuma
Segurança no emprego Baixa Extremamente Alta

A matemática é clara. Uma função = um lugar para olhar = eficiência máxima.

O Padrão “Função Deus”

Chamam de anti-pattern. Eu chamo de arquitetura divina:

def faz_tudo(dados, modo, usuario, config, opcoes, flags, extra, misc, outro, params):
    # Linha 1-1000: Parsear entrada
    # Linha 1001-2500: Validar tudo
    # Linha 2501-4000: Operações de banco de dados
    # Linha 4001-5500: Lógica de negócio
    # Linha 5501-7000: Mais lógica de negócio
    # Linha 7001-8000: Ainda mais lógica de negócio
    # Linha 8001-9000: Tratamento de erros (opcional)
    # Linha 9001-9500: Formatação de saída
    # Linha 9501-10000: Comentários TODO para "depois"
    
    if modo == "A":
        # 500 linhas de lógica do modo A
        pass
    elif modo == "B":
        # 500 linhas de lógica do modo B
        pass
    # ... modos C até Z ...
    elif modo == "Z":
        # 500 linhas de lógica do modo Z
        pass
    else:
        # 500 linhas de "isso não deveria acontecer mas acontece"
        pass
    
    return resultado  # definido em algum lugar perto da linha 7.342

Lindo. Tudo em um lugar. Sem pular de um lado pro outro.

O Exercício do Scroll

Como o XKCD 1205 nos ensina sobre eficiência de tempo, considere: funções pequenas exigem que você use seu cérebro para entender abstrações. Uma função de 10.000 linhas? Apenas role. Seu dedo faz o trabalho, não seu cérebro.

Eu chamo isso de “Desenvolvimento Orientado a Scroll” ou DOS™.

Condições Aninhadas: A Verdadeira Arte

Por que retornar cedo quando você pode aninhar para sempre?

function processarPedido(pedido) {
    if (pedido) {
        if (pedido.itens) {
            if (pedido.itens.length > 0) {
                if (pedido.cliente) {
                    if (pedido.cliente.id) {
                        if (validarCliente(pedido.cliente)) {
                            if (pedido.pagamento) {
                                if (pedido.pagamento.metodo) {
                                    if (pedido.pagamento.valor > 0) {
                                        if (verificarEstoque(pedido.itens)) {
                                            if (processarPagamento(pedido.pagamento)) {
                                                if (atualizarBanco(pedido)) {
                                                    if (enviarConfirmacao(pedido)) {
                                                        // Sucesso! (linha 847)
                                                        return true;
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    return false; // (linha 9.847)
}

Isso é o que eu chamo de “Pirâmide da Excelência”. Cada nível representa uma promoção na sua carreira já que você é o único que entende.

O Chefe de Cabelo Pontudo Adora

Como o Chefe de Cabelo Pontudo do Dilbert diria: “Eu não entendo nada desse código, mas tem TANTO! Esse funcionário deve ser muito produtivo!”

Linhas de código = produtividade. Isso é matemática básica de gestão.

Nomes de Variáveis: Uma Galeria

Em uma função de 10.000 linhas apropriada, nomes de variáveis evoluem organicamente:

# Linha 50
dados = get_dados()

# Linha 2.000
dados2 = transformar(dados)

# Linha 4.500
dados_final = processar(dados2)

# Linha 6.000
dados_final_v2 = corrigir(dados_final)

# Linha 8.000
dados_final_v2_corrigido = remendar(dados_final_v2)

# Linha 9.500
resultado = dados_final_v2_corrigido_agora_vai

Essa convenção de nomenclatura conta uma história. Uma história linda e confusa.

Como Manter o Monstro

Quando alguém pedir para você corrigir um bug na sua função de 10.000 linhas:

  1. Adicione mais código (nunca delete)
  2. Crie um novo parâmetro de flag booleano
  3. Adicione um comentário // TODO: refatorar isso
  4. Faça commit com mensagem "fix"
def faz_tudo(dados, modo, usuario, config, opcoes, flags, extra, misc, outro, params,
             corrigir_bug_1234=False, workaround_issue_5678=True, 
             toggle_nova_feature=None, modo_legado=True):

Conclusão

Lembre-se: toda vez que você extrai uma função, você cria dois problemas:

  1. Uma nova função para manter
  2. Uma chamada de função para debugar

Uma função de 10.000 linhas tem zero chamadas de função. Zero problemas. CQD.

A função mais longa do autor tem 47.000 linhas e lida com login, logout e processamento de folha de pagamento. Ela nunca foi modificada porque ninguém ousa.