O que você faz quando a revisão de código é muito difícil?

OK, então muitas revisões de código são bastante rotineiras. Mas, ocasionalmente, há mudanças que afetam amplamente o código complexo e frágil existente. Nessa situação, o tempo que levaria para verificar a segurança das alterações, a ausência de regressão etc. é excessivo. Talvez até excedendo o tempo necessário para fazer o próprio desenvolvimento.

O que fazer nessa situação? Mesclar e esperar que nada deslize? (Não defendo isso!) O melhor que se pode fazer e tentar detectar apenas falhas óbvias (talvez essa seja a melhor revisão de código que se deve procurar?) Mesclar e testar detalhadamente como uma alternativa melhor do que a revisão de código?

Isso não é especificamente uma questão de saber se o teste deve ser feito como parte de uma revisão de código. Esta é uma pergunta que pergunta quais são as melhores opções na situação descrita, especialmente com um prazo final, nenhum conjunto abrangente de testes de unidade disponíveis ou testes de unidade não viáveis ​​para o código fragmentado alterado.

EDIT: Tenho a impressão de que algumas das respostas / comentários até agora captaram a minha frase "impacto amplo" e, possivelmente, isso significa que a mudança envolveu um grande número de linhas de código. Entendo que essa seja a interpretação, mas essa não era minha intenção. Por "impacto amplo", quero dizer, por exemplo, que o potencial de regressão é alto devido à interconectividade da base de código ou ao escopo dos efeitos indiretos, não necessariamente pelo fato de a mudança em si ser grande. Por exemplo, um desenvolvedor pode encontrar uma maneira de corrigir um bug com uma única linha chamando uma rotina de alto nível existente que envia em cascata as chamadas para muitas rotinas de nível inferior. Testar e verificar se a correção de bug funcionou é fácil. Validar manualmente (via revisão de código) o impacto de todos os efeitos indiretos é muito mais difícil.

A premissa da pergunta é, francamente, surpreendente. Supomos que haja uma grande alteração no código frágil e complexo e que simplesmente não haja tempo suficiente para revisá-lo adequadamente . Este é o último código que você deve gastar menos tempo revisando! Essa pergunta indica que você tem problemas estruturais, não apenas no seu próprio código, mas em sua metodologia de gerenciamento de alterações.

Então, como lidar com esta situação? Comece por não entrar nele:

• Identifique fontes de complexidade e aplique refatorações corretas cuidadosamente revisadas e pesadas para aumentar o nível de abstração. O código deve ser compreensível por um novo funcionário recém-formado que saiba algo sobre o domínio da sua empresa.

• Identificar fontes de fragilidade; isso pode ser feito através da revisão do próprio código, examinando o histórico de correções de bugs no código e assim por diante. Determine quais subsistemas são frágeis e os torne mais robustos . Adicione lógica de depuração. Adicione afirmações. Crie uma implementação lenta, mas obviamente correta, do mesmo algoritmo e, na sua compilação de depuração, execute os dois e verifique se eles concordam. Na sua compilação de depuração, faça com que situações raras ocorram com mais frequência. (Por exemplo, crie um alocador de memória que sempre mova um bloco na realocação ou sempre aloque um bloco no final de uma página ou qualquer outra coisa.) Torne o código robusto diante das alterações em seu contexto. Agora você não tem mais código frágil; agora você tem um código que encontra os bugs, em vez de causar os bugs.

• Escreva um conjunto de testes automatizados. Obviamente.

• Não faça grandes mudanças. Faça uma série de pequenas alterações direcionadas, cada uma das quais pode ser vista como correta.

Mas, fundamentalmente, seu cenário é "nós nos metemos em um buraco de dívida técnica e cada mudança complexa e não revisada nos aprofunda; o que devemos fazer?". O que você faz quando se encontra naquele buraco? Pare de cavar . Se você tem tanta dívida que não consegue executar tarefas básicas, como revisar o código uma da outra, precisará parar de fazer mais dívidas e gastar tempo pagando-as.

Um dos principais objetivos de uma revisão de código é aumentar a qualidade e fornecer código robusto . Robusto, porque quatro olhos geralmente identificam mais problemas que 2. E o revisor que não escreveu o código adicional tem mais probabilidade de contestar suposições (potencialmente erradas).

