Código temporário deve ser colocado sob controle de versão e como?

Aqui estão alguns exemplos de código local / temporário. É necessário para trabalhar com a base de código, mas seria prejudicial fazer parte dela:

1. Arquivos de projeto. Os caminhos podem precisar ser editados para refletir o layout no PC atual.
2. Makefiles. Por exemplo, a otimização pode precisar ser desativada durante a depuração, mas não para o servidor de IC.
3. Hacks feios e sujos. Por exemplo, return 7no meio de uma função, para testar algo, dependendo da função, e com suspeita de quebra no valor de 7. Ou 7 é o código do botão ainda não implementado que estou implementando e preciso testar durante todo a vida do meu ramo.

Eu tentei manter aqueles em um commit do git que eu sempre refiz para o topo antes de ir para o repo e depois empurrar HEAD~. Isso é bastante inconveniente e não funciona com o svn. O esconderijo me assusta ainda mais - "lembrei de aparecer depois de empurrar?".

Manter o código fora do controle de versão gera ruído desagradável toda vez que um commit está sendo montado, além de poder ser introduzido acidentalmente em um commit na sexta-feira à noite.

Qual seria uma solução sensata para esse código descartável?

Todo o código é temporário. Quando estou fazendo alterações, introduzirei espaços reservados ocasionalmente - o ícone que eu desenhei aguardando o real do designer, a função que conheço chamará a biblioteca que meu colega está escrevendo e ainda não terminou (ou iniciou), o registro extra que será removido ou tornado condicional, os bugs que corrigirei depois que eles forem notados pela equipe de teste, etc.

Portanto, verifique tudo. Use um ramo de recursos para todo o seu desenvolvimento, para mesclar a versão final ao tronco e ninguém precisará saber quais hacks, bodges e correções foram feitas durante o seu ciclo de desenvolvimento, eles só precisarão veja a versão final. Mas se você se comprometer com o seu ramo regularmente, poderá ver as coisas que valiam a pena manter se um dia desse espetacularmente errado ou continuasse codificando depois de um almoço no pub.

O controle de versão não é um repositório de artefatos ou um sistema de armazenamento de documentos. É sobre manter a história das mudanças. Cole tudo o que você gosta, porque um dia você pode querer ver o que era, e esses são os dias em que você percebe o que realmente é o seu SCM.

PS. Arquivos verdadeiramente temporários (por exemplo, .obj ou artefatos de construção) não têm lugar no seu SCM. São coisas que não têm valor para ninguém. Você pode dizer o que são - se você excluí-los, não se importa, ou até perceber que eles se foram.

Arquivos de projeto. Os caminhos podem precisar ser editados para refletir o layout no PC atual.

Para arquivos de projeto, a melhor estratégia é quando você pode gerar o arquivo de projeto por meio de um script. Adicione o arquivo de projeto real aos seus ignorantes e simplesmente gere novamente o arquivo de projeto, conforme necessário. Por exemplo, em projetos Java, uso gradle, que pode gerar um projeto eclipse.

Makefiles. Por exemplo, a otimização pode precisar ser desativada durante a depuração, mas não para o servidor de IC.

Você deve poder alternar entre o modo de otimização e depuração sem modificar o Makefile. Em vez disso, use um sinalizador de linha de comando, variável de ambiente ou arquivo separado que não esteja no seu repositório para controlar isso.

Hacks feios e sujos. Por exemplo, retorne 7 no meio de uma função, para testar algo, dependendo da função, e com suspeita de quebra no valor de 7. Ou 7 é o código do botão ainda não implementado que estou implementando e preciso teste ao longo da vida do meu ramo.

Você não pode escrever um teste que induza o caso de falha suspeita?

Na maioria dos casos, você deve ajustar seu fluxo de trabalho para não fazer essas alterações nos arquivos do seu repositório. Os arquivos que são alterados localmente devem ser adicionados ao mecanismo de ignição do seu projeto e não devem estar no repositório. Em alguns casos, você ainda fará alterações temporárias que não deseja colocar no repositório. Para aqueles, adicione uma sequência especial como: XXX e adicione um gancho de pré-confirmação que rejeite as confirmações que ainda a possuem.

O controle de versão deve conter código e configuração necessários para criar o aplicativo.

Isso significa que:

• Coisas temporárias que foram introduzidas por um curto período de tempo (o tempo necessário para identificar a localização de um bug ou para experimentar um recurso de um idioma, por exemplo) não devem estar em um controle de versão: mantenha-o até que você precise e remova-o simplesmente ao fazer o commit .

