Devo manter meus arquivos de projeto sob controle de versão? [fechadas]

Devo manter os arquivos do projeto, como .project, .classpath, .settings do Eclipse, sob controle de versão (por exemplo, Subversion, GitHub, CVS, Mercurial, etc)?

Você deseja manter no controle de versão todos os arquivos de configuração portáteis , o que
significa:
Qualquer arquivo que não tenha um caminho absoluto.
Isso inclui:

• .projeto,
• .classpath ( se nenhum caminho absoluto for usado , o que é possível com o uso de variáveis ​​IDE ou variáveis ​​de ambiente do usuário)
• Configurações IDE (que discordo totalmente da resposta 'aceita'). Essas configurações geralmente incluem regras de análise de código estático que são de vital importância para serem aplicadas de forma consistente para qualquer usuário que carregue este projeto em seu espaço de trabalho.
• As recomendações de configurações específicas do IDE devem ser escritas em um grande arquivo README (e com versão também, é claro).

Regra prática para mim:
você deve ser capaz de carregar um projeto em um espaço de trabalho e ter tudo o que você precisa para configurá-lo corretamente em seu IDE e começar em minutos.
Nenhuma documentação adicional, páginas wiki para ler ou o que não.
Carregue, configure e vá.

Arquivos .project e .classpath sim. No entanto, não mantemos nossas configurações IDE no controle de versão. Existem alguns plug-ins que não fazem um bom trabalho de persistência de configurações e descobrimos que algumas configurações não eram muito portáveis ​​de uma máquina de desenvolvimento para outra. Portanto, temos uma página Wiki que destaca as etapas necessárias para um desenvolvedor configurar seu IDE.

Esses são o que considero serem arquivos gerados e, como tal, nunca os coloco sob controle de versão. Eles podem ser diferentes de máquina para máquina e de desenvolvedor para desenvolvedor, por exemplo, quando as pessoas têm diferentes plug-ins Eclipse instalados.

Em vez disso, uso uma ferramenta de construção (Maven) que pode gerar versões iniciais desses arquivos quando você faz um novo checkout.

Estou dividido entre duas opções aqui.

Por um lado, acho que todos deveriam ser livres para usar o conjunto de ferramentas de desenvolvimento com que são mais produtivos, contanto que todos os artefatos de origem sejam armazenados no controle de versão e o script de construção (digamos ANT ou Maven) garanta a conformidade dos padrões por especificando exatamente qual JDK usar, quais versões de quais bibliotecas de terceiros depender, executar verificações de estilo (por exemplo, checkstyle) e executar testes de unidade etc.

Por outro lado, acho que muitas pessoas usam as mesmas ferramentas (por exemplo, Eclipse) e muitas vezes é muito melhor ter algumas coisas padronizadas em tempo de design em vez de tempo de construção - por exemplo, Checkstyle é muito mais útil como um plugin do Eclipse do que como uma tarefa ANT ou Maven - que é melhor padronizar no conjunto de ferramentas de desenvolvimento e um conjunto comum de plug-ins.

Eu trabalhei em um projeto onde todos usavam exatamente o mesmo JDK, mesma versão do Maven, a mesma versão do Eclipse, o mesmo conjunto de plug-ins do Eclipse e os mesmos arquivos de configuração (por exemplo, perfis de Checkstyle, regras do formatador de código etc.). Todos eles foram mantidos no controle de origem - .project, .classpath e tudo na pasta .settings. Isso tornou a vida muito fácil durante as fases iniciais do projeto, quando as pessoas estavam continuamente ajustando as dependências ou o processo de construção. Também ajudou imensamente ao adicionar novos iniciadores ao projeto.

No geral, acho que se não houver muitas chances de uma guerra religiosa, você deve padronizar o conjunto básico de ferramentas de desenvolvimento e plug-ins e garantir a conformidade da versão em seus scripts de construção (por exemplo, especificando explicitamente a versão Java) .I não pense que há muitos benefícios em armazenar o JDK e a instalação do Eclipse no controle de origem. Todo o resto que não seja um artefato derivado - incluindo seus arquivos de projeto, configuração e preferências de plug-in (particularmente formatador de código e regras de estilo) - deve entrar no controle de origem.

PS Se você usa o Maven, há um argumento para dizer que os arquivos .project e .classpath são artefatos derivados. Isso só é verdade se você gerá-los toda vez que fizer uma compilação, e se você nunca teve que ajustá-los manualmente (ou alterá-los inadvertidamente, alterando algumas preferências) após gerá-los a partir do POM

Não, porque eu apenas os arquivos de controle de versão necessários para construir o software. Além disso, os desenvolvedores individuais podem ter suas próprias configurações específicas do projeto.

