Melhores hábitos de controle de versão para desenvolvedor solo?

Sou um desenvolvedor único no meu trabalho e, embora compreenda os benefícios do VCS; Acho difícil seguir boas práticas. No momento, estou usando o git para desenvolver principalmente aplicativos da Web (que nunca serão de código aberto devido ao meu trabalho).

Meu fluxo de trabalho atual é fazer muitas alterações no site de desenvolvimento, testar, revisar, testar, ser feliz e confirmar alterações e, em seguida, enviar a confirmação para o site ativo (por isso, se estou trabalhando em uma grande alteração nova, talvez eu apenas confirmar uma vez por semana, mas meu IDE tem um bom histórico de desfazer para coisas não confirmadas).

Basicamente, só uso o git ao alternar entre máquinas (por exemplo, trabalhar com computador de desenvolvimento em computador doméstico ou em máquina viva), mas durante o dia não vejo realmente o benefício. Isso me leva a ter longas listas de alterações (e tenho problemas para encontrar boas mensagens para cada confirmação; e sempre que estou com pressa - costumo deixar mensagens de baixa qualidade como 'alterações diversas no administrador e nos modelos').

Com que frequência devo estar cometendo? Cada alteração de uma linha deve ser confirmada? Devo confirmar antes de qualquer teste (por exemplo, pelo menos para erros de sintaxe / compilação e, em seguida, preciso desfazê-lo totalmente; pois a ideia não funcionou ou a mensagem é uma mentira)?

Devo me certificar de me comprometer todas as manhãs / tardes antes de parar de trabalhar para o jantar enquanto ainda está fresco? O que estou perdendo por ter maus hábitos de VCS?

Está faltando muito.

Eu sou solo também, de certa forma. Eu me comprometo toda vez que faço uma alteração significativa ou antes de iniciar uma alteração significativa para poder voltar se eu estragar tudo, e de vez em quando, mesmo que não esteja fazendo nada grande. Não todos os dias realmente, mas perto. Às vezes, algumas vezes ao dia.

O que recebo é que posso voltar quando quiser. O que é muito. Além disso, ter as filiais solicitadas ajuda.

Eu acho que isso me dá muita ordem.

Estou usando o svn e estou ficando cansado disso. Mas não pode gastar mais tempo aprendendo mais nada.

Boa sorte.

Você deve cometer frequentemente. Você certamente deve se comprometer depois de atingir algum marco lógico. Se isso levar mais de um dia, você deve pelo menos confirmar no final do dia de trabalho, ou melhor ainda, dividir seu trabalho em pedaços menores.

Existem muitas razões para fazer isso. Por exemplo, e se o seu computador travar? É muito melhor perder apenas um dia de trabalho do que uma semana ou um mês. Outro motivo é que confirmações frequentes facilitam o isolamento de um bug. Você pode fazer uma pesquisa binária e descobrir qual pequena alteração causou o erro.

Outra coisa: antes de se comprometer, você deve fazer uma comparação e analisar todas as alterações que você fez. Isso permite que você verifique se todas as alterações fazem sentido e se você não esqueceu nada. Isso também ajuda a criar uma mensagem de confirmação melhor. E, é claro, esse é outro motivo para se comprometer com frequência: é muito mais fácil passar por um dia de alterações do que um mês.

Para tirar o máximo proveito do CVS, você deve trabalhar em um recurso / correção de bug por vez e confirmar quando esse recurso / correção de bug estiver concluído. Ao fazer isso, você ganha:

• enviar mensagens será mais fácil de criar e fará mais sentido;
• rastreamento mais fácil de bugs futuros, de volta às mudanças que os introduziram;
• mais fácil reverter para um estado anterior (mesmo que isso signifique perder um recurso com falha, mas manter as correções que ocorreram posteriormente).

Além disso, desde que você alterna entre PCs, você deve ter pelo menos duas ramificações:

