O que devo fazer quando já esperei muito tempo entre confirmações?

Eu era travesso ... Muita "codificação de cowboy", não basta cometer. Agora, aqui estou eu com um enorme comprometimento. Sim, eu deveria estar cometendo o tempo todo, mas agora é tarde demais.

O que é melhor?

1. Faça um commit muito grande listando todas as coisas que eu mudei
2. Tente dividi-lo em confirmações menores que provavelmente não serão compiladas, pois os arquivos têm várias correções, alterações, nomes de métodos adicionais etc.
3. Tente fazer reversões parciais dos arquivos apenas para confirmações apropriadas e, em seguida, coloque as novas alterações de volta.

Nota: a partir de agora eu sou o único programador trabalhando neste projeto; a única pessoa que analisará algum desses comentários de commit sou eu, pelo menos até contratarmos mais programadores.

A propósito: eu estou usando SVN e Subclipse. Eu criei uma nova ramificação antes de fazer qualquer uma dessas alterações.

Mais informações : Fiz uma pergunta separada relacionada a como entrei nessa situação em primeiro lugar: Como se preparar para reescrever a cola de um aplicativo

Para responder, você deve se perguntar como espera usar os resultados desses commits no futuro. Os motivos mais comuns são:

• Para ver qual versão um bug foi introduzido.
• Para ver por que uma certa linha de código está presente.
• Para mesclar em outro ramo.
• Para poder verificar uma versão anterior para solucionar um problema que um cliente ou testador está vendo nessa versão.
• Ser capaz de incluir ou excluir determinadas partes de uma liberação.

Os dois primeiros motivos também podem ser atendidos com um grande check-in, supondo que você possa criar uma mensagem de check-in que se aplique igualmente bem a cada linha de código alterado. Se você é o único programador, confirmações menores não facilitarão sua mesclagem. Se você não planeja fazer uma liberação ou testar apenas parte de suas alterações não enviadas, os dois últimos motivos não se aplicam.

Existem outras razões para fazer pequenas confirmações, mas elas ocorrem enquanto você está no meio das mudanças e esse tempo já passou. Esses motivos estão facilitando a recuperação de um erro ou alteração experimental e facilitando a sincronização com colegas sem grandes fusões assustadoras.

Pelo meu entendimento de sua situação como você a descreveu, parece que há pouco ou nenhum benefício em dividir seu commit neste momento.

Eu acho que o que você faz, tente evitar o código de entrada que você sabe que não será compilado.

Se você acha que sua terceira opção é viável, pode ser uma boa maneira de fazê-lo, desde que você possa garantir que sua sequência de confirmações não crie um sistema não-compilável. Caso contrário, faça o único grande commit. É feio, mas é simples, rápido e o faz. No futuro, comprometa-se com mais frequência .

O motivo mais importante para fazer confirmações frequentes, pequenas e significativas é ajudar a entender o histórico do código. Em particular, é muito difícil entender como o código mudou, se é difícil gerar diferenças compreensíveis.

A opção 1 ofusca o histórico de alterações que você fez, mas, caso contrário, não causará problemas.

A opção 2 ofusca o histórico de alterações que você fez, possivelmente um pouco menor que a opção 1, mas pode causar outros problemas para você ou para outras pessoas se eles assumirem ou concluirem que os commits são distintos, por exemplo, podem ser mesclados em outros ramos independentemente. A menos que haja uma forte razão prática pela qual isso é preferível à opção 1, isso é menos ideal do que isso.

A opção 3 é a melhor, sendo tudo igual, mas, como você descreveu em outro lugar, isso exigiria quantidades "extremas" de tempo ou incorreria em outros custos significativos, você terá que ponderar esses custos com os benefícios esperados de criando confirmações mais limpas.

Com base nas informações que você forneceu, eu optaria pela opção 1. Talvez você deva configurar lembretes solicitando que você efetue suas alterações?

Prototipagem e Reescrita

Outra consideração a ter em mente, especialmente à luz de sua observação sobre ser o único programador, e minha suspeita de que você esteja trabalhando em uma base de código relativamente nova, é que provavelmente é bom desenvolver hábitos diferentes com relação a confirmar alterações quando você está criando um novo código para a criação de protótipos em vez de manter ou estender o código existente. Provavelmente não existe uma divisão muito nítida entre os dois, mas acho que ainda é uma distinção útil.

Ao criar um novo código para criação de protótipo, confirme sempre que desejar salvar suas alterações, quase certamente em uma ramificação, mas talvez em um projeto separado. Ou talvez apenas trabalhe completamente fora do controle de versão. Em vez disso, você pode se concentrar em reunir evidências sobre a viabilidade de várias hipóteses ou projetos que estiver considerando. Costumo escrever pequenos protótipos usando ferramentas diferentes, por exemplo, LINQPad em vez de código do Visual Studio para C #.

Quando você validar uma hipótese ou design específico, reescreva-o em seu projeto principal, idealmente em uma ramificação, e faça os pequenos e significativos commits que ajudarão melhor a compreensão dos outros (incluindo você futuro) quanto à natureza das mudanças você está fazendo.

Embora a única resposta razoável seja nunca quebrar o tronco , algumas vezes isso não é possível. Por exemplo, o svn pode interromper o commit se você confirmar demais (talvez uma opção ou recurso, não tenho certeza). Nesses casos especiais, basta fazer o check-in em pedaços. Como você é um programador único, isso não vai incomodar ninguém.

