Quels sont les avantages des scripts de construction?

Pendant la majeure partie de ma carrière en programmation, j'ai utilisé la commande "build / compile / run" dans n'importe quel IDE avec lequel je travaille pour créer un programme exécutable. Ceci est un bouton, assez facile. Alors que j'en apprends davantage sur différents langages et frameworks, je vois de plus en plus parler de "scripts de construction" (ANT, Maven, Gradle, etc.) pour faire fonctionner un projet. D'après ce que j'ai compris, il s'agit d'instructions adressées au compilateur / éditeur de liens / fabricant de programme magique qui spécifient les détails de la configuration - minuties.

Je me souviens d’avoir écrit des fichiers makefile à l’école, mais je ne voyais alors aucun avantage particulier (nous ne les utilisions que pour écrire dans un terminal Unix, où il n’y avait pas d’IDE avec son bouton "build" bien pratique). Au-delà de cela, j'ai vu d'autres questions ici qui expliquent comment les scripts de génération peuvent faire plus que créer votre programme: ils peuvent exécuter des tests unitaires ainsi que des ressources sécurisées indépendamment de la machine hôte .

Je ne peux m'empêcher de penser qu'il est important de comprendre les scripts de génération en tant que développeur, mais j'aimerais une explication significative. pourquoi devrais-je utiliser / écrire des scripts de construction?

Les responsabilités de Build Script et Build Server décrivent le rôle qu’il joue dans un cadre plus large. Je recherche les avantages spécifiques offerts par un script de construction par rapport à la commande "build / run" d'un IDE ou à des méthodes similaires.

Automatisation.

Lorsque vous développez, seuls les projets les plus simples permettent au bouton "Générer" par défaut de faire tout ce dont vous avez besoin; vous devrez peut-être créer des WS à partir des API, générer des documents, établir des liens avec des ressources externes, déployer les modifications sur un serveur, etc. Certains IDE vous permettent de personnaliser le processus de construction en ajoutant des étapes ou des générateurs supplémentaires, mais cela signifie simplement que vous êtes générer votre script de construction via les produits IDE.

Mais développer un système, ce n'est pas seulement écrire du code. Il y a plusieurs étapes impliquées. Un script indépendant de l'EDI peut être exécuté automatiquement, ce qui signifie que:

• Lorsque vous validez une modification du contrôle de version, une nouvelle version peut être lancée automatiquement par le serveur. Cela garantira que vous n'avez pas oublié de commettre quoi que ce soit nécessaire pour la construction.

• De même, une fois la construction terminée, des tests peuvent automatiquement être exécutés pour voir si quelque chose ne fonctionne pas.

• Maintenant, le reste de l’organisation (assurance qualité, administrateurs système) a un produit construit qui

  a) est parfaitement reproductible à partir de la version de contrôle.

  b) est commun à tous.

Même lorsque je travaillais en tant que personne, j’ai utilisé des scripts à cette fin; Une fois le correctif développé, je m'engageais pour SVN, exportais le SVN dans un autre répertoire et utilisais le script de construction pour générer la solution, qui passait ensuite aux systèmes de préproduction puis à la production. Si quelques semaines plus tard (avec ma base de code locale déjà changée), quelqu'un se plaignait d'un bogue, je saurais exactement quelle révision SVN je devrais passer à la caisse pour pouvoir correctement déboguer le système.

Comme le code, un script de construction est exécuté par l'ordinateur. Les ordinateurs sont exceptionnellement bons pour suivre un ensemble d'instructions. En fait, (en dehors du code à modification automatique), les ordinateurs exécuteront la même séquence d'instructions exactement de la même manière, avec la même entrée. Cela offre un niveau de cohérence auquel seul un ordinateur peut correspondre.

En revanche, les sacs à chair remplis d’eau sont carrément abominables en ce qui concerne les étapes suivantes. Ce cerveau analytique embêtant a tendance à remettre en question tout ce qui se passe. "Oh ... je n'ai pas besoin de ça", ou "Dois-je vraiment utiliser ce drapeau? Euh ... je vais juste l'ignorer." De plus, nous avons tendance à faire preuve de complaisance. Une fois que nous avons fait quelque chose à quelques reprises, nous commençons à croire que nous connaissons les instructions et que nous n'avons pas à consulter la feuille d'instructions.