Evitar a revisão por pares, no seu caso, apenas contribuiria para aumentar a fragilidade do seu código. Obviamente, reforçar os testes com um conjunto de testes sólido e repetível certamente poderia melhorar a qualidade. Mas deve ser complementar à revisão por pares, não uma substituição .

Penso que a complexidade deve ser entendida e dominada, e a revisão por pares completa é a ocasião para compartilhar conhecimento e conseguir isso. O investimento que você faz para que mais pessoas entendam a força e a fraqueza do código frágil ajudará a melhorá-lo ao longo do tempo.

Uma citação para concluir:

"Se você quer ir rápido, vá sozinho. Se você quiser ir longe, vá junto"

Bem-vindo ao mundo do desenvolvimento de software legado.

Você tem centenas de milhares, milhões, 10s de milhões de linhas de código.

Essas linhas de código são valiosas, pois produzem um fluxo de receita e sua substituição é inviável.

Seu modelo de negócios se baseia na alavancagem dessa base de código. Portanto, sua equipe é pequena, a base de código é grande. A adição de recursos é necessária para que as pessoas comprem uma nova versão do seu código ou para manter os clientes existentes satisfeitos.

Em um mundo perfeito, sua enorme base de código é testada em unidade no wazoo. Você não vive em um mundo perfeito.

Em um mundo menos perfeito, você tem o orçamento para corrigir sua dívida técnica - divida seu código em partes testáveis ​​por unidade, faça testes intensivos de integração e itere.

Isso, no entanto, está pagando dívidas sem produzir novos recursos. O que não corresponde ao caso comercial de "obter lucros com o código existente, ao modificá-lo para gerar incentivo à atualização".

Você pode pegar grandes pedaços de código e reescrevê-lo usando técnicas mais modernas. Mas em todos os lugares em que você interage com o código existente, você expõe possíveis pontos de interrupção. Esse hack no sistema do qual você se livrou realmente compensou uma peculiaridade em um subsistema que você não reescreveu. Sempre.

O que você pode fazer é agir com cuidado. Você pode encontrar parte do código que realmente entende e cujo comportamento e interação com o resto do sistema são bem compreendidos. Você pode modernizar isso, adicionando testes de unidade e tornando seu comportamento ainda mais claro.

Em seguida, encontre as partes do restante do aplicativo que interagem principalmente com ele e ataque-as uma por vez.

Ao fazer isso, você pode melhorar o subsistema, adicionando recursos pelos quais os clientes estão dispostos a pagar.

Em suma, essa é a arte do possível - fazer alterações sem quebrar as coisas que fornecem um caso de negócios.

Mas essa não é sua pergunta. Sua pergunta é: "Estou fazendo algo enorme e com probabilidade de quebrar coisas, e como sigo as melhores práticas?"

Ao fazer algo enorme, é verdade que, se você quiser fazer isso de maneira confiável, acaba gastando mais esforço em rastrear bugs e corrigi-los do que em escrevê-los. Essa é a regra geral do desenvolvimento de software: escrever coisas é fácil, fazer com que funcione perfeitamente é difícil.

Você provavelmente tem um caso de negócios pairando sobre sua cabeça, em que prometeu a alguma parte interessada que essa mudança maciça ocorre. E está "concluída", então você se empurra ao dizer "não, isso não está feito, apenas parece gosto disso".

Se você tem poder e orçamento, na verdade gaste o esforço gerando confiança de que a mudança funciona ou simplesmente rejeite a mudança. Isso vai ser uma questão de grau, não gentil.

Se você não tem tanto poder, mas ainda tem um pouco, tente insistir que o novo sistema seja testável por unidade . Se você reescrever algum subsistema, insista para que o novo subsistema seja composto de peças pequenas com comportamento bem especificado e testes de unidade ao seu redor.

Depois, há o pior caso. Você se aprofunda em dívidas. Você toma emprestado contra o futuro do programa, tendo mais código que é frágil e mais bugs para liberar o recurso agora e danar as conseqüências. Você faz o controle de qualidade baseado em varredura para encontrar os piores problemas e ignora o resto. Às vezes, essa é a resposta certa da perspectiva do negócio, já que é mais barata agora. Endividar-se para gerar lucros é uma estratégia comercial válida, especialmente se a liquidação da dívida por falência (abandonar o código) estiver sobre a mesa.

