Quais são as vantagens dos scripts de construção?

Durante a maior parte da minha carreira em programação, usei o comando "build / compile / run" em qualquer IDE com o qual estou trabalhando para produzir um programa executável. Este é um botão, muito fácil. Porém, à medida que aprendo mais sobre diferentes linguagens e estruturas, vejo cada vez mais discussões sobre "scripts de construção" (ANT, Maven, Gradle etc.) para executar um projeto. Meu entendimento disso é que elas são instruções para o compilador / vinculador / fabricante de programas mágicos que especificam detalhes da configuração - minúcias.

Lembro-me de escrever makefiles na escola, mas não vi nenhuma vantagem especial na época (nós os usamos somente quando escrevíamos em um terminal Unix, onde um IDE com o prático botão "build" não estava presente). Além disso, já vi outras perguntas aqui que discutem como os scripts de compilação podem fazer mais do que apenas criar seu programa - eles podem executar testes de unidade e proteger recursos, independentemente da máquina host .

Não posso deixar de pensar que os scripts de construção são importantes para entender como desenvolvedor, mas eu gostaria de uma explicação significativa; por que devo usar / escrever scripts de construção?

As responsabilidades do Build Script e do Build Server discutem a função que ele desempenha em um escopo mais amplo. Estou procurando vantagens específicas oferecidas por um script de compilação versus o comando "compilar / executar" de um IDE ou métodos igualmente simples.

Automação.

Quando você está desenvolvendo, apenas nos projetos mais simples o botão "compilar" padrão faz tudo o que você precisa; pode ser necessário criar WS com APIs, gerar documentos, vincular-se a recursos externos, implantar as alterações em um servidor etc. Alguns IDEs permitem personalizar o processo de construção adicionando etapas ou construtores extras, mas isso significa apenas que você está gerando seu script de construção por meio das mercadorias IDE.

Mas desenvolver um sistema não é apenas escrever código. Existem várias etapas envolvidas. Um script independente do IDE pode ser executado automaticamente, o que significa que:

• Quando você confirma uma alteração no controle de versão, uma nova compilação pode ser iniciada automaticamente pelo servidor. Isso garantirá que você não se esqueça de confirmar qualquer coisa necessária para a compilação.

• Da mesma forma, após a conclusão da compilação, os testes podem ser executados automaticamente para verificar se você quebrou alguma coisa.

• Agora, o restante da organização (controle de qualidade, administradores de sistemas) criou um produto que

  a) é perfeitamente reproduzível apenas na versão de controle.

  b) é comum a todos eles.

Mesmo quando trabalhei como uma equipe, usei scripts para esse fim; quando eu desenvolvesse a correção, eu confirmaria o SVN, exportaria o SVN de volta para outro diretório e usaria o script de construção para gerar a solução, que passaria para os sistemas de pré-produção e posteriormente para a produção. Se algumas semanas depois (com a minha base de código local já alterada) alguém reclamasse de um bug, eu saberia exatamente qual revisão do SVN precisaria fazer checkout para depurar corretamente o sistema.

Como o código, um script de construção é executado pelo computador. Os computadores são excepcionalmente bons em seguir um conjunto de instruções. De fato, (fora do código de modificação automática), os computadores executam a mesma sequência de instruções exatamente da mesma maneira, com a mesma entrada. Isso fornece um nível de consistência que, bem, apenas um computador pode corresponder.

Por outro lado, os sacos de carne cheios de água são absolutamente desprezíveis quando se trata das etapas a seguir. Esse cérebro analítico traquina tem uma tendência a questionar tudo o que aparece. "Ah ... eu não preciso disso", ou "Eu realmente devo usar essa bandeira? Eh ... eu vou ignorá-la." Além disso, temos uma tendência a ser complacentes. Depois de fazer algo algumas vezes, começamos a acreditar que conhecemos as instruções e não precisamos olhar para a folha de instruções.

Do "Programador Pragmático":

Além disso, queremos garantir consistência e repetibilidade no projeto. Os procedimentos manuais deixam a consistência alterada; a repetibilidade não é garantida, especialmente se aspectos do procedimento estiverem abertos à interpretação de pessoas diferentes.

Além disso, somos HILARIAMENTE lentos na execução de instruções (em comparação com um computador). Em um projeto grande, com centenas de arquivos e configurações, levaria anos para executar manualmente todas as etapas em um processo de compilação.

Vou te dar um exemplo do mundo real. Eu estava trabalhando em algum software incorporado, onde a maior parte do código era compartilhada em algumas plataformas de hardware diferentes. Cada plataforma tinha hardware diferente, mas a maior parte do software era a mesma. Mas havia pequenas peças específicas para cada hardware. Idealmente, as peças comuns seriam colocadas em uma biblioteca e vinculadas a cada versão. No entanto, as partes comuns não podem ser compiladas em uma biblioteca compartilhada. Tinha que ser compilado com todas as configurações diferentes.

