Entre Dobras

Seu código ruim funciona. Esse é o problema.

A arquitetura de software não prova seu valor na primeira entrega, mas em todas as mudanças que vêm depois.

Ítalo Castro7 min de leitura
Imagem de abertura do artigo “Seu código ruim funciona. Esse é o problema.”

Existe uma coisa perigosa sobre código ruim:

Ele funciona.

A funcionalidade pode ser entregue, os testes podem passar.

O sistema pode entrar em produção, o cliente pode usar e ficar satisfeito.

Se o código ruim simplesmente quebrasse no primeiro dia, seria fácil identificá-lo e corrigi-lo o problema é que ele consegue sobreviver por bastante tempo.

Às vezes, por anos, a conta aparece quando alguma coisa precisa mudar.

A primeira entrega mente no início de um projeto, quase qualquer arquitetura parece boa.

Existem poucas regras, poucas integrações poucos desenvolvedores.

A equipe ainda lembra por que cada decisão foi tomada, nesse momento, adicionar mais uma funcionalidade é relativamente simples. O sistema é pequeno o suficiente para caber na cabeça de quem o construiu.

A velocidade inicial cria uma sensação de que a arquitetura está funcionando.

Talvez esteja.

Ou talvez ainda não tenha sido testada pelo tempo, a arquitetura começa a revelar sua qualidade quando:

- uma regra muda;

- uma tecnologia precisa ser substituída;

- uma nova integração aparece;

- outra pessoa entra no projeto;

- uma funcionalidade antiga precisa ser testada isoladamente;

- o sistema precisa continuar evoluindo sem quebrar o que já existe.

É aí que percebemos se construímos um sistema ou apenas acumulamos código que funciona.

De MongoDB para PostgreSQL

Vivi uma situação em produção que materializou essa diferença.

O sistema utilizava MongoDB como mecanismo de persistência.

Com a evolução do produto, começaram a aparecer necessidades cada vez mais relacionais. As consultas exigiam relações e comportamentos que faziam mais sentido em um banco relacional.

A decisão foi migrar do MongoDB para o PostgreSQL, não foi uma alteração pequena.

Precisávamos modelar os dados de outra forma, criar a nova estrutura, migrar as informações e adaptar a camada responsável pela persistência.

Havia trabalho real, arquitetura limpa não faz um banco de dados desaparecer para que outro surja magicamente no lugar.

O que ela fez foi impedir que a mudança do banco exigisse também uma reescrita das regras de negócio.

A aplicação precisava continuar respondendo às mesmas perguntas as regras continuavam válidas.

O produto não havia mudado de propósito apenas porque a tecnologia de persistência mudou.

Como as responsabilidades estavam separadas, conseguimos concentrar a troca na parte do sistema que realmente precisava mudar.

MongoDB saiu.

PostgreSQL entrou.

A regra de negócio permaneceu protegida, o banco não deveria mandar no negócio

É comum começarmos um sistema pelo banco de dados.

Criamos as tabelas ou coleções, depois construímos os serviços ao redor da estrutura escolhida, com o tempo, a forma de persistir passa a determinar a forma de pensar o próprio negócio.

A regra já não diz apenas o que precisa acontecer, ela começa a conhecer detalhes de consulta, estrutura de documento, framework e tecnologia.

O banco deixa de ser uma ferramenta usada pelo sistema, passa a ser o lugar onde o sistema inteiro está preso.

Enquanto nada muda, isso pode parecer eficiente, há menos abstrações, menos interfaces, menos arquivos.

A implementação inicial fica rápida, só que velocidade na primeira entrega não é a única medida de uma arquitetura.

Um banco de dados é uma decisão importante, mas continua sendo uma tecnologia.

A regra que calcula um valor, aprova uma operação ou define o comportamento do produto representa o motivo pelo qual o software existe.

Quando misturamos os dois, qualquer mudança de infraestrutura ameaça o centro do negócio.

O que significa estar desacoplado?

Desacoplamento não significa ausência de dependências.

Todo sistema depende de alguma coisa.

Precisávamos do MongoDB antes, passamos a precisar do PostgreSQL depois.

O ponto é definir a direção dessas dependências, a regra de negócio não deveria precisar conhecer detalhes do banco para existir.

Ela deveria trabalhar com contratos que expressem aquilo de que precisa:

- buscar determinada informação;

- salvar uma entidade;

- recuperar um conjunto de dados;

- verificar uma condição.

A implementação concreta desses contratos pode utilizar MongoDB, PostgreSQL ou outra tecnologia, trocar o banco ainda exige trabalho.

Mas o trabalho fica no limite do sistema, não espalhado dentro das regras centrais.

Essa é uma das ideias mais importantes da Clean Architecture.

Não se trata apenas de separar o projeto em pastas com nomes bonitos.

bTrata-se de proteger aquilo que muda por motivos de negócio daquilo que muda por motivos técnicos, código ruim cobra juros

Uma arquitetura deficiente raramente apresenta uma fatura única, ela cobra juros, a primeira funcionalidade leva um dia a segunda leva dois, depois, uma alteração aparentemente pequena exige tocar em cinco partes do sistema.

Os testes precisam subir banco, fila e serviços externos, ninguém sabe ao certo quais comportamentos podem quebrar, a equipe começa a adicionar condições dentro de condições porque alterar a estrutura parece mais perigoso que continuar remendando.

O código ainda funciona, esse é o problema.

Como continua funcionando, sempre existe uma justificativa para adiar a correção, temos uma entrega urgente, o cliente precisa da funcionalidade, na próxima sprint organizamos.