Um grande problema é que raramente os incentivos dos proprietários da empresa estão alinhados com os tomadores de decisão e os programadores. Tende a haver muita pressão para 'entregar', e isso gerando uma dívida técnica quase invisível (para seus superiores) é uma ótima estratégia de curto e às vezes a médio prazo. Mesmo que seus superiores / partes interessadas sejam melhor atendidos por não criar toda essa dívida.

Resolva os problemas maiores que estão fazendo com que a revisão de código seja muito difícil.

Os que eu vi até agora:

1. Sem suíte de teste de unidade
2. Mesclagens complexas de código que poderiam ser evitadas por uma estrutura de código mais sensível e delegação de tarefas de codificação
3. Uma aparente falta de arquitetura rudimentar

1. Você pode enviar a revisão de código de volta e pedir ao desenvolvedor para dividi-la em conjuntos de alterações menores e mais incrementais e enviar uma revisão de código menor.

2. Ainda é possível verificar odores, padrões e antipadrões de código, padrões de formatação de código, princípios do SOLID etc. sem necessariamente passar por todos os detalhes do código.

3. Você ainda pode executar inspeções de código tático para validação de entrada adequada, gerenciamento de bloqueios / encadeamentos, possíveis exceções não tratadas etc. em um nível detalhado, sem necessariamente entender a intenção geral de todo o conjunto de alterações.

4. Você pode fornecer uma avaliação das áreas de risco geral que você sabe que podem ser impactadas pelo código e solicitar ao desenvolvedor que confirme que essas áreas de risco foram testadas por unidade (ou solicite que ele escreva testes de unidade automatizados e envie-os para revisão também) )

Nessa situação, o tempo que levaria para verificar a segurança das alterações, a ausência de regressão etc. é excessivo.

As revisões de código não devem ter como objetivo principal a correção. Eles estão aqui para melhorar a legibilidade do código, a capacidade de manutenção e a aderência aos padrões da equipe.

Encontrar bugs de correção durante uma revisão de código é um bom subproduto, mas o desenvolvedor deve garantir que seu código funcione perfeitamente (incluindo a não regressão) antes de enviá-lo para revisão .

A correção deve ser incorporada desde o início. Se um desenvolvedor não for capaz de alcançá-lo, peça-o emparelhe o programa ou planeje um plano com toda a equipe, mas não o trate como algo que você pode adicionar como uma reflexão tardia.

Se você acha que a revisão do código é muito difícil, porque mudou o código quebradiço que é quase impossível de mudar sem quebrá-lo, você tem um problema. Mas o problema não está na revisão de código. O problema também não está nos testes de unidade, porque o código quebradiço não pode ser testado em unidade! Se o seu código fosse testável por unidade, ele seria dividido em unidades pequenas e independentes, para que cada uma pudesse ser testada e funcionasse bem juntas, e é exatamente isso que você não possui!

Então você tem um monte de código de lixo (também conhecido como "dívida técnica"). A pior coisa que você pode fazer é começar a consertar esse monte de código de lixo e não terminar o trabalho, pois dessa forma você terá um monte ainda maior de código de lixo. Portanto, a primeira coisa é convencer sua gerência a consertá-la e concluir o trabalho. Ou você não. Nesse caso, você simplesmente não toca.

Quando você o corrige, extrai uma unidade do código, transforma-a em algo que possui um comportamento bem definido e bem documentado, escreve testes de unidade para essa unidade, revisa-o e reza para que nada quebre. E então você faz o mesmo com a próxima unidade e assim por diante.

A parte complicada vem quando você encontra bugs. Seu ninho de código de ratos fará as coisas erradas em alguns casos, porque as coisas são tão frágeis e complicadas que as coisas dão errado. À medida que você extrai unidades, o código restante fica mais claro. (Eu tive um caso em que, após alguma refatoração, uma função começou com "if (condition1 && condition2 && condition3) crash ();" que era exatamente o comportamento antes da refatoração, apenas mais claro. Em seguida, apaguei essa linha :-) Você verá comportamento estranho e indesejado claramente, para que você possa corrigi-lo. Por outro lado, é aí que você deve alterar o comportamento do código existente, para que isso seja feito com cuidado).