De "Le programmeur pragmatique":

De plus, nous voulons assurer la cohérence et la répétabilité du projet. Les procédures manuelles laissent la cohérence pour changer; la répétabilité n'est pas garantie, en particulier si certains aspects de la procédure peuvent être interprétés par différentes personnes.

De plus, nous sommes HILARIEUSEMENT lents dans l'exécution des instructions (par rapport à un ordinateur). Sur un grand projet, avec des centaines de fichiers et de configurations, il faudrait des années pour exécuter manuellement toutes les étapes d'un processus de construction.

Je vais vous donner un exemple du monde réel. Je travaillais sur un logiciel intégré, où la majeure partie du code était partagée sur plusieurs plates-formes matérielles différentes. Chaque plate-forme avait un matériel différent, mais la plupart des logiciels étaient les mêmes. Mais il y avait des petites pièces spécifiques à chaque matériel. Idéalement, les pièces communes seraient placées dans une bibliothèque et liées à chaque version. Cependant, les éléments communs ne peuvent pas être compilés dans une bibliothèque partagée. Il devait être compilé avec chaque configuration différente.

Au début, j'ai compilé manuellement chaque configuration. Cela n'a pris que quelques secondes pour passer d'une configuration à l'autre, et ce n'était pas si pénible. Vers la fin du projet, un défaut critique a été découvert dans la partie partagée du code, un périphérique prenant essentiellement le relais du bus de communication. C'était mauvais! Vraiment mauvais. J'ai trouvé le bogue dans le code, je l'ai corrigé et j'ai recompilé chaque version. Sauf un. Pendant le processus de construction, je me suis laissé distraire et j'en ai oublié un. Les fichiers binaires ont été libérés, la machine a été construite et un jour plus tard, je reçois un appel téléphonique me disant que la machine ne répondait plus. Je vérifie et découvre qu'un appareil a verrouillé le bus. "Mais j'ai corrigé ce bug!".

Je l’ai peut-être corrigé, mais il n’a jamais trouvé sa place sur ce seul tableau. Pourquoi? Parce que je n'avais pas de processus de construction automatisé qui construisait chaque version en un clic.