• Arquivos locais adequados a uma máquina específica podem ser mantidos em uma ramificação.

  Eu evitaria mantê-los apenas localmente, pois é muito doloroso refazer tudo isso quando seu laptop é roubado ou um vírus obriga a reinstalar o sistema operacional (e, a propósito, você descobre que seu último backup foi feito há dois anos) .

  Por outro lado, tenha cuidado com a estrutura do arquivo: a configuração local está OK, até que se torne avassaladora, e obriga a fazer uma única alteração em todos os arquivos de cada um dos 42 desenvolvedores participantes do projeto.

  Preste atenção na oportunidade de remover as particularidades entre as máquinas. Isso pode significar:

  • Dando acesso a um servidor SQL dev para substituir instâncias locais em máquinas de desenvolvedores,

  • Usando serviços de distribuição de pacotes como Pypi ou npm para pacotes públicos e suas contrapartes particulares para pacotes internos,

  • Peça aos membros da equipe para instalar as mesmas versões de software,

  • Torne as atualizações de software o mais transparente possível,

  • Ou torne possível implantar o sistema operacional e o software necessário em uma máquina com um clique (mais o tempo para cada desenvolvedor instalar seu Vim vs. Emacs, Chrome vs. Firefox etc.)

Tão:

Arquivos de projeto. Os caminhos podem precisar ser editados para refletir o layout no PC atual.

Por que não usar o mesmo layout em todos os PCs? Os caminhos dentro do projeto devem ser relativos ao arquivo do projeto, o que significa que não importa onde o projeto está localizado. Versões de software e bibliotecas são melhores para evitar erros crípticos que aparecem apenas em algumas máquinas e são impossíveis de reproduzir para outros membros da equipe.

Exemplo:

Em um projeto criado com o Visual Studio, você pode encontrar:

• Os próprios arquivos. Os caminhos são relativos, não importa se, na minha máquina, o projeto está localizado H:\Development\Hello World Project\enquanto outros membros da equipe fazem check-out no projeto C:\Work\HelloWorld\.

• As dependências, ou seja, bibliotecas de terceiros e internas. Ambos os tipos devem ser tratados pelo NuGet, o que torna obsoletas todas as discussões relacionadas a conflitos. Se você não possui a mesma versão da biblioteca que eu tenho, peça ao NuGet para atualizar as dependências. Tão simples como isso (quando funciona bem, o que nem sempre é o caso).

  Observe que é crucial manter as bibliotecas internas também em um NuGet particular. Ter um monte de bibliotecas armazenadas em uma pasta compartilhada ou enviadas por e-mail para uma equipe leva a servidores de CI anárquicos e depressivos.

• As configurações. É crucial que a equipe compartilhe as mesmas configurações. Se metade da equipe decide tratar os avisos como erros e metade da equipe mantém os avisos como estão, os membros da primeira parte da equipe gastam seu tempo removendo os avisos gerados pelos desenvolvedores da segunda parte da equipe.

• As configurações relacionadas aos utilitários. Isso é complicado, porque alguns membros da equipe podem ter instalado alguns utilitários, enquanto outros não.

  É altamente recomendável ter o mesmo conjunto de ferramentas instalado. Se alguns programadores quiserem usar o StyleCop, mas outros não, a equipe não fará o trabalho. Se alguns usam contratos do Código, mas outros não, eles terão os mesmos problemas.

Makefiles. Por exemplo, a otimização pode precisar ser desativada durante a depuração, mas não para o servidor de IC.

Mantenha vários makefiles no controle de versão. Não é incomum criar também uma versão de depuração no servidor de CI e enviá-la a um cliente que tenha um bug complicado.

Hacks feios e sujos. Por exemplo, retorne 7 no meio de uma função, para testar algo, dependendo da função, e suspeita de quebra no valor de 7.

Eu evitaria esse código em primeiro lugar. Para testar algo, use testes de unidade. Se realmente levar alguns segundos para trocar algum código com o objetivo de depurar , faça-o, mas você removerá esse código em alguns minutos, portanto, não há necessidade de confirmá-lo.

Ao descrevê-lo, você deve escrever um teste. Por exemplo, se você quiser ter certeza de que:

class TemperatureConverter
{
    public int CelsiusToFahrenheit(int temperature)
    {
        ...
    }
}

lança uma exceção quando temperatureé inferior a AbsoluteZeroconstante, você não deve jogar com o próprio código. Em vez disso, crie um teste de unidade que:

• documente seu código,
• aumentar a confiabilidade do seu código,
• garantir que os mantenedores possam confiar no teste de regressão ao modificar o método acima,
• servir a outros desenvolvedores de sua equipe que talvez precisem fazer o mesmo teste.

Nós usamos @@ comentários no código para indicar que algo não está totalmente pronto, para fins de teste etc.

Dessa forma, podemos comprometer, os colegas não precisam esperar muito para sincronizar e podem ver onde ainda há trabalho em andamento (por exemplo, entender por que uma parte ainda não está funcionando totalmente).