Infelizmente, não há muito o que você possa fazer sobre isso no momento da revisão de código além de tomar outra xícara de café. A solução real para esse problema é resolver a dívida técnica que você acumulou: design frágil, falta de testes. Felizmente, você tem pelo menos algum tipo de controle de qualidade funcional. Se você não tem isso, sempre há orações por alguns ossos de galinha.

Se você não se contentar em enviar o software com erros / não funcionar e corrigi-lo mais tarde, o esforço de V&V DEVE ser maior que o esforço de desenvolvimento!

Se o código existente é frágil, a primeira pergunta é "você deveria alterá-lo?" A gerência precisa decidir se o custo / risco de redesenhar e reimplementar esse código é maior que o custo / risco de consertar a pilha vacilante de lixo. Se for único, pode ser mais fácil consertar o problema. Se é provável que haja mais mudanças necessárias no futuro, tomar o golpe agora para evitar mais dores no futuro pode ser uma decisão melhor. Você precisa aumentar isso com sua gerência, pois fornecer boas informações aos gerentes faz parte do seu trabalho. Eles precisam tomar essa decisão, porque é uma decisão estratégica que está acima do seu nível de responsabilidade.

Pela minha experiência, eu recomendo fortemente que você cubra seu código com uma quantidade razoável de testes, tanto de unidade quanto de integração, ANTES de fazer alterações no sistema em questão. É importante lembrar que hoje em dia há um número muito bom de ferramentas para esse fim, não importa a linguagem com a qual você está desenvolvendo.

Além disso, existe a ferramenta de todas as ferramentas para você criar seus testes de integração. Sim, estou falando de contêineres e especialmente de Docker e Docker Compose . Ele nos fornece uma maneira de configurar rapidamente um ambiente de aplicativos complexo, com infraestrutura (banco de dados, mongodb, servidores de filas etc.) e aplicativos.

As ferramentas estão disponíveis, use-as! :)

Não sei por que não foi mencionado ainda, mas essas duas são as peças mais importantes:

• Você divide a lista de alterações em várias listas menores, e depois revisa uma após a outra. *
• Se a revisão de uma lista de alterações não resultar em uma decisão de que a lista de alterações parece ser boa, você obviamente rejeita a alteração.

* Exemplo: você substitui a biblioteca A pela biblioteca B. Uma lista de alterações introduz a biblioteca B, várias listas de alterações diferentes substituem o uso de A por B peça por peça (por exemplo, uma lista de alterações por módulo) e a última lista de alterações exclui a biblioteca A.

Faça o melhor que puder e tente apenas detectar falhas óbvias (talvez essa seja a melhor revisão de código que você deve procurar)?

Não subestime o valor potencial das revisões de código. Eles podem ser bons em detectar bugs:

• Encontre erros que seriam difíceis de detectar durante o teste
• Encontre bugs que seriam difíceis de identificar / corrigir durante o teste

Eles também são úteis por outros motivos:

• Ajude a treinar os membros da equipe
• Ajude a garantir que o código atenda a outras métricas de qualidade, por exemplo, ajude a garantir que seja compreensível e sustentável, e não apenas livre de erros

O que fazer nessa situação?

No melhor / ideal caso, passar na inspeção de código não significa apenas "sem erros óbvios": significa "obviamente sem erros" (embora, é claro, você queira testá-lo também).

Se você não conseguir verificar a nova base de código por meio da inspeção de código, ela precisará de testes mais abrangentes da "caixa preta". Você pode estar acostumado a um ciclo de desenvolvimento em que coloca o código em produção após a aprovação na inspeção, mas se não pode "passar na inspeção", não é possível "colocá-lo em produção" e precisa de um ciclo mais longo: por exemplo, testes de integração , testes de sistema, testes alfa, testes de aceitação, testes beta, etc.

nenhum conjunto abrangente de testes de unidade disponíveis ou testes de unidade não viáveis ​​para o código fragmentado alterado

E os testes de integração, sistema e aceitação?

De qualquer forma, você provavelmente deve dizer ao gerente de projeto e ao gerente de produto que o código é quase certamente incorreto, com um número desconhecido de erros; e que eles "obterão o que inspecionam" em vez de apenas "obter o que esperam" - ou seja, que a qualidade do código não seja melhor que o teste (porque a qualidade do código não foi e não pode ser garantida pela inspeção do código) .