• um ramo "Pronto para uso" que sempre funciona (exceto os erros nos quais você está trabalhando no ramo de desenvolvimento, é claro)
• um ramo de desenvolvimento que pode estar em um estado irregular de tempos em tempos (como durante sua viagem de volta para casa do trabalho;).

Cada alteração de uma linha deve ser confirmada?

Se é isso que corrige um bug, com certeza.

O que estou perdendo por ter maus hábitos de VCS?

Eu trabalhei com um cara que tinha "maus hábitos no VCS". Ele adorava trabalhar sozinho e era o responsável por uma linha de produtos que gerava algo como US $ 1.000.000 / ano. Ele só fazia confirmações quando o chefe o incomodava. Então, um dia, seu disco rígido caiu. Depois de configurar um substituto para ele, descobrimos que seu último check-in foi realizado seis meses antes. Como o VCS era Source Safe, você pode adivinhar o que mais deu errado - o último commit foi corrompido. Tivemos que voltar mais de um ano para obter uma versão não corrompida de sua linha de produtos. Ele não foi demitido, mesmo que devesse ter sido.

Outra anedota envolve-me. Eu costumava armazenar código para projetos de pesquisa e hobby em discos rígidos removíveis. Um dia, meu apartamento foi arrombado. O laptop (que estava quebrado) e todos os discos rígidos removíveis foram roubados. Todo DVD (com exceção de Red Dawn) foi roubado. Nenhum dos computadores foi roubado. Se eu tivesse controle de fonte externo, não perderia 15 anos em projetos, especialmente porque alguns se baseavam em projetos acadêmicos - muitos dos profissionais deixaram a academia para ir para o setor privado, para que esses projetos desaparecessem em um buraco negro corporativo de IP, fazendo com que código perdido impossível de recuperar.

Com que frequência devo estar cometendo?

Divido-o em algumas métricas:

• Quanto trabalho você está disposto a perder se o computador morrer? ou é roubado?

• Se isso corrigir o Bug_1234, verifique o código com o comentário "corrige o Bug_1234".

• Se esse for um marco / entrega lógica, faça check-in com um comentário como "Bug_1234, form_xyz" (ou Task_1234, conforme apropriado).

• Sempre verifique o código na sexta-feira à noite antes de voltar para casa. Também faça um check-in (ou desfaça os check-out) de tudo antes de sair de férias.

• Sempre que a política da empresa exigir.

Não pense em termos de número de alterações de linhas. Pense em pedaços de funcionalidade. O VCS permite que você indique um cabeçalho em um local central para cada parte da funcionalidade, para que você possa ver facilmente o "o que aconteceu aqui" com, por exemplo, o git log.

Além disso, IDEs como o Eclipse permitem que você aponte para uma determinada linha e vá para o commit que trouxe a forma que você vê. Em outras palavras, você pode ir diretamente de uma linha de origem para o commit. Se o commit for pequeno e tiver uma boa mensagem, será muito mais útil que "toneladas de bugs corrigidos".

Eu diria que a maior coisa que você está perdendo ao agrupar as alterações é a capacidade de rastrear quando e onde os bugs foram introduzidos.

Na minha experiência, houve algumas vezes em que algum erro é percebido duas a três semanas após sua introdução, e é difícil peneirar os commits de uma semana após muito tempo. Nesses casos, era útil simplesmente pesquisar binariamente os commits para rastrear qual alteração individual causou o problema. Esses bugs eram principalmente erros de uso de memória no código C ++, portanto, pode não acontecer com tanta frequência para o seu projeto.

Outros benefícios entram em jogo quando se desenvolve em equipe - comentários simples de confirmação, mesclagens mais fáceis, relação de confirmações a correções de bugs, etc.

Eu acho que com o seu fluxo de trabalho que, se você começar a confirmar diariamente ou semi-diariamente, precisará usar tags ou indicadores para acompanhar qual versão do código está em uso no site ao vivo. Eu diria que é a coisa mais importante a ser acompanhada.

