Quando fazer revisões de código ao fazer integração contínua?

Estamos tentando mudar para um ambiente de integração contínua, mas não temos certeza de quando fazer revisões de código. Pelo que li sobre integração contínua, deveríamos tentar fazer o check-in do código tantas vezes quanto várias vezes ao dia. Suponho que isso signifique recursos que ainda não estão completos.

Portanto, a questão é: quando fazemos as revisões de código?

Não podemos fazer isso antes de fazer o check-in do código, porque isso atrasaria o processo em que não poderíamos fazer check-ins diários, muito menos vários check-ins por dia.

Além disso, se o código que estamos fazendo o check-in apenas compila, mas não está completo, fazer uma revisão de código não faz sentido, pois a maioria das revisões de código é melhor quando o recurso é finalizado. Isso significa que devemos fazer revisões de código quando um recurso for concluído, mas esse código não revisado entrará no repositório?

Na IMO, você deve revisar o código antes que ele seja publicado na linha principal, para que a linha principal tenha apenas o código da mais alta qualidade.

OTOH, pode-se argumentar que 'por que se preocupar em revisar se a automação de teste de IC não foi executada?', Então talvez o melhor seja oferecer a cada desenvolvedor uma ramificação privada que o servidor de CI criará e testará para eles . Dessa forma, eles primeiro confirmam e enviam push para lá, depois que passam, passam pela revisão e depois passam para a linha principal (onde haverá outra execução no servidor de IC).

Você definitivamente deve revisar o código não completo de recurso para garantir que andaimes para recursos futuros estejam em vigor ou, pelo menos, que não haja nada que impeça a implementação desses recursos futuros.

Além disso, observe que as revisões de código não precisam ser lentas ou síncronas - uma ferramenta como o gerrit ou o reviewboard ou algo semelhante pode torná-las assíncronas e razoavelmente indolor.

(Divulgação completa: eu trabalhava para a SmartBear, criadora do Code Collaborator, uma ferramenta de revisão de código)

Configurar programação em pares?

Todo o código é revisado à medida que é digitado sem estender o processo ou introduzir outra etapa.

Aqui está o extrato do autor de entrega contínua:

Jez Humble escreve como:

Atualmente, estou escrevendo um post sobre este tópico. A resposta curta é esta:

• A melhor maneira de revisar o código é através da programação em pares
• É uma péssima idéia integrar a linha principal - criando uma ramificação separada, por exemplo - em um processo formal de revisão. Isso inibe a integração contínua (a melhor maneira de reduzir o risco de alterações ruins, que é o que você realmente deseja alcançar).
• Eu acho que o Gerrit é uma ferramenta interessante, mas deve ser usada após o check-in (é assim que foi projetada, de fato). Parte do trabalho dos desenvolvedores seniores é revisar todos os check-ins. Eles poderiam, por exemplo, assinar um feed.

Para resumir: a revisão do código é boa. Tão bom, deveríamos fazê-lo continuamente, através da programação em pares e revisão de commits. Se um desenvolvedor sênior encontrar um comprometimento incorreto, deverá emparelhar com a pessoa que o comprometeu para ajudá-lo a resolver o problema.

A junção da mesclagem à linha principal em uma revisão formal é ruim e a criação de ramificações para isso é muito ruim, pelo mesmo motivo que as ramificações dos recursos são ruins.

Obrigado,

Jez.

o link original é: https://groups.google.com/forum/#!msg/continuousdelivery/LIJ1nva9Oas/y3sAaMtibGAJ

Não sei se é a melhor maneira de fazê-lo ... mas vou explicar como o fazemos. Um ou mais desenvolvedores trabalham em um determinado ramo e confirmam seu código o mais rápido possível para evitar desperdiçar tempo na mesclagem que não teria acontecido de outra forma. Somente quando o código está pronto é confirmado na cabeça. Agora isso é para o commit e o ramo / cabeça.