Eles devem retransmitir essa mensagem para o cliente ou usuários, para fazer testes beta (se quiserem adotar) ou usar a versão mais antiga até que a nova versão esteja fora de beta (se não estiverem).

Muitos códigos são gravados e mesclados sem a devida revisão de código. Isso pode funcionar. Há uma razão pela qual o código é chamado não cheira a "código quebrado" ou algo nesse sentido. A falta de revisão de código é um sinal de alerta, não um presságio de desgraça.

A solução para esse problema é que não há uma solução única para atender a todos os casos que podemos incluir em uma resposta no estilo StackExchange. É um forte consenso da comunidade de desenvolvimento de software que a revisão de código é uma "melhor prática" crucial e, nesse caso, está sendo ignorada. Seu desenvolvimento não está mais naquele canal estreito de "seguir todas as melhores práticas". Você precisará encontrar o seu próprio caminho.

O que é uma "melhor prática" de qualquer maneira? Quando você vai direto ao assunto, é um conjunto de práticas que as pessoas geralmente acham que melhoram o código. Eles fazem código certo? Parreira não! A internet está repleta de histórias de empresas que seguiram as "melhores práticas" e ficaram atoladas. Talvez um ponto de vista melhor das "melhores práticas" seja que elas são as soluções "ignore e esqueça" do mundo do software. Não sei nada sobre a sua empresa, seu projeto, sua equipe e poderei usar as "melhores práticas" como coisas que o ajudarão. Eles são os conselhos gerais "não faça mal".

Você claramente se desviou deste plano. Felizmente, você reconhece isso. Bom trabalho! Eles dizem que o conhecimento é metade da batalha; Nesse caso, a conscientização é bem mais da metade! Agora é necessária uma solução. A partir da sua descrição, fica claro que o ambiente de negócios em que você está evoluiu para um ponto em que os conselhos chatos de "fazer a revisão do código, é uma boa prática" não serão suficientes. Para isso, recomendo uma regra chave que eu uso quando se trata de práticas recomendadas de software:

Nenhuma prática recomendada de desenvolvimento de software supera uma necessidade comercial.

Francamente, eles estão pagando seu salário e a sobrevivência da empresa é tipicamente muito mais importante que a qualidade do software. Não gostamos de admitir, mas um software perfeitamente escrito é inútil se estiver preso no corpo de uma empresa que está morrendo de seus esforços para sustentar esse software perfeitamente escrito.

Onde você vai? Siga a trilha de força. Você apontou que, por algum motivo não declarado, não é razoável passar por uma revisão de código para alguma tarefa. Na minha experiência, essa razão é sempre temporal. Sempre é "tempo insuficiente" ou "dinheiro insuficiente para manter os salários fluindo enquanto você passa o tempo". Isso é negócio; está bem. Se fosse fácil, todo mundo faria. Siga a trilha de força para cima e encontre o gerenciamento que está em uma posição para ajudá-lo a entender por que uma revisão de código não é uma opção. A linguagem é difícil, e muitas vezes um decreto sai da gerência superior e fica distorcido. A solução para o seu problema pode estar oculta nessa distorção.

A resposta para isso é, necessariamente, um cenário de caso específico. É como tentar prever se um sorteio será cara ou coroa. As melhores práticas dizem que você deve girar 100 vezes e a expectativa será de aproximadamente 50 caras e 50 caudas, mas você não tem tempo para girar uma vez. É aqui que os detalhes da sua situação são importantes. Você sabia que uma moeda normalmente cai na mesma orientação em que foi lançada cerca de 51% das vezes? Você teve tempo para observar para que lado a moeda estava antes de jogar? Isso pode fazer a diferença.

Uma solução geral que pode estar disponível para você é tentar encontrar uma maneira de extrair o processo de revisão de código e torná-lo um esforço de custo muito baixo. Muito do custo de um processo de revisão de código é que todo mundo é 100% dedicado à revisão de código enquanto você o faz. Esse deve ser o caso, porque, uma vez concluída a revisão do código, o código é abençoado. Talvez você possa colocar o código em uma ramificação diferente e fazer a revisão do código paralelamente ao desenvolvimento no tronco principal. Ou talvez você possa configurá-lo para que o software faça o teste para você. Talvez você esteja em um ambiente de negócios em que seus clientes possam executar o código "novo" em paralelo com o antigo e fazer com que eles comparem os resultados. Isso transforma os clientes em vários dispositivos de criação de casos de uso.