Depois criamos os testes, em algum momento, a equipe já não entrega devagar porque perdeu competência, entrega devagar porque cada mudança precisa atravessar todas as decisões que foram adiadas.

Código ruim não avisa que é ruim na primeira entrega. Ele cobra em cada mudança seguinte.

A arquitetura aparece na décima funcionalidade, uma estrutura improvisada pode ser mais rápida para entregar a primeira versão.

Às vezes, essa é inclusive a decisão correta, nem todo software precisa viver durante dez anos.

Nem todo projeto precisa suportar trocas de tecnologia, dezenas de integrações ou regras complexas de negócio, o problema é tratar a velocidade inicial como prova definitiva da qualidade da arquitetura.

A diferença aparece depois, em uma arquitetura saudável, o esforço necessário para mudar o sistema permanece relativamente controlado.

Em uma arquitetura ruim, cada funcionalidade aumenta o custo da próxima.

A primeira entrega gera confiança., a décima revela a dívida.

Por isso, arquitetura não deve ser avaliada apenas por quanto tempo levamos para colocar a primeira versão em produção.

Também precisamos observar:

- quanto custa alterar uma regra;

- quanto do sistema precisa ser conhecido para fazer uma mudança;

- quais partes conseguem ser testadas isoladamente;

- quanto medo uma pequena alteração gera;

- quanto conhecimento existe apenas na cabeça de uma pessoa.

Manutenibilidade é uma medida de velocidade ao longo do tempo.

Clean Architecture não é uma religião

Existe um erro no outro extremo.

Depois de aprender Clean Architecture, algumas equipes passam a aplicá-la como uma fórmula universal, criam camadas, interfaces, adaptadores e casos de uso para sistemas que talvez nunca precisem daquela estrutura.

Um CRUD simples ganha dezenas de arquivos, uma alteração pequena precisa atravessar abstrações que não protegem nenhuma complexidade real.

O código fica “limpo” no diagrama e cansativo para quem precisa trabalhar nele.

Arquitetura também possui custo.

A pergunta não é:

“Estamos seguindo todos os círculos corretamente?”

A pergunta é:

“Quais partes deste sistema precisam continuar independentes porque provavelmente mudarão em ritmos diferentes?”

Se existe uma regra de negócio importante que deve sobreviver a frameworks, bancos e interfaces, faz sentido protegê-la.

Se estamos construindo algo temporário, pequeno e com poucas chances de evolução, uma estrutura mais simples pode ser suficiente.

Uma arquitetura limpa não é aquela que possui mais camadas, é aquela na qual as fronteiras ajudam o sistema a mudar.

Sustentabilidade não aparece na demo o cliente raramente olha para uma demonstração e pergunta se as dependências apontam na direção correta.

Ele quer saber se o produto resolve o problema.

E está certo, eu defendo muito isso!

Arquitetura não deveria competir com o valor entregue.

Ela existe para permitir que esse valor continue sendo entregue depois, o desafio é que a sustentabilidade de um sistema quase sempre é invisível no começo.

Duas implementações podem produzir a mesma tela, podem responder à mesma requisição, podem executar no mesmo tempo.

Uma delas, porém, permite mudar a persistência sem reescrever as regras.

A outra espalha detalhes técnicos pelo produto inteiro para o usuário, elas parecem iguais hoje para a empresa, terão custos completamente diferentes amanhã.

A arquitetura não precisa prever tudo, quando adotamos uma estrutura mais limpa, não estamos afirmando que sabemos exatamente como o sistema mudará.

No nosso caso, ninguém precisava prever todos os detalhes da migração para PostgreSQL, precisávamos apenas reconhecer que o mecanismo de persistência não deveria possuir o negócio.

Essa fronteira preservou uma opção, quando as consultas relacionais começaram a justificar outra tecnologia, a troca era difícil, mas possível.

Essa é uma forma mais madura de pensar arquitetura, não tentar prever cada requisito futuro, construir limites claros ao redor das partes mais importantes para que o sistema consiga absorver mudanças que ainda não conhecemos.

Toda arquitetura é uma aposta, não sabemos exatamente o que mudará.

Mas podemos evitar que uma decisão técnica temporária se torne uma prisão permanente.

Seu código ruim funciona

Talvez o sistema esteja funcionando hoje, isso não encerra a discussão sobre qualidade.

A pergunta não é apenas se ele entrega.

É quanto custará continuar entregando.

Se cada mudança demora mais que a anterior, se os testes dependem de tudo e se trocar uma tecnologia ameaça as regras de negócio, o sistema está enviando um sinal.

A arquitetura deixou de sustentar o crescimento, foi isso que a migração de MongoDB para PostgreSQL reforçou para mim.

Clean Architecture não eliminou o trabalho.

Não tornou a mudança automática, não adivinhou qual banco usaríamos no futuro.

Ela fez algo mais útil:

Manteve a mudança técnica no lugar em que ela deveria acontecer.

O código ruim também consegue chegar à produção, a diferença é o que acontece quando a produção exige que ele mude.

E essa foi mais uma dobra de: construir software que continue mudando sem precisar esquecer por que existe.

Nos vemos na próxima quinta, às 10:10.

Escrevi anteriormente um artigo mais técnico e acadêmico sobre Clean Architecture, testabilidade e sustentabilidade de sistemas:

https://medium.com/@italocastro2010/arquitetura-limpa-impactos-na-manutenibilidade-testabilidade-e-sustentabilidade-de-sistemas-de-de14fe21521a (3/3)

Também enviado pela newsletter — a conversa continua no Substack.

Quer levar uma dessas conversas para o seu evento ou empresa?

Quer trocar uma ideia sobre engenharia, produto ou IA?