Inicialmente, compilei manualmente cada configuração. Levou apenas alguns segundos para alternar entre configurações, e não foi tão difícil. No final do projeto, um defeito crítico foi descoberto na parte compartilhada do código, onde um dispositivo assumia essencialmente o barramento de comunicação. Isso foi ruim! Muito ruim. Encontrei o bug no código, corrigi-o e recompilei todas as versões. Excepto um. Durante o processo de construção, eu me distraí e esqueci um. Os binários foram liberados, a máquina foi construída e, um dia depois, recebi uma ligação dizendo que a máquina parou de responder. Eu verifiquei e descobri que um dispositivo havia trancado o ônibus. "Mas eu consertei esse bug!".

Eu posso ter consertado, mas nunca encontrou seu caminho para aquela placa. Por quê? Porque eu não tinha um processo de criação automatizado que criava todas as versões com um clique.

Se tudo o que você quiser é <compiler> **/*.<extension>criar scripts de pouca utilidade (embora se possa argumentar que, se você vê um Makefileno projeto, sabe que pode construí-lo make). A coisa é - projetos não triviais geralmente exigem mais do que isso - pelo menos, você geralmente precisará adicionar bibliotecas e (conforme o projeto amadurecer) configurar parâmetros de construção.

Os IDEs geralmente são pelo menos configuráveis ​​- mas agora o processo de construção depende de opções específicas do IDE. Se você estiver usando o Eclipse , Alice prefere o NetBeans e Bob deseja usar o IntelliJ IDEA , não será possível compartilhar a configuração e, quando um de vocês fizer uma alteração no controle de origem, precisará editar manualmente a configuração criada pelo IDE. arquivos dos outros desenvolvedores ou notifique os outros desenvolvedores para que eles mesmos o façam (o que significa que haverá confirmações nas quais a configuração do IDE está errada para alguns dos IDEs ...).

Você também precisa descobrir como fazer essa alteração em cada um dos IDEs usados ​​pela equipe, e se um deles não suportar essa configuração específica ...

Agora, esse problema depende da cultura - seus desenvolvedores podem achar aceitável não ter a opção de IDEs. Mas os desenvolvedores que têm experiência com um IDE geralmente são mais felizes e mais eficientes ao usá-lo, e os usuários de editores de texto tendem a se interessar religiosamente por suas ferramentas favoritas; portanto, este é um dos lugares onde você deseja dar liberdade aos desenvolvedores. - e sistemas de compilação permitem que você faça exatamente isso. Algumas pessoas podem ter uma preferência de sistema de compilação, mas não é tão fanática quanto as preferências de IDE / editor ...

Mesmo se você conseguir que todos os desenvolvedores usem o mesmo IDE - boa sorte convencendo o servidor de compilação a usá-lo ...

Agora, é para as personalizações simples do processo de construção, que os IDEs tendem a fornecer uma interface gráfica agradável. Se você deseja coisas mais complexas - como arquivos de origem de pré-processamento / geração automática antes da compilação - geralmente precisará escrever um script de pré-construção em alguma área de texto básica dentro da configuração do IDE. Quais sistemas de compilação você ainda teria que codificar essa parte, mas você pode fazê-lo no editor em que escreve o código e, o que é mais importante: a própria estrutura do sistema de compilação geralmente fornece algum suporte para organizar esses scripts.

Por fim - os sistemas de construção são bons para mais do que apenas construir o projeto - você pode programá-los para executar outras tarefas que todos na equipe possam precisar executar. No Ruby on Rails , por exemplo, existem tarefas do sistema de compilação para executar migrações de bancos de dados, limpar arquivos temporários etc. A colocação dessas tarefas no sistema de compilação garante que todos na equipe possam executá-las de maneira consistente.

Muitos IDEs simplesmente empacotam os comandos usados ​​para criar algo e, em seguida, geram um script e o chamam!

Por exemplo, no Visual Studio, você pode ver os parâmetros da linha de comando para uma compilação do C ++ na caixa 'linha de comando'. Se você observar atentamente a saída da compilação, verá o arquivo temporário que contém o script de compilação usado para executar a compilação.

Atualmente, é tudo MSBuild , mas isso ainda é executado diretamente pelo IDE.

Portanto, o motivo pelo qual você usa a linha de comando é que você está indo diretamente para a fonte e pulando o intermediário, um intermediário que pode ter sido atualizado ou requer um monte de dependências que você simplesmente não deseja ou precisa em um servidor sem cabeça que atua como seu servidor de integração contínua (CI).

Além disso, seus scripts fazem mais do que as etapas habituais orientadas ao desenvolvedor para as quais foram projetadas. Por exemplo, após uma compilação, convém que seus binários sejam empacotados e copiados para um local especial, ou um pacote de instalação criado, ou uma ferramenta de documentação executada neles. Muitas tarefas diferentes são executadas por um servidor de IC que não faz sentido em uma máquina de desenvolvedor, portanto, embora você possa criar um projeto IDE que execute todas essas etapas, você precisará manter duas delas - um projeto para desenvolvedores e outro para compilações. Algumas tarefas de construção (análise estática, por exemplo) podem levar um longo tempo que você não desejaria para projetos de desenvolvedor.

Em suma, porém, é apenas mais fácil - crie um script para fazer tudo o que você deseja e é rápido e simples iniciar isso na linha de comando ou na configuração do servidor de compilação.

make

é muito mais fácil lembrar e digitar do que

gcc -o myapp -I/include/this/dir -I/include/here/as/well -I/dont/forget/this/one src/myapp.c src/myapp.h src/things/*.c src/things/*.h

E os projetos podem ter comandos de compilação muito complexos. Um script de construção também tem a capacidade de recompilar apenas as coisas que mudaram. Se você deseja fazer uma construção limpa,

make clean

é mais fácil e confiável depois de configurado corretamente do que tentar lembrar de todos os lugares em que um arquivo intermediário pode ter sido produzido.

Obviamente, se você usa um IDE, também é fácil clicar em um botão de compilação ou limpeza. No entanto, é muito mais difícil automatizar o movimento do cursor para um local específico na tela, especialmente quando esse local pode se mover se a janela se mover, do que automatizar um simples comando de texto.

De que outra forma você faria isso? A única outra maneira é especificar um comando de linha de comando longo.

Outro motivo é que os makefiles permitem compilação incremental, o que acelera bastante o tempo de compilação.

Makefiles também podem criar um processo de compilação entre plataformas. O CMake gera diferentes scripts de construção com base na plataforma.

Editar:

Com um IDE, você está vinculado a uma maneira específica de fazer as coisas. Muitas pessoas usam o vim ou emacs, embora não tenham muitos recursos semelhantes ao IDE. Eles fazem isso porque querem o poder que esses editores fornecem. Os scripts de construção são necessários para aqueles que não usam um IDE.

Mesmo para quem usa um IDE, você pode realmente saber o que está acontecendo, portanto, o script de construção oferece os detalhes mais baixos da implementação que uma abordagem da GUI não possui.

Os próprios IDE também costumam criar scripts internamente; o botão executar é apenas outra maneira de executar o comando make.

As respostas acima cobrem muito terreno bom, mas um exemplo do mundo real que eu gostaria de adicionar (que não posso adicionar como comentário devido a nenhum karma) é da programação do Android.

Eu sou um profissional Android / iOS / Windows desenvolvedor de telefone, e eu usar APIs de serviços do Google (principalmente o Google Maps) um monte .

No Android, esses serviços exigem que eu adicione um keystore ou um tipo de arquivo de ID do desenvolvedor que informe ao Google que sou quem afirmo ser em um console do desenvolvedor. Se meu aplicativo for compilado com um keystore diferente, a seção Google Maps do aplicativo não funcionará.

Em vez de adicionar e gerenciar uma dúzia de keystores no console do desenvolvedor, apenas um deles pode ser usado para atualizar o aplicativo de qualquer maneira, incluo esse keystore em nosso repositório seguro e uso o Gradle para informar ao Android Studio exatamente o keystore a ser usado ao criar para "debug" ou "release". Agora, só tenho que adicionar duas lojas de chaves ao meu console do desenvolvedor do Google, uma para "depuração" e outra para "release", e todos os membros da minha equipe podem clonar o repositório e começar o desenvolvimento sem precisar ir ao desenvolvedor console e adicione o hash SHA de seu keystore específico, ou pior, me fazendo gerenciá-los. Isso tem o benefício adicional de fornecer a cada membro da equipe uma cópia do keystore de assinatura, o que significa que, se eu estiver fora do escritório e uma atualização estiver agendada, um membro da equipe precisará seguir apenas uma lista muito curta de instruções para enviar um atualizar.

A automação de construção como essa mantém as construções consistentes e reduz a dívida técnica, reduzindo o tempo de configuração quando obtemos um novo desenvolvedor, uma nova máquina ou quando temos que recriar uma máquina.

Crie vantagens de script:

• as alterações se parecem com código (por exemplo, em um comando git diff), não com diferentes opções marcadas em uma caixa de diálogo

• criando mais saída do que uma compilação simples

Em alguns dos meus projetos anteriores, usei os scripts de construção para:

• gerar a documentação do projeto (baseada em doxygen)
• Construir
• executar testes de unidade
• gerar relatórios de cobertura de teste de unidade
• empacotar binários em um arquivo morto
• gerar notas de versão internas (com base nas mensagens "git log")
• teste automatizado

Geralmente, você pode chamar o botão "criar" de maneira automatizada (o Visual Studio aceita argumentos de linha de comando, por exemplo). As pessoas escrevem scripts de construção assim que precisam de algo que o botão de construção não pode fornecer.

Por exemplo, a maioria dos IDEs permitirá criar apenas uma plataforma por vez. Ou apenas um idioma por vez. Depois, há o que você faz com as saídas criadas: seu IDE pode agrupá-las em um pacote de instalação?