Si tout ce que vous voulez faire <compiler> **/*.<extension>, c’est que les scripts de construction ne servent à rien (bien que l’on puisse dire que si vous voyez un Makefileprojet, vous savez que vous pouvez le construire make). Le problème est que - les projets non triviaux nécessitent généralement plus que cela - à tout le moins, vous aurez généralement besoin d'ajouter des bibliothèques et (à mesure que le projet mûrit) de configurer les paramètres de construction.

Les IDE sont généralement au moins configurables, mais le processus de construction s'appuie désormais sur des options spécifiques à l'IDE. Si vous utilisez Eclipse , Alice préfère NetBeans et que Bob souhaite utiliser IntelliJ IDEA , vous ne pouvez pas partager la configuration. Lorsque l'un de vous insère une modification dans le contrôle de code source, il doit soit modifier manuellement la configuration créée par l'EDI. fichiers des autres développeurs, ou en informer les autres développeurs afin qu'ils le fassent eux-mêmes (ce qui signifie qu'il y aura des commits où la configuration de l'EDI est erronée pour certains des IDE ...).

Vous devez également déterminer comment effectuer ce changement dans chacun des IDE utilisés par l'équipe, et si l'un d'eux ne prend pas en charge ce paramètre particulier ...

Maintenant, ce problème dépend de la culture - vos développeurs peuvent trouver acceptable de ne pas avoir le choix d'EDI. Mais les développeurs qui ont de l'expérience avec un IDE sont généralement plus heureux et plus efficaces lors de son utilisation, et les utilisateurs d'éditeurs de texte ont tendance à être très zélés envers leurs outils favoris. C'est donc l'un des endroits où vous voulez donner toute liberté aux développeurs. - Et construire des systèmes vous permettent de faire exactement cela. Certaines personnes peuvent avoir une préférence pour le système de construction, mais ce n'est pas aussi fanatique que les préférences IDE / éditeur ...

Même si vous obligez tous les développeurs à utiliser le même IDE - bonne chance pour convaincre le serveur de compilation de l'utiliser ...

Maintenant, c’est pour les simples personnalisations de processus de construction, que les IDE ont tendance à fournir une interface graphique agréable. Si vous voulez des choses plus complexes - comme le pré-traitement / la génération automatique de fichiers source avant la compilation - vous devrez généralement écrire un script de pré-construction dans une zone de texte de base à l'intérieur de la configuration de l'EDI. Quels systèmes de construction vous devez encore coder cette partie, mais vous pouvez le faire dans l'éditeur dans lequel vous écrivez le code, et plus important encore: le cadre du système de construction lui-même fournit généralement une aide pour organiser ces scripts.

Enfin, les systèmes de construction sont plus utiles que la construction du projet: vous pouvez les programmer pour qu'ils effectuent d'autres tâches que tous les membres de l'équipe pourraient avoir besoin d'exécuter. Dans Ruby on Rails , par exemple, il existe des tâches de système de génération permettant d'exécuter des migrations de base de données, de nettoyer les fichiers temporaires, etc. Le fait de placer ces tâches dans le système de construction garantit que tous les membres de l'équipe peuvent les exécuter de manière cohérente.

De nombreux IDE regroupent simplement les commandes utilisées pour construire quelque chose, puis génèrent un script et l'appellent!

Par exemple, dans Visual Studio, vous pouvez voir les paramètres de ligne de commande pour une compilation C ++ dans la zone "ligne de commande". Si vous regardez attentivement la sortie de la construction, vous verrez le fichier temporaire contenant le script de construction utilisé pour exécuter la compilation.

De nos jours, tout est MSBuild , mais cela reste géré directement par l'EDI.

La raison pour laquelle vous utilisez la ligne de commande est que vous allez directement à la source et que vous évitez l’intermédiaire, un intermédiaire qui a peut-être été mis à jour ou qui nécessite un tas de dépendances dont vous ne voulez tout simplement pas ou dont vous n’avez plus besoin. agit comme votre serveur d' intégration continue (CI).

De plus, vos scripts font plus que les étapes habituelles pour lesquelles ils ont été conçus. Par exemple, après une construction, vous pouvez souhaiter que vos fichiers binaires soient packagés et copiés vers un emplacement spécial, ou qu'un package d'installation soit créé, ou qu'un outil de documentation soit exécuté sur ceux-ci. De nombreuses tâches différentes sont effectuées par un serveur de CI qui sont inutiles sur une machine de développement. Par conséquent, bien que vous puissiez créer un projet IDE exécutant toutes ces étapes, vous devrez en gérer deux: un projet pour les développeurs et un autre pour les générations. Certaines tâches de construction (analyse statique, par exemple) peuvent prendre un temps que vous ne souhaiteriez pas pour des projets de développement.

En bref, c’est plus simple: créez un script pour faire tout ce que vous voulez et c’est simple et rapide de lancer cela sur la ligne de commande ou sur une configuration de serveur de construction.

make

est beaucoup plus facile à retenir et à taper 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

Et les projets peuvent avoir des commandes de compilation très complexes. Un script de construction a également la capacité de recompiler uniquement les éléments qui ont changé. Si vous voulez faire un build propre,

make clean

est plus facile et plus fiable une fois correctement configuré que d’essayer de vous souvenir de chaque endroit où un fichier intermédiaire a pu être produit.

Bien sûr, si vous utilisez un IDE, il est également facile de cliquer sur un bouton de compilation ou de nettoyage. Cependant, il est beaucoup plus difficile d’automatiser le déplacement du curseur à un endroit spécifique de l’écran, en particulier lorsque cet endroit peut se déplacer si la fenêtre se déplace, plutôt que d’automatiser une simple commande de texte.

Sinon, comment le ferais-tu? Le seul autre moyen consiste à spécifier une longue commande en ligne de commande.

Une autre raison est que les fichiers make permettent la compilation incrémentale, ce qui accélère beaucoup le temps de compilation.

Les makefiles peuvent également créer un processus de construction multi-plateforme. CMake génère différents scripts de construction basés sur la plate-forme.

Modifier:

Avec un IDE, vous êtes attaché à une manière particulière de faire les choses. Beaucoup de gens utilisent vim ou emacs même s’ils n’ont pas beaucoup de fonctionnalités de type IDE. Ils le font parce qu'ils veulent le pouvoir de ces éditeurs. Les scripts de construction sont nécessaires pour ceux qui n’utilisent pas d’EDI.

Même pour ceux qui utilisent un IDE, vous voudrez peut-être savoir vraiment ce qui se passe, alors le script de construction vous offre les détails les plus bas de l'implémentation qu'une approche avec une interface graphique n'a pas.

Les IDE eux-mêmes utilisent souvent aussi des scripts de construction internes; le bouton run est juste un autre moyen d’exécuter la commande make.

Les réponses ci-dessus couvrent beaucoup de terrain, mais un exemple concret que j'aimerais ajouter (que je ne peux pas ajouter comme commentaire faute de karma) provient de la programmation Android.

Je suis un développeur professionnel sous Android / iOS / Windows Phone et j'utilise beaucoup les API de services Google (principalement Google Maps) .

Sous Android, ces services nécessitent l’ajout d’un fichier de clés ou d’un type de fichier d’identification de développeur indiquant à Google que je suis qui je le suis, à une console de développeur. Si mon application est compilée avec un magasin de clés différent, la section Google Maps de l'application ne fonctionnera pas.

Au lieu d'ajouter et de gérer une douzaine de magasins de clés dans la console du développeur, dont un seul peut en tout cas être utilisé pour mettre à jour l'application, j'inclue ce magasin dans notre référentiel sécurisé et utilise Gradle pour indiquer à Android Studio le magasin de clés à utiliser lors de la création. "debug" ou "release". Maintenant, je n'ai plus qu'à ajouter deux magasins de clés à ma console de développeur Google, un pour "déboguer" et un pour "libérer", et tous les membres de mon équipe peuvent cloner le référentiel et se lancer dans le développement sans avoir à passer au développeur. console et ajouter le hachage SHA de leur magasin de clés particulier, ou pire, me faisant les gérer. Cela présente l'avantage supplémentaire de donner à chaque membre de l'équipe une copie du fichier de clés de signature, ce qui signifie que si je ne suis pas au bureau et qu'une mise à jour est planifiée, un membre de l'équipe doit simplement suivre une très courte liste d'instructions afin de pousser un mise à jour.

L'automatisation de construction telle que celle-ci permet de conserver des générations cohérentes et de réduire la dette technique en réduisant le temps d'installation lorsque nous obtenons un nouveau développeur, une nouvelle machine ou lorsqu'il est nécessaire de re-imaginer une machine.

Construire des avantages de script:

• les modifications ressemblent au code (par exemple, dans une commande git diff), pas à différentes options cochées dans une boîte de dialogue

• créer plus de sortie qu'une simple construction

Dans certains de mes projets précédents, j'ai utilisé les scripts de génération pour:

• générer la documentation du projet (basée sur le doxygen)
• construire
• exécuter des tests unitaires
• générer des rapports de couverture des tests unitaires
• pack binaires dans une archive de publication
• générer des notes de publication internes (basées sur les messages "git log")
• test automatisé

Vous pouvez souvent appeler le bouton "Générer" de manière automatisée (Visual Studio accepte les arguments de ligne de commande, par exemple). Les gens écrivent des scripts de génération dès qu’ils ont besoin de quelque chose que le bouton de génération ne peut pas fournir.

Par exemple, la plupart des IDE ne vous permettent de construire qu'une plate-forme à la fois. Ou seulement une langue à la fois. Ensuite, il y a ce que vous faites avec les sorties construites: votre IDE peut-elle les intégrer dans un paquet d'installation?