A chave para todos esses "talvez" em execução é que você deve se esforçar para tornar seu código facilmente dividido em pedaços. Você pode "provar" partes do código sem depender de uma revisão formal do código, usando-as em projetos menos críticos. É mais fácil fazer isso se as alterações ocorrerem em partes menores, mesmo que a soma total delas seja muito grande para a revisão por pares.

Em geral, procure soluções específicas para o seu projeto, sua empresa, sua equipe. A resposta de propósito geral foi "melhores práticas". Você não os está usando, portanto, deve procurar soluções mais personalizadas para esse problema, desta vez. Isso é negócio. Se tudo acontecesse como esperávamos o tempo todo, as IPOs seriam muito mais fáceis de atribuir valores, não?

Se a substituição de uma revisão de código for uma luta, lembre-se de que nunca houve um único trecho de código que comprovadamente funcionasse em uma revisão de código. * Tudo o que uma revisão de código faz é dar confiança no código e uma oportunidade de fazer correções antes que se tornem um problema. Esses dois produtos valiosos de uma revisão de código podem ser adquiridos por outros meios. A revisão de código apenas tem um valor reconhecido por ser particularmente boa nisso.

* Bem, quase: o microkernel L4 recebeu uma revisão de código há um tempo atrás por um sistema automatizado de prova que prova que seu código, se compilado por um compilador C ++ em conformidade, fará exatamente o que a documentação diz.

Como @EricLippert aponta em sua excelente resposta, esse tipo de mudança precisa de mais atenção, não menos . Se você perceber que uma mudança na qual você está trabalhando se tornará uma mudança, existem algumas estratégias que podem ajudar:

• Comprometa-se com o controle de versão com freqüência. A revisão pode progredir em uma base de confirmação por confirmação e pode ser mais compreensível quando você tiver confirmações menores.
• Certifique-se de comentar os motivos de cada alteração o mais claramente possível.
• Se possível, use a programação em pares para esse tipo de alteração. Ter três olhares sobre o problema em vez de 2 pode ajudar a evitar problemas que normalmente podem ser esquecidos, e ter um par enquanto você trabalha pode ajudar a melhorar quaisquer comentários sobre o código que você achou óbvio, mas que se mostrou menos óbvio do que você acreditava, o que, por sua vez, ajudará o revisor mais tarde. A ajuda para (a) reduzir erros durante o desenvolvimento e (b) melhorar a documentação pode significar que menos horas de trabalho são gastas nisso, apesar de haver mais pessoas envolvidas.

Mais respostas estão abordando como você chegou a esse ponto. Muitos deles dão algumas sugestões para remediar a situação, mas eu gostaria de dar a minha resposta para dar a resposta curta.

O que fazer quando as revisões de código são "muito difíceis"?

1. Volte para o ramo principal do código de linha
2. Escreva testes para a funcionalidade que você refatorou (por exemplo, testes funcionais)
3. Faça os testes passarem
4. Mesclar os testes no código "difícil de testar"
5. Os testes ainda passam?

sim

Vocês desenvolvedores foram ótimos! Gatos de volta para todos!

(ou para aqueles que não cresceram assistindo " Os Simpsons " na televisão dos EUA: se os testes estiverem passando, pule a tentativa de observar as diferenças e peça ao desenvolvedor que o conduza em um tour pelas mudanças)

Não

Continue refatorando e adicionando cobertura de teste até que os testes sejam aprovados.

Como uma multiplicação, a revisão do código fornece resultado zero quando aplicada a zero. Não aumenta o valor nesse caso, enquanto na maioria dos outros casos aumentaria.

O código com o qual você precisa trabalhar é muito mal projetado para se beneficiar do processo de revisão de código durante o desenvolvimento. Use o processo de revisão de código para refatorá-lo ou desenvolvê-lo novamente.

Também pode ser que o código ainda seja suportável, mas a tarefa não seja boa. É muito amplo e deveria ter sido feito em incrementos menores.