As mensagens de commit devem ser escritas no tempo presente ou no passado? [fechadas]

Então, o que você acha que é melhor e mais intuitivo?

Fixed the XXX bug in YYY
Fix the XXX bug in YYY
Fixes the XXX bug in YYY
Fixing the XXX bug in YYY

Forneça seus fundamentos. Nota Estou perguntando de sua perspectiva geral, o que significa que você não deve tentar associar isso às suas ferramentas ou linguagens de programação svn / cvs preferidas, mas sim pensar nisso como algo que deve / pode ser aplicado a quaisquer ferramentas e linguagens de programação.

Eu penso nessas mensagens como elas aparecem para outros desenvolvedores. Eles ainda não têm as alterações aplicadas e há a questão implícita, "o que a aplicação deste changeset / patch fará?" Irá "Corrigir o bug XXX em YYY"!

Para outros verbos, escrevê-los como um comando parece mais natural e funciona melhor se você tiver um objetivo específico antecipadamente - você pode literalmente escrever o resumo do commit junto com os testes iniciais antes que o trabalho seja concluído.

Eu não coloco muito peso nisso, mas para mim este é o caminho de menor resistência, mantendo a consistência.

Eu, pessoalmente, escolho o pretérito ("corrigido"), pois no momento em que começo a cometer o bug está corrigido (ou eu não estaria cometendo).

Eu prefiro ver as mensagens de commit no presente. Dessa forma, a mensagem descreve o que o diff faz (porque você pode puxar aquele diff ou mesmo todo o commit em um branch diferente). Portanto, a mensagem de commit não descreve o que "fez" ... Ela descreve o que o próprio commit "faz" faz. Portanto, deve estar no tempo presente.

Imagine olhar para uma diferença isoladamente e tentar decidir se vai aplicá-la. Não faz sentido ter um título no passado.

IMHO, se você quiser que seja descritivo sem a necessidade de considerar o contexto, então "Fixo" é definitivamente a única variante certa.

Com relação à intuição - se eu olhar para algum changelog, definitivamente entenderei que você quer dizer o bug corrigido, pois eu sei o contexto em que a palavra é usada, mas meu cérebro vai pegá-lo muito mais rapidamente se a palavra estiver escrita desta forma- especificando forma.

"Consertar" é a pior escolha IMHO, pois pode ser interpretado não apenas como uma descrição do que o patch faz (é para), mas também como um status de bug, o que significa que ele está sendo trabalhado e ainda não foi resolvido.

Fix the XXX bug in YYY
Teach the XXX to be more ZZZ
Correct typos in javadoc

Em geral: {verbo imperativo} o {objeto afetado} {qualificadores opcionais}

A forma imperativa se adapta a todos os casos de uso quando estou considerando um patchset.

• O que vais fazer aqui?
• O que esse patchset faz?
• Por que esse patchset foi criado? (para consertar o bug xxx ...)
• Eu preciso corrigir o bug xxx em yyy. Existe um commit em outro branch que já faz isso?

Independentemente da sua escolha, acho que a consistência ajuda imensamente a legibilidade. Escolha um e fique com ele.

Eu acho que escrever sobre o commit atual no tempo presente é uma boa ideia, porque torna mais claro quando você se refere a commits anteriores no pretérito.

Eu não acho que isso realmente importe. O objetivo é:

1) Transmita o que está ou estava sendo feito, para que os bugs possam ser encontrados mais facilmente, os problemas possam ser revertidos com mais facilidade e, geralmente, seja capaz de manter o projeto mais fácil.

2) Transmita quais tickets foram corrigidos, se houver, para que os auditores (se eles forem usados ​​em sua empresa podem ver quais mudanças correspondem a quais tickets).

Por último, se já tiver sido corrigido, "Consertar" não faz sentido e, se você ainda estiver trabalhando nisso, "Consertar" não está correto.

" Corrigir bug X " tem 2 caracteres a menos que " Corrigir bug X ".
E 3 mais curtos do que " Consertando bug X ".

Do ponto de vista da escrita de mensagens curtas de confirmação, o tempo presente às vezes / geralmente salva alguns caracteres?
O que eu realmente acho que importa um pouco, por exemplo, com a recomendação do Git de menos de 50 caracteres-na-primeira-linha de mensagem de confirmação.
Além disso, menos texto -> leu mais rápido?

Uma mensagem de confirmação descreve por que você escreveu o código que está sendo confirmado.

"Corrigido o problema 3124" ou "Corrige o problema 3124" parece certo porque diz que este código corrigiu | corrige o problema 3124.

No entanto, a gramática também pode depender do motivo pelo qual marca o bug como corrigido. Se você pode marcar o bug como corrigido após a confirmação, então "Corrigido" está bem, mas se o bug for marcado como corrigido por outra pessoa após verificar seu código, então "Correções" pode ser mais apropriado.

Acho que a resposta mais importante para essa pergunta é: todos devem usar o que funciona para um projeto específico e mantê-lo pelo menos um pouquinho consistente.

Embora eu veja as vantagens de usar o tempo presente (e na verdade me deparei com este post porque vi algumas mensagens de tempo presente em projetos de código aberto), provavelmente nunca irei usar o tempo presente para meus projetos. É a forma recomendada para Linux e Git, e provavelmente outros grandes projetos de código aberto, mas eu honestamente não me importo, contanto que não faça parte desses projetos.

Sou um desenvolvedor independente e uso a primeira linha de uma mensagem de confirmação para notas de lançamento, enquanto a descrição nas linhas a seguir me dá uma ideia sobre os detalhes de implementação. É um fluxo de trabalho centrado no usuário em comparação com o tempo presente, abordagem baseada no desenvolvedor. Posso economizar algum tempo dessa forma. Seria extremamente antinatural dar instruções aos meus usuários nas notas de versão. É meu trabalho consertar bugs e adicionar recursos. Tenho que economizar tempo, porque sou um indie. Não tenho um “redator de notas de lançamento” em minha equipe.

Use as regras de um projeto se já estiverem estabelecidas, mas seja pragmático e faça o que quer que torne seu trabalho mais fácil ou rápido.

Eu acho que "Fixes XXX bug"faz mais sentido do que "Fix XXX bug"se o motivo para usar o tempo presente for "torná-lo mais descritivo do que o commit faz" ao invés do que o committer fez.

Se for um pequeno commit, eu uso o presente contínuo:

Reparando bug 304

ou

Adicionando comentários

Se for um grande commit, faço mais um log de alterações:

• Correções de Bug 453, 657 e 324
• Adicionando sintaxe de expressão
• Refatorou a classe Operator.