Também sou desenvolvedor solo, uso o SVN e adoro isso. Até escrevi uma ferramenta para converter a estrutura do meu banco de dados e os dados de teste nele em xml, para que eu possa incluí-lo no controle de origem.

Eu costumo confirmar sempre que concluo uma unidade de trabalho autônoma. Às vezes, se eu executar várias correções de linha única triviais e não relacionadas aqui e ali, eu as comprometo todas juntas, mas se ocorrer uma correção de linha única entre duas grandes unidades autônomas de trabalho não relacionadas, ela terá suas próprias confirmar, não há nada de errado nisso.

Além disso, eu sempre confirmo o código que é compilado e quase sempre o código que também passa em todos os testes básicos. Caso contrário, certifique-se de incluir "NÃO FUNCIONA" na mensagem de confirmação. O único caso em que isso acontece é quando fiz mudanças importantes que não quero perder, mesmo que elas ainda não funcionem, e, além disso, estou prestes a embarcar em uma grande aventura de refatoração que não tenho certeza se será bem sucedido. Então, eu uso o repositório como um backup do trabalho que fiz até agora antes de arriscar estragar tudo e ter que jogá-lo fora.

Isso significa que eu sempre confirmo quando meu código-fonte precisa ser confirmado; não faz absolutamente nenhum sentido ter regras de confirmação da manhã ou da noite. É o estado em que o código determina se é hora ou não de confirmar.

As mensagens que você coloca no repositório não importam muito. Se você absolutamente não consegue apresentar algo significativo, ainda é melhor confirmar com uma mensagem em branco do que não confirmar quando deveria.

Se você não consegue pensar em uma boa mensagem de confirmação, porque tudo o que você cria parece estúpido, lembre-se de que está tudo bem; Espera-se que as mensagens de confirmação declarem o óbvio; portanto, elas parecerão estúpidas quando você as escrever. Mas confie em mim, se você precisar examinar revisões antigas um mês depois, ficará agradecido pelas mensagens estúpidas, mesmo que sem mensagens.

Confirme cada vez que você fizer uma alteração "lógica". Por exemplo, se você estiver implementando um novo recurso, estará fazendo isso passo a passo. Cada uma dessas etapas geralmente depende uma da outra. Portanto, você pode apenas confirmar essas etapas separadamente e explicar na mensagem de confirmação por que cada etapa é necessária.

A mensagem de confirmação é realmente importante. Você deve evitar dizer o que está fazendo, dizer por que está fazendo. O código já documenta as alterações, mas em 6 meses você ficará feliz em saber por que as fez.

Isso também é útil se por acaso alguém aparecer e você não estiver mais sozinho. Mesmo para você, um histórico limpo facilita o uso de um git blamepara saber quando e por que a linha que apresenta um bug foi alterada.

Fazer pequenas confirmações em vez de grandes mudanças de bola também permite testar o estado intermediário. Você pode ocultar as alterações se precisar liberar algo com urgência. Se você introduzir um bug enquanto ele funcionava antes, poderá ocultar e verificar se são as alterações não confirmadas que introduzem o bug ou se isso ocorreu em uma confirmação mais antiga.

Você também pode liberar o poder git bissectdisso e informar o commit que esse bug desagradável. Se o commit tiver 2.000 linhas, ainda ajuda, mas não tanto ...

Outra coisa é que é o primeiro passo para a integração contínua (CI) e, em seguida, a implantação contínua (CD). O IC e seus testes podem ser acionados em uma nova confirmação, portanto, informando sempre que você pressiona suas alterações se elas quebrarem algo ou não. Dessa forma, você poderá saber se é seguro implantar ou não e ser notificado disso no momento em que o problema for apresentado, e não antes da sua liberação, quando estiver com pressa.

Sobre suas outras perguntas:

• não comprometa coisas que você nem compilou, a menos que esteja disposto a reescrever seu histórico para isso (usando git rebase --interactive).
• uma alteração de uma linha merece uma confirmação se tiver uma finalidade separada (corrige um bug ou não está relacionada às alterações não confirmadas no momento). Use git add --patchpara encenar aqueles.
• não há necessidade de se forçar a se comprometer antes do jantar, a menos que você tenha coisas importantes que não pode perder. Nesse caso, convém comprometer em um ramo separado seu trabalho em andamento.
• confirmar e enviar para um repositório remoto é um backup. Se você confirmar e enviar apenas uma vez por semana, na pior das hipóteses, poderá perder uma semana de trabalho.

Com que frequência devo estar cometendo?

Como desenvolvedor solo, geralmente me comprometo sempre que sinto que fiz uma mudança significativa, após os testes básicos e quando deixo um projeto no final da noite.

Cada alteração de uma linha deve ser confirmada?

Não, a menos que a alteração de uma linha altere significativamente um recurso ou bug.

Devo confirmar antes de qualquer teste (por exemplo, pelo menos para erros de sintaxe / compilação e, em seguida, preciso desfazê-lo totalmente; pois a ideia não funcionou ou a mensagem é uma mentira)?

Provavelmente não. Pelo menos para mim, faço a maior parte dos meus testes e codificação em uma 'cópia de trabalho' e efetuo o commit depois que estou satisfeito com minhas alterações. Em muitos IDEs, ele me mostra o que mudou antes que eu efetue o commit e me dê a oportunidade de anexar notas ao commit.

Devo me certificar de me comprometer todas as manhãs / tardes antes de parar de trabalhar para o jantar enquanto ainda está fresco? O que estou perdendo por ter maus hábitos de VCS?

Não estou muito familiarizado com o VCS ou com os maus hábitos que ele causa. Acho que compartilhei minha opinião sobre isso em resposta à primeira pergunta.

Em resposta à pergunta geral postulada, você parece estar usando commits principalmente como ramificações, o que é abordado em outra postagem de respondentes. Não sei ao certo qual IDE você está usando e que tem um bom histórico de desfazer, etc.

Sou um comunicador habitual e achei que combina comigo, mas é verdade que minhas mensagens de confirmação são quase sempre como,

Age:  9 mins [*] Working on implementing and testing PaintSystem.
Age: 17 mins [*] Working on implementing and testing PaintSystem.
Age: 37 mins [*] Working on implementing and testing PaintSystem.
Age: 52 mins [*] Working on implementing and testing PaintSystem.

Portanto, não posso dizer exatamente que fazer confirmações tão frequentes e habituais no meu ramo (mercurial) incentivou exatamente os logs de confirmação mais detalhados. Às vezes, eu até comprometo o código pela metade se, digamos, minha esposa me pede para sair para jantar; nesse momento, eu simplesmente copio e uso apressadamente a mensagem de confirmação "Trabalhando em" anterior.

Meus padrões de log de confirmação normalmente são como, "Working on [...] Working on [...] Working [...] Completed [...] Started working on [...] Working on [...] Completed [...] Started working on [...]"

Por outro lado, ele salvou minha bunda. Às vezes, encontro um caso delicado que não previ e testei, quando as confirmações frequentes me ajudam a descobrir exatamente onde introduzi o erro.

Portanto, eu não conheço os melhores hábitos e certamente não sou o único a ouvir os hábitos ideais de log de confirmação, mas certamente posso dizer que confirmar com mais frequência pode definitivamente ajudar quando você precisar executar uma regressão.

Cada alteração de uma linha deve ser confirmada?

Eu cometi alterações em uma linha antes, mas geralmente são complicadas e talvez eu tenha pouco tempo. Meus commits nem sempre se parecem com unidades perfeitas e completas de trabalho ou mudança. Como já foi dito, às vezes são apenas o resultado de minha esposa me pedir para sair para jantar inesperadamente.

