Dando as boas-vindas e introduzindo o tema
Olá, sejam muito bem-vindas e bem-vindos de volta.
No vídeo anterior, eu fiz uma breve introdução sobre o curso e sobre mim. Agora, neste vídeo, nós vamos falar sobre o tema Funcional versus Sustentável.
Explicando a metáfora do iceberg e a estratégia de qualidade
Nesta lâmina que aparece à esquerda, mostramos um iceberg. Um iceberg é uma estrutura de gelo que geralmente aparece nos oceanos e tem uma parte visível acima do nível da água e uma parte muito maior invisível abaixo d’água. Um código sustentável é semelhante a um iceberg: há uma parte visível para fora, mas existe uma base que, se não for bem cuidada, não fica tão visível e pode se tornar um problema maior. A estrutura que fica embaixo e sustenta esse iceberg — a estrutura que sustenta o código — precisa estar muito bem pensada, definida e fundamentada.
Qualidade é uma estratégia de sobrevivência. O valor de negócio é entregue por meio do software. O meio de produção é o código. Qualidade não é um luxo. Não é algo a ser feito apenas se sobrar tempo, equipe ou orçamento. Qualidade deve ser um requisito prévio, porque é a estratégia que vai garantir a sobrevivência do produto.
Se não tivermos cuidado, enfrentaremos um custo composto:
- retrabalho;
- medo de mudança;
- incidentes que se acumulam silenciosamente;
- velocidade insustentável.
Isso leva a um ritmo acelerado sem padrão, resultando em colapso no médio e no longo prazo.
Defendendo método reprodutível e padrões de equipe
Se tivermos método reprodutível, revisões e padrões, transformaremos a experiência em processo de equipe. Sem método reprodutível e sem padrões, cada revisão será feita de um jeito, cada pessoa revisora analisará o código de uma forma, e acabaremos com um código “Frankenstein”, pensado de formas distintas por cada pessoa, baseado em gosto e opinião, e não em uma ideia coesa e unificada, na qual a equipe define os melhores padrões, aplica esses padrões e utiliza também referências do mercado.
Aqui vale um adendo: não existe a melhor técnica ou o melhor padrão absoluto. Não existe bala de prata. Cada equipe definirá o que é melhor conforme seu contexto e área de atuação, utilizando padrões de mercado, mas também fazendo acordos internos. É importante combinar essas duas frentes: usar frameworks — que, inclusive, vamos mostrar aqui — e respeitar os acordos da equipe, aplicando o que foi definido para uso nas revisões de código.
Apresentando as ferramentas e o escopo do curso
Antes de continuar, após essa breve introdução, queremos deixar claro que, neste curso, daremos prioridade a ferramentas de SaaS (software como serviço), ferramentas que rodam na nuvem, para evitar preocupações com servidores e provisionamento de infraestrutura. Assim, é muito mais simples conectar ferramentas já disponíveis na internet para uso imediato.
A única ferramenta que não seguirá esse padrão é o CURTOR, que vamos usar aqui. É um IDE (ambiente de desenvolvimento integrado) de código. Ele estará em execução local, em nossa máquina, e nós vamos escrever o código tal como no dia a dia.
Com essa única exceção, usaremos o SonarCloud, hospedado na própria infraestrutura da Sonar. Nós apenas o conectaremos à nossa conta no GitHub, seguindo a sequência.
Nós também vamos usar o GitHub para armazenar e versionar o código. O repositório, as pull requests (solicitações de alteração) e a branch protection (proteção de ramificações) serão o núcleo do nosso fluxo, conectando-se ao SonarCloud.
No GitHub, nós temos também o GitHub Actions para criar as pipelines (esteiras) de execução do nosso código e de nossas métricas de qualidade. A própria integração com o SonarCloud será executada nessa pipeline. Podemos criar convenções para que elas ocorram automaticamente na pipeline.
Neste curso, nós não vamos cobrir testes integrados. O foco não é falar de testes, e sim de revisão de código. No entanto, GitHub e GitHub Actions são ferramentas nas quais também é possível incorporar testes na pipeline.
Contrastando código funcional e sustentável
Seguindo para o tema deste vídeo, propriamente dito: funcional versus sustentável. Código funcional satisfaz o teste de hoje. Código sustentável permitirá mudanças previsíveis amanhã, com custo de erro controlado.
Hoje, se pensarmos apenas no momento atual, quando estamos escrevendo o código, e fizermos um código que “funciona”, o teste vai passar e o deploy (implantação) vai acontecer. Porém, se a estrutura tiver nomes opacos, lógica altamente acoplada e testes apenas nas extremidades — ou seja, sem garantir testabilidade, extensibilidade e a possibilidade de adicionar mais parâmetros ou funções sem quebrar o comportamento original — o impacto, a longo prazo, será negativo. Não teremos um código sustentável, e sim um código que simplesmente funciona naquele momento, mas não se sustenta no longo prazo. Em outras palavras, sustentável é sinônimo de funcionar no longo prazo: é um código que seguirá sendo utilizado por muito tempo, receberá atualizações e incrementos, e não precisará ser refeito por completo para continuar funcionando.
Pensando em amanhã: chega a mudança; quem for modificar tem receio; o impacto é pior do que o esperado. Para evitar isso, precisamos de:
- legibilidade, para reduzir a carga cognitiva;
- manutenibilidade e mais testes, garantindo mudança segura.
Se o código é legível, fácil de interpretar, ele impõe menor carga cognitiva para quem precisa mantê-lo ou evoluí-lo. Se é fácil de manter e testável, a mudança é segura, porque qualquer alteração não deve prejudicar o funcionamento original. Os testes fornecem o indicativo de se a alteração preservou o comportamento esperado.
Também precisamos tornar os trade-offs explícitos. Não é possível maximizar tudo ao mesmo tempo. Precisamos decidir, conforme o momento do projeto, se vale mais a pena construir algo extremamente organizado e distribuído, ou entregar uma versão mais simples, mas muito bem construída, compreensível e fácil de manter. Não teremos tudo que gostaríamos de imediato. Talvez precisemos de mais tempo para construir algo de longo prazo, sem abrir mão do que realmente importa.
Detalhando as dimensões da qualidade
Por fim, temos cinco dimensões da qualidade. Qualidade é multidimensional; portanto, é uma decisão de engenharia e não pode se basear apenas em opinião. Dentre elas:
- Correção: o software faz o que deve fazer em todos os cenários relevantes.
- Testabilidade: código que pode ser verificado automaticamente com esforço razoável.
Se o código é testável, facilmente testável, isso é um indicativo de que ele é bom e adequado para ter uma longa vida útil.
Segurança significa ausência de vulnerabilidades exploráveis: autenticação, dados, injeção.
Legibilidade implica uma intenção clara para qualquer membro da equipe, não apenas para a pessoa autora. Costumamos afirmar em aula que o grande desafio não é escrever código para que a máquina entenda; o grande desafio é escrever código que outra pessoa entenda. A máquina pode executar um código muito mal escrito, com nomes de funções dúbios, nomes de variáveis pouco claros e funções que fazem muitas coisas ao mesmo tempo. Mesmo que, em uma leitura humana, não fique claro de imediato e exija tempo para interpretação, a máquina o executará. Porém, imagine outra pessoa que precisa assumir esse código sem nenhum contexto, sem tê-lo criado, e precisa ler tudo e entender. Se o código não foi pensado para que outra pessoa pudesse lê-lo — isto é, foi escrito apenas para “funcionar” e não foi organizado de forma adequada — isso compromete a manutenção.
Por último, observabilidade: logs, métricas e traces que permitem entender o sistema em produção. Também não vamos cobrir observabilidade aqui. O foco não são testes, mas também não é observabilidade. Não vamos chegar ao ponto de conectar uma ferramenta de observabilidade, usar um código ótimo, um Datadog. Contudo, ao pensar em qualidade como um todo, não podemos deixar esse tema de fora. É necessário considerá-lo no futuro, além do conjunto de tópicos que vamos tratar aqui ao falar de revisão de código. Para ter um código em produção que seja facilmente mantido e corrigido, precisamos considerar testes e observabilidade, além dos itens desta aula.
Exemplificando com versão original do código
Agora, vamos a um exemplo mais prático. Temos, na tela, duas versões do mesmo código.
Na versão original, há uma função calc, recebendo os parâmetros o, p entre (), e abrindo {} para começar a função. Em seguida, let t = 0, um for com let i of o e {} abrindo o bloco. Depois, um if i.t === p, seguido de t += i.v. Logo de início observa-se que isso é um código medíocre. O nome da função é genérico e não comunica exatamente o que ela faz; indica que vai calcular algo, mas o quê? Os nomes das variáveis estão reduzidos a letras: let t — o que é t? O que representa isso? let i of o — i não comunica nada, e o comunica menos ainda. i.t complica ainda mais. Portanto, os nomes das variáveis e o nome da função não dizem absolutamente nada para quem for ler no futuro. Vai funcionar? Sim, a máquina interpretará. No entanto, está longe de ser um código bem escrito, pensado para que uma pessoa possa interpretá-lo e dar manutenção.
Para materializar essa primeira versão, observe o trecho abaixo:
function calc(o, p) {
let t = 0;
for (let i of o) {
if (i.t === p)
t += i.v;
}
return t;
}
Resumindo os problemas dessa versão:
- Nomes opacos.
- Intenção invisível.
- Onboarding (integração inicial) difícil.
- Medo de alterar no futuro.
Refatorando para uma versão legível e sustentável
Em seguida, trazemos uma versão muito mais pensada e organizada, com a função sumPricesForType (corrigindo o nome para refletir a intenção do código). Aqui indicamos explicitamente o que queremos fazer: somar preços por tipo. Apenas lendo o nome da função já temos uma pista do que ela realiza. Como parâmetros, recebemos orders e productType, o que indica claramente que trabalhamos com uma lista de pedidos (orders) e um tipo de produto (productType).
O código está em inglês porque existe uma convenção internacional de escrever o código em inglês e só colocar no idioma nativo mensagens que se comunicam diretamente com a pessoa usuária. Escrever código em inglês facilita a manutenção por pessoas de outros países. Diferentemente de escrever código em português, por exemplo: se uma pessoa dos Estados Unidos entrar no projeto, terá dificuldade para manter um código em português; o mesmo para uma pessoa da Alemanha, da França ou de qualquer outro país. O inglês, hoje, é mais universal.
Seguindo com a explicação, há um retorno que aplica orders.filter(...), onde comparamos o.type === productType. A letra o, neste caso, é aceitável porque está explícito que usamos um método de filtragem que recebe um callback (função de retorno) e, aí, o representa um elemento do array que estamos percorrendo. Não é necessário um nome mais descritivo nesse ponto específico porque o contexto do filter() deixa claro que o é um objeto de orders. Nos demais pontos, tudo está explícito: o.type é o nome da propriedade que queremos capturar, o que é muito diferente de usar o.t, por exemplo. productType é um parâmetro que veio como requisito da função.
Depois, aplicamos reduce, isto é, realizamos a soma, usando sum e o objeto o (instância de Order), fazendo sum + o.price, partindo de 0. Nesse caso, temos nomes de domínio, responsabilidade clara, facilidade para testar e facilidade para revisar.
Veja como essa segunda versão se apresenta no código:
function sumPricesForType(
orders, productType) {
return orders
.filter(o => o.type === productType)
.reduce((sum, o) => sum + o.price, 0);
}
A diferença prática aparece em termos de qualidade de onboarding (integração inicial), ocorrência de bugs (defeitos) e medo do deploy (implantação), não no número de linhas de código. Em quantidade de linhas, ambos os códigos têm volume semelhante; talvez o segundo tenha um pouco menos. Porém, o importante não é o código ser grande ou pequeno, e sim legível. Se, ao ler uma vez, já entendemos o que está acontecendo, atingimos o objetivo. No segundo exemplo, conseguimos isso; no primeiro, não. No primeiro, seria necessário interpretar, testar e passar por um onboarding mais complexo, isto é, uma iniciação mais trabalhosa naquele código.
Reforçando pilares de qualidade e encerrando o vídeo
Qualidade é igual a decisão repetível. Qualidade não é “sorte” da pessoa desenvolvedora experiente; é um padrão explícito, com revisão e automação sempre que possível.
- Padrão explícito: o código precisa estar documentado, acordado e com responsabilidade compartilhada por toda a equipe.
- Revisão de código: é uma barreira humana que garante a aderência à base de conhecimento. É o momento em que outra pessoa critica o código para verificar se algo foi esquecido ou se algum padrão não foi seguido.
- Automação: SONAR, LINT e testes fecham o que o olho humano não consegue captar todos os dias. O SONAR avalia detalhes como cobertura de testes e possíveis smells (indícios de problema no código). O LINT verifica se os padrões acordados com a equipe estão sendo seguidos — por exemplo, usar ponto e vírgula (;) ou não no código. Haverá projetos em que o uso de ponto e vírgula será obrigatório e o LINT acusará se faltar; em outros, não será. Esse é apenas um detalhe entre muitos outros em que o LINT ajuda. E os testes verificam se o código é testável e se está passando, evitando que uma pessoa precise testar manualmente cada alteração a cada nova linha adicionada.
Bom, isso é o que eu tinha para este vídeo. Eu espero que vocês tenham gostado e nos vemos em um próximo vídeo.