Qu’est-ce qu’un outil de construction?

Depuis 4 ans, je programme avec Eclipse (pour Java) et Visual Studio Express (pour C #). Les IDE mentionnés semblaient toujours fournir toutes les facilités qu’un programmeur pouvait demander (liées à la programmation, bien sûr).

Dernièrement, j’ai entendu parler de quelque chose appelé “outils de construction”. J’ai entendu dire qu’ils étaient utilisés dans presque toutes les formes de développement du monde réel. Qu’est-ce qu’ils sont exactement? Quels problèmes sont-ils conçus pour résoudre? Comment se fait-il que je n’en ai jamais eu besoin au cours des quatre dernières années? Sont-ils des types d’IDE dépouillés en ligne de commande?

Quels sont les outils de construction?

Les outils de construction sont des programmes qui automatisent la création d’applications exécutables à partir du code source (par exemple .apk pour une application Android). La construction intègre la compilation, la liaison et l’emballage du code sous une forme utilisable ou exécutable.

Fondamentalement, l’automatisation de la construction consiste à créer des scripts ou à automatiser une grande variété de tâches que les développeurs de logiciels effectuent dans leurs activités quotidiennes, telles que:

  1. Téléchargement des dépendances
  2. Comstackr le code source en code binary.
  3. Empaquetant ce code binary.
  4. Tests en cours
  5. Déploiement sur des systèmes de production.

Pourquoi utilisons-nous des outils de construction ou d’automatisation de la construction?

Dans les petits projets, les développeurs invoquent souvent manuellement le processus de génération. Ce n’est pas pratique pour les grands projets, où il est très difficile de suivre ce qui doit être construit, dans quel ordre et quelles dépendances dans le processus de construction. L’utilisation d’un outil d’automatisation permet au processus de génération d’être plus cohérent.

Divers outils de construction disponibles (nommer seulement quelques-uns):

  1. Pour java – Ant, Maven, Gradle.
  2. Pour le framework .NET – NAnt
  3. c # – MsBuild.

Pour plus d’informations, vous pouvez vous référer aux liens suivants:

1. Construire l’automatisation

2. Liste des logiciels d’automatisation de la construction

Merci.

Les outils de construction sont des outils pour gérer et organiser vos builds et sont très importants dans les environnements où il existe de nombreux projets, en particulier s’ils sont interconnectés. Ils servent à faire en sorte que lorsque différentes personnes travaillent sur divers projets, elles ne cassent rien. Et pour vous assurer que lorsque vous effectuez vos modifications, elles ne cassent rien non plus.

La raison pour laquelle vous n’en avez pas entendu parler auparavant est que vous ne travailliez pas dans un environnement commercial auparavant. Il y a beaucoup de choses que vous n’avez probablement pas rencontrées dans un environnement commercial, surtout si vous travaillez dans des sociétés de logiciels.

Comme d’autres l’ont dit, vous les utilisez, mais vous n’avez pas eu à les prendre en considération, car vous avez probablement travaillé différemment à la manière habituelle de travailler dans le commerce.

Les outils de génération sont généralement exécutés sur la ligne de commande, à l’intérieur d’un environnement de développement intégré ou complètement séparés.

L’idée est de séparer le travail de compilation et de conditionnement de votre code de la création, du débogage, etc.

Un outil de construction peut être exécuté sur la commande ou dans un IDE, tous deux déclenchés par vous. Ils peuvent également être utilisés par des outils d’continuous integration après vérification de votre code à partir d’un référentiel et sur une machine propre.

make était un outil de commande utilisé dans les environnements * nix pour la construction de C / C ++.

En tant que développeur Java, les outils de construction les plus populaires sont Ant et Maven. Les deux peuvent être exécutés dans des IDE comme IntelliJ ou Eclipse ou NetBeans. Ils peuvent également être utilisés par des outils d’continuous integration tels que Cruise Control ou Hudson.

Les outils de construction consistent généralement à transformer le code source en fichiers binarys: ils organisent le code source, définissent les indicateurs de compilation, gèrent les dépendances… Certains s’intègrent également au test unitaire en cours, à l’parsing statique et à la génération de documentation.

Eclipse ou Visual Studio sont également des systèmes de construction (mais plus d’un IDE), et pour Visual Studio, c’est le msbuild sous-jacent permettant d’parsingr des fichiers de projets visuels en studio sous le capot.

L’origine de tous les systèmes de construction semble être le fameux «make».

Il existe des systèmes de construction pour différentes langues:

  1. C ++: make, cmake, premake
  2. Java: ant + lierre, maven, gradle
  3. C #: msbuild

Généralement, créez des systèmes en utilisant un langage spécifique au domaine (make, cmake) ou xml (ant, maven, msbuild) pour spécifier une génération. La tendance actuelle est d’utiliser un vrai langage de script pour écrire des scripts de construction, comme lua pour premake, et groovy pour gradle. L’avantage de l’utilisation d’un script est qu’il est beaucoup plus flexible et permet API (en tant que build DSL).

Processus de construction est un processus de compilation de votre code source pour toutes les erreurs à l’aide de certains outils de génération et de création de versions (qui sont des versions exécutables du projet). Nous (principalement les développeurs) effectuons des modifications dans le code source et archivons ce code pour que le processus de génération se produise. Après le processus de construction, il donne deux résultats: 1. Construisez PASSES et vous obtenez une version exécutable de votre projet (Build est prêt). 2. Il échoue et vous obtenez certaines erreurs et la génération n’est pas créée.

Il existe différents types de processus de construction tels que: 1. Build Nightly 2. Gated Build 3. Intégration continue, etc.

Les outils de création aident et automatisent le processus de création de builds.

* Donc, en version abrégée, le développeur ou l’équipe de développement utilise une version du logiciel en format pré-version pour gagner en confiance quant au résultat final de son produit en surveillant continuellement son produit et en résolvant les problèmes au début du processus de développement. *

Ce sont différents types de processus par lesquels vous pouvez faire vos builds.

1. Intégration continue build: Dans cette principalement les développeurs archivent leur code et juste après leur check-in un build initie pour la construction des modifications récentes afin que nous devions savoir si les modifications apscopes par le développeur ont fonctionné ou pas juste après le contrôle -in est fait. Ceci est préférable pour les petits projets ou les composants des projets. Dans le cas où plusieurs équipes sont associées au projet ou qu’il y a un grand nombre des développeurs travaillant sur le même projet, ce scénario devient difficile à gérer comme s’il n’y avait pas de de check-in et de build échoue à certains moments, il devient très difficile de savoir si toute la rupture est due à un problème ou à plusieurs problèmes. Par conséquent, si les anciens problèmes ne sont pas traités correctement, défauts survenus après ce changement. Le principal avantage de ces builds est de savoir si un enregistrement particulier est réussi ou non.

2. Génération d’archive sécurisée: Dans ce type de vérification, une génération est lancée immédiatement après la fin de l’archivage, en conservant les modifications dans les ensembles de grids. Dans ce cas, si la génération réussit, l’archivage du jeu de clés est validé, sinon il ne sera pas validé sur Team Foundation Server. Cela donne une image légèrement meilleure de la construction d’continuous integration car seuls les enregistrements réussis sont autorisés à être validés.

3. Constructions nocturnes: ceci est également appelé constructions planifiées. Dans ce cas, nous planifions les builds pour une durée spécifique afin de générer les modifications. Toutes les modifications non validées précédentes de la dernière version sont générées pendant ce processus de génération. Ceci est pratiqué lorsque nous voulons vérifier plusieurs fois, mais nous ne voulons pas une construction à chaque fois que nous archivons notre code afin que nous puissions avoir une période ou une période fixe pour lancer la construction du code archivé.

Vous trouverez plus de détails sur ces versions à l’emplacement ci-dessous.

Gated-check dans les builds

Intégration continue

Construit tous les soirs

Vous les avez utilisés – IDE est un outil de construction. Pour la ligne de commande, vous pouvez utiliser des choses comme make .

Les gens utilisent des outils de ligne de commande pour des choses comme une construction nocturne – donc le matin, avec une gueule de bois, le programmeur a réalisé que le code qu’il manipulait avec les dernières versions des bibliothèques ne fonctionnait pas!

“… il est très difficile de garder une trace de ce qui doit être construit” – Construire des outils n’aide pas à tout ça. Vous devez savoir ce que vous voulez construire. (Extrait de la réponse de Ritesh Gun)

“J’ai entendu dire qu’ils étaient utilisés dans presque toutes les formes de développement réel” – Pour une raison quelconque, les développeurs de logiciels aiment travailler dans de grandes entresockets. Ils semblent avoir des directives de travail moins claires pour chaque personne qui y travaille.

“Comment se fait-il que je n’en ai jamais eu besoin au cours des quatre dernières années”. Probablement parce que vous êtes un programmeur qualifié.

Pseudo, meta. Je pense que les outils de construction ne fournissent aucun avantage réel. Il est juste là pour append un sentiment de sécurité découlant des mauvaises pratiques de l’entreprise, du manque d’orientation – un mauvais leadership dans l’architecture des logiciels menant à une mauvaise connaissance du projet. Vous ne devriez jamais avoir à utiliser des outils de construction (pour tester) dans votre projet. Faire des tests aléatoires avec un manque de connaissance du projet logiciel ne donne aucune aide.

Vous ne devriez jamais append quelque chose à un projet sans connaître son objective et comment il fonctionnera avec les autres composants. Les composants peuvent être fonctionnels séparés, mais ne pas fonctionner ensemble. (C’est la responsabilité de l’architecte logiciel que je suppose).

Que se passe-t-il si 4 à 5 composants sont ajoutés au projet? Vous ajoutez un 6ème composant. Avec le premier composant ajouté, il pourrait tout gâcher. Aucun automatique ne permettrait de détecter cela.

Il n’y a pas de raccourci autre que penser penser penser.

Ensuite, il y a le téléchargement automatique à partir des référentiels. Pourquoi voudriez-vous jamais faire ça? Vous devez savoir ce que vous téléchargez, ce que vous ajoutez au projet. Comment détecter les changements dans les versions des référentiels? Tu dois savoir. Vous ne pouvez rien “auto”.

Et si nous devions tester les bicyclettes et les transports de bébé avec les yeux bandés avec un bâton et les contourner au hasard. Cela semble être l’idée du test des outils de construction.

Je suis désolé, il n’y a pas de raccourci https://en.wikipedia.org/wiki/Scientific_method et https://en.wikipedia.org/wiki/Analysis