TBH muitos dos meus commits que seguem esse "Working on [...]"padrão de log não estão modelando unidades coerentes de mudança (por que muitas vezes não consigo apresentar uma mensagem melhor que isso "Working on [...]"), mas apenas o resultado de eu respirar, como fazer uma xícara de café. A "Completed [...]"mensagem indica o fim dessa unidade de trabalho, e muitas vezes escrevo uma mensagem muito mais detalhada junto com as primeiras "Started working on [...]"mensagens de tipo quando começo a trabalhar em algo. Se você faz uma média de confirmações como uma vez a cada 15 minutos, as mensagens "Trabalhando [...] em" são mais intermediárias para o que alguém pode confirmar em uma confirmação mais massiva com uma mensagem mais detalhada.

Devo confirmar antes de qualquer teste (por exemplo, pelo menos para erros de sintaxe / compilação e, em seguida, preciso desfazê-lo totalmente; pois a ideia não funcionou ou a mensagem é uma mentira)?

Eu apenas vou em frente e cometo antes mesmo de executar testes algumas vezes (novamente se eu tiver um evento inesperado). Além disso, mesmo sendo solo, envio para um servidor (apenas um rodando aqui em casa em uma LAN) que faz CI. Pode parecer um exagero, mas não sei, eu me acostumei a me apoiar nisso nos meus locais de trabalho anteriores. Além disso, não quero me incomodar em ter que executar todos os meus testes de unidade e integração manualmente todas as vezes. Eu gosto de ter tudo isso ligado a apenas empurrar. Se um teste falhar, é fácil trabalhar de maneira progressiva, onde eu faço a regressão, corrijo o erro na última revisão e continuo. Dito isto, pelo menos construo o código contra uma compilação de depuração antes de confirmar.

Devo me certificar de me comprometer todas as manhãs / tardes antes de parar de trabalhar para o jantar enquanto ainda está fresco?

Eu gosto de me comprometer antes de sair e fazer uma pausa entre a programação. Eu realmente não pensei muito no porquê exatamente até encontrar essa pergunta. Suponho que é para me impedir de continuar de onde parei sem um log de confirmação no lugar de onde parei para que eu possa diferenciar e assim por diante. Hmm, eu preciso voltar para você, pois talvez não seja teoricamente necessário, dada a frequência com que eu me comprometo. Ainda me sinto mais confortável em fazer e empurrar antes de sair do computador por qualquer motivo. Parte disso pode ser o antigo medo psicológico de, digamos, o computador pegando fogo depois que eu saio e tendo os gerentes de projeto nos dias em que estávamos usando SVN com os desenvolvedores às vezes passando semanas sem comprometer a respiração de nossos pescoços e constantemente nos lembrando de verificar o código o mais rápido possível, lembrando-nos que nosso código é propriedade da empresa. Além disso, é um pouco mais eficiente, especialmente com o envio para que meu processo de IC possa começar a executar todos os testes enquanto estiver fora, para que eu possa voltar e ver os resultados.

Ah, e às vezes fico um pouco bêbado depois que saio e geralmente é uma má idéia tentar escrever código complexo enquanto bêbado (embora nem sempre; uma vez, eu criei um sistema de menu de contexto muito bom depois de ter um momento eureka enquanto estava bêbado, mas eu só tinha 6 cervejas e não era tão complexo de codificar). Se eu tentar fazer isso, pelo menos eu cometi o código sobriamente escrito antes de voltar a voltar para, em vez de misturar o código bêbado com o código sóbrio, quando o meu log de confirmação pode ser como, "Reverting back to code written before Jagermeister shots."não faço isso com muita frequência, a menos que eu tenha uma inspiração de código bêbado, mas nesses raros casos, realmente ajudou o fato de eu ter cometido algo antes de sair e ficar bêbado.