Nos meus anos de programação em Java e, mais recentemente, em Scala, nunca usei Ant, Maven, Gradle ou qualquer uma dessas ferramentas de construção para Java. Em todos os lugares em que trabalhei, havia um gerente de construção que cuidava de tudo isso - eu compilava localmente com o IDE para desenvolvimento e teste de unidade, depois verificava o código-fonte e notificava o gerente de construção que fazia o necessário para compile os arquivos de todos para o ambiente compartilhado.

Agora que estou entre os contratos, tenho trabalhado em meu próprio projeto autofinanciado e está chegando ao ponto em que poderia ser bom o suficiente para realmente ganhar dinheiro. Até tenho um investidor em potencial alinhado e planejo mostrar a eles uma versão beta nas próximas semanas.

Mas o tempo todo, basta clicar no botão de compilação no IDE, e ele cria o arquivo Jar e funciona muito bem. Obviamente, a sabedoria convencional sugere que eu "deveria" escrever meus próprios scripts Ant / Maven / Gradle e usá-los em vez do IDE, mas quais são as vantagens concretas disso na minha situação (trabalhando sozinho)?

Fiz algumas leituras sobre como usar essas ferramentas de construção e parece que eu estaria escrevendo centenas de linhas de XML (ou Groovy ou o que quer que seja) para fazer o que o IDE faz em um clique (o IDE gerado O XML da formiga para o projeto tem mais de 700 linhas). Parece propenso a erros, demorado e desnecessário para a minha situação. Sem mencionar a curva de aprendizado, que tiraria tempo de todo o outro trabalho que estou fazendo para preparar o produto para mostrar às pessoas.

Eu sugiro que você use o Maven em vez do Ant. Se o seu IDE puder criar seu projeto com um clique, é provável que o Maven também possa construí-lo com praticamente nenhuma configuração personalizada.

E para responder à pergunta, simplificar o processo de implantação é um exemplo concreto. Se você estiver construindo um produto distribuível localmente, isso significa que você deve implantá-lo manualmente em seu sistema de produção e implica que você provavelmente precisou fazer algumas configurações manuais no sistema de produção para prepará-lo para a implantação (instalação do Tomcat , talvez, ou copiar dependências e recursos exigidos pelo seu aplicativo). Isso pode levar muito tempo e tornar a implantação de atualizações um processo tedioso e manual. Ele também permite que pequenas diferenças de configuração entre sua plataforma de produção e seu ambiente de desenvolvimento causem erros obscuros e difíceis de rastrear.

De qualquer forma, o que faço para me livrar dessa labuta manual é que eu configuro meu projeto para compilar com o Maven e meu pom.xmlarquivo com todas as informações necessárias para (no caso de um aplicativo Web Java) encontrar e baixar o versão correta do Tomcat, instale-o localmente, configure os arquivos de configuração corretos do Tomcat, implemente quaisquer dependências do projeto e o próprio arquivo WAR do projeto e inicie o Tomcat. Em seguida, crio um shell script simples (e também uma .batversão para Windows) que usa o Maven para criar e iniciar o servidor:

mvn clean install cargo:start -Dcargo.maven.wait=true

Portanto, em vez de empacotar um implementável no meu ambiente de desenvolvimento e depois empurrá-lo manualmente para a produção, tudo o que preciso fazer é sincronizar do sistema de controle de versão para o servidor de produção e, em seguida, o próprio sistema de produção cria, instala e executa o implementável (e o faz de maneira idêntica à de como é feito em qualquer sistema de desenvolvimento, minimizando a possibilidade de erros ou configurações incorretas específicas da plataforma). E seja no ambiente de desenvolvimento ou produção, tudo o que faço para criar e iniciar o servidor é:

./startServer.sh #or startServer.bat for Windows

E para implantar uma atualização no ambiente de produção, o processo é apenas:

1. Pare a instância do servidor em execução, se houver.
2. Corra svn update -r<target_release_revision>.
3. Corra ./startServer.sh.

É simples, fácil de lembrar, e não é possível fazer isso se eu tivesse que usar meu IDE para criar o implementável para mim. Também faz com que a reversão para a última implantação válida seja rápida, caso uma reversão seja necessária.

Não consigo nem contar a quantidade de tempo que essa abordagem me salvou ao tentar gerenciar manualmente o processo de implantação e configuração.

E, claro, outra resposta para sua pergunta é o gerenciamento automático de dependências, mas acredito que já tenha sido coberto por outras respostas.

Contanto que seu código esteja no controle de origem, é bom usar o IDE para tornar seus distribuíveis.

Como uma loja individual, é melhor gastar seu tempo adicionando novos recursos ao seu produto ou escrevendo scripts de construção? Algo me diz que não está escrevendo scripts de construção.

Claro, é mais difícil ver os benefícios quando você está trabalhando sozinho. Pessoalmente, trabalhei em muitos projetos solo e não apenas escrevi um script de construção, como também enfrentei o problema de configurar um servidor de CI (como Jenkins).

Existe uma sobrecarga, é claro, por que valeria a pena?

• Uma construção reproduzível, não vinculada ao IDE (ou à sua máquina, se você a executar externamente). Se um servidor de compilação o executar, outras máquinas poderão executá-lo.
• A diversão começa após a construção e o teste de unidade (a propósito: você tem certeza de testar antes de cada confirmação? Às vezes esqueço). Gere documentação, construa instaladores, execute suas ferramentas de análise de código favoritas.
• Seu servidor de IC favorito permite que você veja gráficos de cobertura de código, falhas no teste de unidade etc. ao longo do tempo. Seu IDE faz isso?

Para o meu projeto atual, o script cria, executa ferramentas de análise estática, compacta js / css, testes de unidade e pacotes em um arquivo da web. Jenkins o executa após cada confirmação e implanta o projeto em um servidor de teste.

