Dividir o programa em módulos

O novelo de código

Todo programa nasce pequeno e simpático. Uma tela, uma conta, um resultado. O problema aparece com o crescimento: mais telas, mais regras, mais casos especiais. Se tudo vive no mesmo lugar, misturado, o programa vira um novelo. Você quer trocar a cor de um botão e, sem querer, quebra o cálculo do frete, porque a conta do frete estava escrita no meio do código que desenha o botão. Cada mudança dá medo, porque ninguém sabe o que mais depende daquele trecho. Esse é o sintoma clássico do código que não foi dividido.

A cura é a mesma de qualquer problema grande, e você já a usou o curso inteiro: dividir para conquistar. Só que aqui não é dividir o dado nem o cálculo, e sim dividir o próprio programa em módulos. Um módulo cuida de calcular, outro de mostrar na tela, outro de ler os dados de onde eles vierem. Cada um tem uma fronteira clara e um assunto. Quando você precisa mexer no cálculo, vai no módulo do cálculo, e só nele. A tela nem fica sabendo. Essa separação é o primeiro passo para um código que aguenta o tempo.

Uma coisa por módulo

O guia prático para dividir é a pergunta da responsabilidade única: qual é o único motivo pelo qual este módulo mudaria? Se você consegue responder com uma frase curta, o módulo está saudável. Se a resposta tem vários "e" (calcula o preço E formata o texto E salva no arquivo), ele faz coisas demais e cada uma dessas tarefas puxa o módulo para uma direção diferente. Separar não é enfeite: é o que permite testar o cálculo sem abrir a tela, trocar a tela sem tocar na conta, e reusar o mesmo cálculo em dois lugares. Uma função que só calcula recebe números e devolve números, previsível e fácil de testar.

// RUIM: uma função só, fazendo tudo, difícil de testar e reusar
funcao processarPedido(pedido)
  preco <- pedido.qtd * pedido.valor
  escreva("Total: R$ ", preco)   // já mostra na tela aqui dentro
  salvarNoArquivo(preco)          // e ainda salva
fim

// BOM: cada responsabilidade num módulo, ligadas por fora
funcao calcularTotal(pedido)      // módulo de cálculo: só conta
  retorne pedido.qtd * pedido.valor
fim
funcao mostrarTotal(total)        // módulo de tela: só exibe
  escreva("Total: R$ ", total)
fim
// quem coordena chama um, depois o outro:
total <- calcularTotal(pedido)
mostrarTotal(total)

A versão ruim mistura contar, mostrar e salvar. A boa dá a cada tarefa uma função com uma responsabilidade.

Quando vale a pena separar

Dividir tem custo: mais peças, mais nomes, mais lugares para olhar. Por isso não se quebra tudo em mil pedaços por esporte. O sinal de que chegou a hora de separar é concreto. Você percebe que copiou o mesmo cálculo em dois lugares (então ele merece virar um módulo reusado). Você não consegue testar a regra sem abrir a tela inteira (então a regra e a tela estão grudadas demais). Uma função passou de umas dezenas de linhas e faz três assuntos diferentes. Quando um desses sinais aparece, separar paga o custo. Antes disso, um programa pequeno pode viver junto sem problema.