Fazemos uma pesquisa global para @@evitar sobras antes de entrar nos estágios finais dos testes beta etc.

Usando essa disciplina, não vejo razão para não apenas cometer. Dessa forma, não temos ramificações separadas e apenas um 'protocolo' a seguir.

Como um benefício extra, essas tarefas (geralmente pequenas) estão sempre no código. O desenvolvedor que trabalha neles pode examiná-los rapidamente, e não há necessidade de manter listas separadas.
Você sabe como é o desenvolvimento: você está trabalhando em um só lugar, mas está constantemente usando sua mente como uma pilha (' Eu devo mudar isso lá quando terminar aqui '). Apenas anotando uma rápida@@ observação evita o estouro da pilha.

Eu até uso @@namepara indicar questões que preciso discutir com 'nome'.

2 soluções HAMSTER:

• Você pode usar um gancho de pré-confirmação para verificar seu código em busca de palavras-chave incomuns, como HAMSTER. Apenas não permita que as pessoas cometam códigos HAMSTERed e os utilizem sempre que você fizer hacks sujos.

• Outra opção, por exemplo, em C é usar #ifdef HAMSTER, o código será executado apenas na sua máquina onde você tem um sinalizador de compilador HAMSTER.

Colocamos tudo sob controle de origem necessário para criar e testar os binários atuais e entender por que as coisas foram projetadas / implementadas / testadas da maneira que são.

Isso vale para picos http://www.extremeprogramming.org/rules/spike.html , como os que você descreveu; nós apenas os hospedamos em uma subárvore diferente.

Aqui estão algumas soluções que ocasionalmente me uso sob várias circunstâncias, e que você pode considerar úteis quando aplicadas a seus próprios fluxos de trabalho:

1. Galhos leves que podem ser esmagados.

   Git é ótimo nisso. Invada uma ramificação, faça muitas confirmações e depois refaça ou esmague seu histórico para editar o barulho.

2. Use uma fila de correções em cima do seu SCM.

   Costumo encontrar-me usando o StGit para colocar patches no topo da minha ramificação atual. Quando terminar a ramificação, posso retirá-los da pilha antes de mesclar, esmagar ou rebasear, ou mesclá-los na base de código principal, se quiser mantê-los por perto.

3. Use o RCS como um SCM "fora da banda" para pequenas experiências.

   Às vezes, você só deseja marcar um arquivo em andamento de maneira descartável, sem precisar limpar o histórico posteriormente. Normalmente, uso o RCS para isso dentro do Git ou SVN. Eu digo ao Git para ignorar os artefatos do RCS, verificar meu trabalho em andamento no RCS e, quando gosto dos resultados, apenas lancei os *,varquivos ou o diretório inteiro do RCS. Só não corra git clean -fdxou similar até que você comprometa seu trabalho com o seu SCM "real" ou se arrependerá.

4. Stashes nomeados.

   Outro Git-ism, mas útil: git stash save --include-untracked <some-cool-title>pode ser útil em uma pitada. Você pode salvar, exibir e aplicar o trabalho em andamento dessa maneira e visualizar seus vários pontos de verificação por meio de git stash listou git reflog --all. Outros SCMs podem ter recursos semelhantes, mas sua milhagem pode variar muito com essa.

Parte desse código temporário é realmente apenas uma manifestação de uma metodologia inadequada de compilação / teste / desenvolvimento e, esperançosamente, sua existência motivará melhorias futuras.

No git, pelo menos, você deve estar livre para mexer com qualquer número de ramificações de recursos até que estejam prontos para serem mesclados no mestre / tronco.

O controle de versão deve ajudá- lo e, na maioria das vezes, aprecio as idéias do modo como os erros (ou talvez apenas decisões menos que intuitivas) foram cometidos no passado e tomo decisões mais informadas para o presente.

Acredito que alguns sistemas lançem avisos ao ver o TODO em um comentário, então

// TODO: remove this hack.

pode ser tudo o que é necessário se você puder encontrar uma opção relevante em alguma parte do seu ambiente de desenvolvimento ou apenas colocar algum tipo de comando grep em seu arquivo de compilação. Também pode ser possível organizar para que // HACKqualquer sequência arbitrária seja captada.

Isso é mais simples do que organizar seu código de uma maneira específica e esperar que as pessoas se lembrem de não usá-lo. Também torna mais seguro seguir os conselhos de @gbjbaanb (se você puder garantir que todos estejam vendo os avisos!).

Cole tudo o que você gosta, porque um dia você pode querer ver o que era, e esses são os dias em que você percebe o que realmente é o seu SCM.

Nunca é prejudicial colocar código no controle de origem.

Cada um dos itens mencionados deve estar no controle de origem.