Levei um tempo para configurá-lo (o script de construção é talvez de 300 linhas, não o toca há meses) e posso dizer que vale a pena, mesmo para uma pessoa. Para mais de uma pessoa, é necessário. Meu envolvimento no processo de construção / implantação consiste nos comandos "hg commit" e "hg push".

Benefícios das Ferramentas de Construção

É um breve resumo apenas mostrando a ponta do iceberg, e você não notará necessariamente o importante disso, a menos que precise fazer uma combinação de muitos projetos, grandes projetos e equipe de médio a grande porte. Mas se você tiver fé e tentar, colherá os benefícios .

Eles facilitam o seu ciclo de vida de desenvolvimento e permitem:

• organize e estruture seus projetos de maneira consistente e sem esforço
• reutilize boas práticas em projetos e inicie-as de maneira fácil e rápida ,
• integre vários projetos em uma única construção,
• automatize seu processo de integração contínua ,
• compartilhe seu projeto com outras pessoas
  • sem forçá-los a usar um kit de ferramentas ou IDE específico (além do sistema de compilação),
  • e sem surpreendê-los, pois eles esperam uma compilação padrão
• automatize e facilite a manutenção do seu produto
• automatize o processo de lançamento do seu produto

Se aplicarmos isso ao Maven ...

Para aqueles de vocês no mundo Java e que usam o Maven , lendo isso, você naturalmente associa cada ponto a:

• Convenção do projeto estruturado de Maven
• Arquétipos Maven
• Materializando um projeto do SCM e as construções do reator
• Jenkins / Hudson / Bamboo / outro suporte + Suporte do Maven para práticas de teste de integração
• m2eclipse, suporte nativo a IntelliJ ou NetBeans - ou mvnsh para a linha de comando
• versões-maven-plugin
• maven-release-plugin, buildnumber-maven-plugin e versões-maven-plugin

E, claro, o Maven (mas também outras ferramentas) oferece gerenciamento de dependência , e isso economiza muito tempo e espaço para você (considerando o número de pessoas em sua equipe) e seu SCM.

Tudo é relativo:

Estou usando o Maven como exemplo, porque acho que é o sistema de construção mais abrangente e com "baterias incluídas", mas isso não significa que seja necessariamente o "melhor". No entanto, ele se encaixa em todas as caixas de seleção listadas acima e, ao procurar um bom sistema de compilação, comparo-o a esta lista e ao Maven. No entanto, o Maven nem sempre é muito flexível - é muito extensível - se você se desviar do processo padronizado. Isso aumenta sua produtividade no caso geral (uma vez à frente da curva de aprendizado), não se você lutar contra isso.

Aqui estão os meus 4 principais motivos para usar as ferramentas de construção:

• tratamento de dependência (evitar erros)
• teste (sua alteração não quebrou outros módulos - muito mais fácil de testar)
• commits seguros
• mais fácil de implantar distribuível local (ninguém tem tempo no ambiente de controle de qualidade para aguardar o construtor construir seu projeto e suas dependências)

No livro Pragmatic Programmer , Andrew Hunt e David Thomas dizem que 'checkout-build-test-deploy' deve ser um único comando (capítulo: Projetos pragmáticos). Você escreveu..

Até tenho um investidor em potencial alinhado e planejo mostrar a eles uma versão beta nas próximas semanas

Então, tenho certeza de que sua equipe vai crescer. É ainda mais importante ter as habilidades automáticas de implantação de teste.

O XML grande (script) que você viu geralmente é um trabalho único. Na maioria das vezes, os mesmos scripts podem ser usados ​​em muitos projetos.

Não está claro qual o tamanho do projeto. Se seus testes integrados / testes de aceitação exigirem CPU / memória grande, considere usar outra máquina como servidor de teste. Você também pode implantar várias ferramentas para analisar o código fonte / código de bytes .

Eu diria que, para um desenvolvedor solitário, ter um bom processo e estrutura como builds com script é muito mais importante do que quando você está em uma equipe. Razão porque você não tem companheiros de equipe para chamá-lo quando você faz cantos. Um servidor de CI que executa seu script de compilação é um excelente companheiro de equipe para se manter honesto.

À medida que sua base de código cresce, você deseja adicionar um conjunto de testes. Minha experiência é que isso deve ser feito mais cedo ou mais tarde, e que sua compilação noturna (ou o que seja) deve executar todos os testes todas as vezes. Comece pequeno, o XML gerado automaticamente provavelmente está bem. Quando você tem medo de mudar alguma coisa por medo de quebrar outra coisa, é um bom incentivo para escrever alguns casos de teste.

Uma compilação não IDE facilita a reconstrução de versões antigas sem se preocupar em reconfigurar seu IDE da maneira que era na época, permite executar a compilação de maneira não interativa, para que você possa manter uma compilação noturna para as pessoas testarem ou descobrir rapidamente se você quebrou os testes sem precisar se lembrar de executá-los e esperar que eles sejam concluídos.

Também permite executar compilações em ambientes que não são da GUI, por exemplo, ssh'ing para um servidor, e permite alternar IDEs sem se preocupar em perder a capacidade de criar seu software.

Algumas ferramentas de construção ajudam a automatizar a marcação e a implantação de versões, além de padrões decentes para gerar relatórios de cobertura de código, etc.

Quando você adiciona mais pessoas, uma ferramenta de compilação garante que você não fique vulnerável à má configuração do IDE de outra pessoa. Eu regularmente faço compartilhamento de tela para consertar as instalações do Eclipse dos colegas porque eles não usam ferramentas de construção (trabalhando nisso).

A razão final é que é algo que não precisa ser feito manualmente, portanto não faça isso manualmente. Tudo o resto cai disso.