Portanto, eu iria para a opção 1. Se não for possível, então a opção 2.

A opção 3 requer muito esforço e simplesmente não vale a pena.

Tente dividi-lo em confirmações menores que provavelmente não serão compiladas, pois os arquivos têm várias correções, alterações, nomes de métodos adicionais etc.

Quando me encontrei em uma situação semelhante, usei a seguinte técnica:

1. Adicione apenas o código relevante para um recurso específico: git add --patch
2. Esconda todas as outras alterações: git stash save --keep-index
3. Execute testes / tente compilar
4. Confirme as alterações se estiver tudo bem, se não for, vá para 1

Eu não estou familiarizado com o SVN, então não sei se isso é aplicável à sua situação específica, mas a base deve ser a mesma - isole pequenas partes do código e teste-as individualmente.

Que tal a opção 4: faça backup do estado atual do seu repositório em um local temporário, reverta-o ao estado original, faça uma lista de todas as alterações que você fez (você ainda pode ver o backup temporário) e reimplemente manualmente (e compile e testá-los!) como confirmações separadas.

Isso deve ser mais fácil, porque você já escreveu o código, é apenas um pouco para descobrir quais partes copiar e colar do seu backup temporário.

Quando você reimplementar todas as alterações de forma limpa e, assim, garantir que as confirmações sejam independentes, pequenas e compiladas, você poderá excluir o backup temporário e tudo será quase exatamente como (exceto a hora / data das confirmações) teria sido se você fizesse isso desde o início.

Você é o único programador; basta fazer um único check-in massivo detalhando os bits importantes do que você fez.

É provável que você reverta "partes" do que fez? Caso contrário, continue com a opção 1.

Existem algumas razões para verificar o código em um sistema de controle de versão. E TODOS eles, quando você é o único desenvolvedor, giram em torno da segurança - ou seja, se você estragar, a máquina morre ou o que for, você sempre pode voltar ao último ponto de verificação.

É improvável que um programador que entre no projeto mais tarde queira reverter para uma versão que não seja compilada. Então, IMHO, a opção 2 é loucura.

A opção 3 parece um sumidouro de tempo: se eu fosse seu chefe e o visse perdendo horas fazendo isso, conversaria um pouco com você sobre quanto vale seu tempo.

Para iterar: ao verificar seu código, você está cobrindo / salvando seu bumbum em caso de falha em sua máquina. Todo o resto, em uma equipe de um homem, é vitrine.

Minha regra é: nenhum check-in sem uma séria revisão de código. Se eu estiver sozinho, terei que revisar o código pessoalmente, mas ele será revisado. Você parece ter uma quantidade de alterações de código que alguém não pôde revisar, portanto, você não pode revisá-lo (revisar seu próprio código é mais difícil e requer mais disciplina, porque você assume automaticamente que o seu próprio código está correto )

A regra totalmente inquebrável de todo mundo é: nunca faça check-in de código que nem cria e evite seriamente fazer check-in de código que não funciona.

Solução: copie seu código alterado e volte ao ponto original. Mesclar uma alteração de cada vez no código original, revisá-lo, testá-lo e fazer check-in. Com o método de programação que você descreveu, é provável que você encontre alguns erros sérios dessa maneira.

Também é uma boa maneira de treinar bons hábitos de programação.

Eu acho que você está se preocupando demais. Se você é o único programador e não possui uma folha de especificações contra a qual trabalhar, depende inteiramente de você o que você faz. Suponho que ninguém o castigará por fazer um commit grande, portanto os únicos problemas com os quais você se deparará são tecnológicos, como não conseguir reverter as alterações de arquivos individuais dentro do commit. Como você está no controle do repo neste momento, isso também não deve ser uma grande preocupação.

Há uma linha a ser traçada entre pragmatismo e dogmatismo. O que você fez não seria uma boa idéia em uma equipe e provavelmente não deveria ser repetido daqui para frente, mas na sua situação eu apenas enviaria o commit grande.

O problema não está nos longos atrasos entre as confirmações, mas no fato de você manter o código em estado não compilável por muito tempo. Primeiro de tudo, qual é a sua definição de 'longo'? Para algumas pessoas, 5 minutos para o estado de transição são demais, mas alguns podem polir seu código por dias sem tentar executar o compilador.

Na verdade, isso não importa - o que importa é que você perdeu o controle do seu código, seu código se tornou incontrolável. Isso é normal, apenas significa que você tem dívida tecnológica e é hora de pensar em refatoração. Então você está frustrado? Seu código não é compilado, você nem tem testes de unidade? Como você pode pensar em refatorar nesse caso? Não se preocupe. Termine sua "codificação de cowboy" e comece a limpá-la. Idealmente, tente escrever alguns testes. Você não tem tempo para isso? Ok, comece com pequenas melhorias.

Algumas alterações não requerem testes. Mude o nome da variável para mais adequado, mova o código de repetição para uma função separada, etc ... Você terá uma melhor idéia do seu código. Depois disso, você pode fazer alterações maiores. Mais uma vez, tente escrever testes, se possível. Torne seu código gerenciável.

Depois disso, você verá que a próxima mudança não demorará "demais" (o que quer que isso signifique).