Quanto à revisão de código, usamos o Sonar como nossa ferramenta de integração contínua (e a Maven / Jenkins para interagir com o Sonar) para fornecer novos resultados de testes, cobertura de código e revisão automática de código todas as manhãs (as compilações são feitas todas as noites) para que possamos os desenvolvedores podem passar no máximo uma hora todas as manhãs para corrigir seus problemas / cheiros de código. Cada desenvolvedor assume a responsabilidade (também com orgulho!) Pelo recurso que está escrevendo. Agora, essa é a revisão automática de código, o que é ótimo para encontrar possíveis problemas técnicos / arquiteturais, mas o mais importante é testar se esses novos recursos implementados estão fazendo o que a empresa deseja que eles façam corretamente.

E para isso, há duas coisas: testes de integração e revisão de código por pares. Os testes de integração ajudam a ter certeza de que o novo código não quebra o código existente. Quanto à revisão de código por pares, estamos fazendo isso nas sextas-feiras à tarde, o que é um pouco mais descontraído para fazer isso :-) Cada desenvolvedor é atribuído a um ramo em que não trabalha, leva algum tempo para ler os requisitos do novo recurso primeiro e depois verifica o que foi feito. Seu trabalho mais importante é garantir que o novo código funcione conforme o esperado, de acordo com os requisitos, não quebre nossas próprias "regras" (use esse objeto para isso, e não aquele), seja fácil de ler e permita extensão fácil.

Portanto, temos duas revisões de código, uma automática e uma "humana" e tentamos evitar a inserção de código não revisado no ramo HEAD. Agora ... acontece às vezes por várias razões, estamos longe de ser perfeitos, mas tentamos manter um equilíbrio justo entre qualidade e custo (tempo!)

O @pjz também fornece uma boa resposta e ele menciona ferramentas de revisão de código. Eu nunca usei nenhum, então não posso dizer nada sobre isso ... embora tenha sido tentado no passado a trabalhar com o Crucible, já que já estamos usando o JIRA .

Eu acho que o principal conceito que ajudará é o de uma área "Staging".

Sim, você não deseja fazer o check-in do código que está quebrado. Mas você também deve verificar o código com frequência. Isso implica perfeição? ;) Não. Basta usar várias áreas e um DVCS como git.
Dessa forma, você faz alterações (localmente) e as confirma com frequência à medida que testa e desenvolve até que os testes sejam aprovados. Em seguida, você passa para uma área de teste para revisão de código.

Você deve passar do teste temporário para outros esforços de controle de qualidade, como testes de navegador e testes de usuário. Finalmente, você pode ir para uma área de teste de volume e, finalmente, produção.

Também existem fluxos de trabalho, como todos que trabalham na ramificação principal ou usam ramificações individuais para todos os esforços.

A integração contínua em si também pode acontecer em vários níveis. Pode ser local para uma máquina de desenvolvedores 'até que os testes passem' e também pode estar nas áreas de teste e qa para quando o código for enviado a eles.

Desacoplar a revisão de código e a integração contínua!

Por que você os combinou?

Usamos o fluxo git para nossos repositórios e fazemos nossas revisões de código quando se trata de mesclar-se ao ramo de desenvolvimento.

Qualquer coisa em desenvolvimento é completa, implementável e revisada por código.

Também temos o CI configurado para nossos ramos de desenvolvimento e master.

Eu realmente acho que você precisaria de um DVCS (por exemplo, mercurial, git) para fazer isso naturalmente. Com um CVCS, você precisaria de um ramo e esperaria que, seja qual for o deus que você tenha, não haverá inferno em fusão.

Se você usa um DVCS, pode hierarquizar o processo de integração para que o código já o revise antes de chegar ao servidor de IC. Se você não possui um DVCS, bem, o código chegará ao servidor de IC antes de ser revisado, a menos que os revisores de código revisem o código na máquina de cada desenvolvedor antes de enviarem suas alterações.

Uma primeira maneira de fazer isso, especialmente se você não possui um software de gerenciamento de repositório que possa ajudar a publicar repositórios pessoais (por exemplo, bitbucket, github, rhodecode), é ter funções de integração hierárquica. Nos diagramas a seguir, você pode solicitar que os tenentes revisem o trabalho dos desenvolvedores e que o ditador seja o principal integrador que revise como os tenentes mesclaram o trabalho.