Não, eu sou um usuário pesado do Maven e uso o Q para Eclipse frequente do plug-in que cria e mantém .project e .classpath atualizados. Para outras coisas, como configurações de plug-ins, geralmente mantenho um README ou uma página Wiki sobre isso.

Além disso, aqueles com quem trabalhei que preferem outros IDEs, apenas usam os plug-ins Maven para gerar os arquivos necessários para manter seu IDE (e eles próprios) felizes.

Isso tudo é opinião, eu suponho - mas as melhores práticas ao longo dos anos indicam que os arquivos específicos para um determinado IDE não devem ser armazenados no controle de origem, a menos que toda a sua organização seja padronizada em um IDE e você nunca tenha qualquer intenção de alternar.

De qualquer maneira, você definitivamente não quer as configurações do usuário armazenadas - e .project pode conter configurações que são realmente específicas do desenvolvedor.

Eu recomendo usar algo como Maven ou Ant como um sistema de construção padronizado. Qualquer desenvolvedor pode obter um classpath configurado em seu IDE em alguns segundos.

Sim, exceto para a pasta .settings. A confirmação dos outros arquivos funciona bem para nós. Há uma questão semelhante aqui .

Embora eu geralmente concorde com a abordagem "não criar arquivos gerados por versão", temos problemas com ela e precisamos voltar.

Nota: Também estou interessado na resposta de VonC , particularmente sobre o ponto "faça o Eclipse funcionar em minutos". Mas não é decisivo para nós.

Nosso contexto é Eclipse + Maven, usando o plug-in m2eclipse. Temos um ambiente de desenvolvimento comum, com diretórios comuns, tanto quanto possível. Mas acontece às vezes que alguém tenta um plug-in, ou muda pequenas coisas na configuração, ou importa um segundo espaço de trabalho para um branch diferente ...

Nosso problema é que a geração do .project é feita ao importar um projeto no Eclipse, mas não é atualizado em todos os casos posteriormente . É triste e provavelmente não é permanente, pois o plug-in m2eclipse vai melhorar, mas é verdade agora. Então acabamos tendo configurações diferentes. O que tínhamos hoje era isso: várias naturezas foram adicionadas a muitos projetos em alguma máquina, que então se comportou de forma muito diferente :-(

A única solução que vemos é a versão do arquivo .project (para evitar riscos, faremos o mesmo para .classpath e .settings). Dessa forma, quando um desenvolvedor muda seu pom, os arquivos locais são atualizados usando m2eclipse, todos eles são comprometidos juntos e outros desenvolvedores verão todas as mudanças.

Nota: em nosso caso, usamos nomes de arquivo relativos, portanto, não temos problemas para compartilhar esses arquivos.

Então, para responder à sua pergunta, eu digo que sim, envie esses arquivos.

Eu também gostei:

• Resposta do rico vendedor

Parece que esses arquivos de projeto podem mudar com o tempo enquanto você trabalha em um projeto, então sim, eu os coloco sob controle de versão.

Sim. Tudo menos a saída de construção.

Usamos IntelliJ IDEA e mantemos versões '.sample' dos arquivos de projeto (.ipr) e módulo (.iml) sob controle de versão.

A coisa um pouco maior aqui é compartilhar e reutilizar que versionar, IMHO. Mas se você vai compartilhar essas configurações, não há melhor lugar para colocá-las do que no repositório, ao lado de todo o resto.

Algumas vantagens de arquivos de projeto compartilhados e com versão:

• Você pode verificar qualquer tag / branch e começar a trabalhar nisso rapidamente
• Torna mais fácil para um novo desenvolvedor configurar primeiro o ambiente de desenvolvimento e se atualizar
• Este adere melhor ao DRY, que sempre é profundamente satisfatório. Antes disso, todos os desenvolvedores tinham que configurar essas coisas de vez em quando, essencialmente fazendo um trabalho repetido. É claro que cada um tinha suas pequenas maneiras de evitar a repetição, mas olhando para a equipe como um todo, havia muito esforço duplicado.

Observe que no IDEA esses arquivos contêm configurações como: quais são os diretórios "source" e "test source"; tudo sobre dependências externas (onde estão localizados os jars da biblioteca, bem como fontes relacionadas ou javadocs); opções de construção, etc. Isso é coisa que não não variar de desenvolvedor para desenvolvedor (não concordo com isso muito fortemente). IDEA armazena mais configurações pessoais do IDE em outro lugar, bem como quaisquer configurações de plug-in. (Não conheço o Eclipse muito bem; isso pode ou não ser bem diferente.)

Eu concordo com esta resposta que diz:

Você deve ser capaz de carregar um projeto em um espaço de trabalho e ter tudo o que você precisa para configurá-lo corretamente em seu IDE e começar em minutos. [...] Carregar, configurar, vai.

E nós temos assim, graças aos arquivos de projeto versionados.