Convença um desenvolvedor solitário a usar uma ferramenta de compilação separada em vez da compilação com um clique do IDE

22

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.

Gigatron
fonte
3
Embora você certamente deva pensar na possibilidade de usar scripts Ant / Maven / Gradle para lidar com o processo de compilação. Certamente pode esperar até uma fase posterior do seu ciclo de desenvolvimento. Não complique as coisas. Quando você está no caminho certo para lançar algo que possa ser vendido e ter um investidor, e quando isso vai além, basta considerar. Porque certamente NÃO será uma tarefa "faça uma vez e esqueça". Você precisará manter o script atualizado para corresponder aos seus procedimentos de compilação. Se preocupe com os scripts quando tiver alguma ajuda.
Ramhound 28/02/2012
5
As ferramentas de construção tornam-se benéficas no momento em que você tem mais do que "a versão mais recente composta por todo o código mais recente" para lidar. Você não está lá ainda - no momento em que você faz, domar sua construção.
8
Se o que você está fazendo agora funciona e não lhe causa problemas, continue. A "Correção prematura" provavelmente causa mais problemas do que a "Otimização prematura". Além do seu IDE, provavelmente você está usando Ant nos bastidores.
James Anderson
1
Pergunta muito válida
Madhur Ahuja

Respostas:

11

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.

aroth
fonte
1
Continuarei com a criação do IDE com um clique até que a primeira versão beta seja lançada. Então, estou planejando usar o Maven. Ant parece criar mais trabalho do que economizaria para minha situação, mas Maven parece ser direto o suficiente e poderoso o suficiente para valer a pena. Para mim, não é apenas uma questão de saber se há um benefício em ter a ferramenta de construção; Também peso o custo de aprendê-lo, configurá-lo e mantê-lo.
Gigatron
7

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.

Nate
fonte
7
Discordo 1000 vezes. Se você estruturar seus scripts de construção corretamente, precisará pagar apenas o custo de escrevê-los uma vez e poderá reutilizá-los quase literalmente em qualquer número de projetos. Há muito a ser dito em favor de ter um comando de compilação de uma linha que cria, configura, implanta e executa o sistema automaticamente. E uma vez que você tem isso, você vai economizar uma tonelada de tempo em relação ao gerenciamento de implantação / configuração manual, que pode ser gasto nesses novos recursos que você menciona.
Aroth
Concordo que uma loja individual precisa ser focada. Não concordo com a sua premissa, pois as ferramentas de construção economizariam tempo a longo prazo, tanto para a criação de novos projetos quanto para a manutenção de projetos existentes, ou mesmo para produzir entregas sob demanda para os clientes.
haylem 29/02/12
Uma vantagem sutil do Maven é que ele funciona melhor com um layout padrão de arquivos, em oposição à maneira ad-hoc frequentemente vista em projetos Ant. Quando as pessoas vêem a vantagem de usar os padrões do Maven, elas os usam e seus projetos são mais fáceis de entender para futuros mantenedores.
1
@aroth Mas o OP não gasta tempo fazendo "gerenciamento manual de implantação / configuração", ele apenas aperta um botão em seu IDE. Portanto, não economizaria tempo algum.
Atsby
1
O IDE é um sistema de construção. Ou então eu não estaria usando.
Arne Evertsson
5

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".

Kryptic
fonte
De fato. A coisa real que esse desenvolvedor deve considerar é uma boa solução de IC, e um script de construção pode ajudar a chegar lá.
Bill Michell
4

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.

haylem
fonte
3

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)

fonte
1
Especialmente manipulação de dependência. Estou com preguiça de baixar e adicionar bibliotecas externas. Muito mais simples apenas para adicioná-los como uma dependência. "Versão errada? Alterar versão na configuração e reconstruir!"
Sim, mas o tratamento de dependências não é realmente um pré-requisito de todas as ferramentas de construção. Maven, Gradle, Ivy apoiam. Formiga, Make, etc ... não.
21712 haylem
2

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 .

Jayan
fonte
1

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.

Wyatt Barnett
fonte
Exatamente o que eu estava pensando! Atualmente, estou trabalhando em um local em que todo desenvolvedor trabalha sozinho em seu próprio projeto. Ainda não consegui vender a idéia de um sistema de compilação, mas estou usando-o porque acho que realmente ajuda.
Elias
0

À 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.

triplo
fonte
1
Eu já faço testes de unidade sem a necessidade de uma ferramenta de compilação separada. O IDE pode executar os testes ou eu posso executá-los na linha de comando.
0

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.

Ricky Clarkson
fonte