Outra maneira de fazer isso, se você tiver um software de gerenciamento de repositório, é usar um fluxo de trabalho como o seguinte:

O software de gerenciamento de repositório normalmente ajuda a emitir notificações quando há atividade nos repositórios (por exemplo, email, rss), além de permitir solicitações de recebimento . A revisão de código pode ocorrer organicamente durante solicitações pull, pois as solicitações pull normalmente fazem as pessoas se envolverem em conversas para integrar o código. Tome esta solicitação de recebimento público como exemplo. O gerenciador de integração realmente não pode permitir que o código chegue ao repositório abençoado (também conhecido como "repositório central") se o código precisar ser corrigido.

O mais importante é que, com um DVCS, você ainda pode suportar um fluxo de trabalho centralizado, não precisa ter outro fluxo de trabalho sofisticado, se não quiser ... mas com um DVCS, é possível separar um repositório de desenvolvimento central do IC servidor e conceda a alguém a autoridade para enviar as alterações do repositório dev para o repositório CI quando uma sessão de revisão de código for concluída .

PS: Crédito pelas imagens, acesse git-scm.com

Por que não ter mais de um repositório? Um para o trabalho "diário", dirigindo um servidor de integração contínuo, executando todos os testes de unidade e testes de integração para obter o ciclo de feedback apertado, e outro para o trabalho "estável", em que as confirmações são menos frequentes, mas precisam ser revisadas.

Dependendo do caminho que as mudanças tomam à medida que avançam pelo sistema, isso pode acabar sendo uma solução um pouco complexa e pode funcionar melhor ao usar ferramentas como Git ou Mercurial Queues (ressalva: eu não usei nada com raiva) mas muitas organizações fazem algo semelhante.

Isso significa que devemos fazer revisões de código quando um recurso for concluído, mas esse código não revisado entrará no repositório?

Bem acima, é a maneira como eu vi isso em pelo menos três projetos que usavam intensamente a integração contínua e, pela minha lembrança, funcionou como um encanto. Essa prática é conhecida como revisão de código pós-confirmação - pesquise esse termo na web se você estiver interessado em detalhes.

• ^{Por outro lado, o único caso em que estive no projeto tentando "casar" as revisões de código pré-confirmadas com o CI acabou sendo bastante doloroso. Bem, quando as coisas correram 100% sem problemas, tudo bem - mas mesmo interrupções pouco frequentes (como quando os revisores principal e de backup estavam indisponíveis por algumas horas) causaram um estresse notável. Também notei que o moral da equipe sofria um pouco - havia conflitos demais.}

Primeiro, devemos esclarecer o conceito de "integração contínua". Nos métodos tradicionais de desenvolvimento, a integração contínua significa que podemos integrar e construir nosso repositório de código-fonte todos os dias, o que evitará as armadilhas do "inferno da integração". As revisões de código estão sempre entre o período de codificação e teste de unidade. Devemos garantir que o código que se mescla à ramificação possa ser compilado sem erros. Raramente existe a situação de partes do recurso serem mescladas à ramificação porque é difícil lidar com a coerência da interface e compilar erros.

A integração contínua é popular no processo de programação extrema. O desenvolvimento orientado a testes adiciona a programação Pair, que é parte real de um processo de revisão de código, facilitando a implementação contínua da integração. A Extreme Programming em si é um processo contínuo de revisão e integração de código. As revisões de código existem em todos os lugares.

Em algumas comunidades de código aberto, as revisões de código são executadas imediatamente antes da fusão do código com a ramificação. Sempre são as pessoas mais experientes nessa equipe que fazem as revisões de código e decidem se o código pode ser mesclado à ramificação principal. Dessa forma, o período de integração contínua é um pouco mais longo, mas a qualidade do código é um pouco melhor.

Retorne à pergunta. Não existe uma resposta padrão para quando fazer revisões de código, e isso depende do seu processo de desenvolvimento original e da implementação real de sua integração contínua.