Quelle est l'importance d'apprendre les makefiles? [fermé]

Je travaille en c ++ principalement comme passe-temps (je suis toujours à l'école et donc je n'ai pas de vrai travail). Les IDE génèrent le makefile pour moi et je me demande donc s'il vaut la peine d'apprendre à les créer moi-même. Par "ça vaut la peine d'apprendre", je veux dire, dois-je tout laisser tomber et apprendre à les écrire avant de continuer à apprendre le c ++? Leur apprentissage sera-t-il vraiment nécessaire? Si oui, devrais-je en savoir plus sur eux (syntaxe générale et comprendre comment ils fonctionnent, etc.) ou vraiment apprendre à les écrire?

Oui, il vaut vraiment la peine de comprendre comment fonctionnent les Makefiles. Il n'est peut-être pas pertinent pour vous en ce moment (car vous utilisez un IDE qui les génère), mais il est probable que ces connaissances seront utiles à l'avenir.

Par "ça vaut la peine d'apprendre", je veux dire, dois-je tout laisser tomber et apprendre à les écrire avant de continuer à apprendre le c ++?

Franchement, c'est une notion bizarre de "mérite d'être appris" ...

Mais non, je ne pense pas que vous ayez besoin de faire ça.

Leur apprentissage sera-t-il vraiment nécessaire?

Nous ne pouvons pas prédire si vous allez vraiment avoir besoin de ces connaissances à l'avenir. Cela dépend si vous continuez avec la programmation C ++ et dans quel contexte vous le faites.

Si oui, devrais-je en savoir plus sur eux (syntaxe générale et comprendre comment ils fonctionnent, etc.) ou vraiment apprendre à les écrire?

Je recommanderais les deux. Si vous ne pouvez pas écrire un Makefile, il est discutable que vous sachiez ce qui se passe.

Il y a l'autre point de vue qui dit que trop de connaissances ne sont pas utiles.

Si vous approfondissez cela, vous apprendrez qu'il existe de nombreuses versions différentes de Make et que l'écriture d'un Makefile compliqué qui fonctionne avec plusieurs versions de Make sur plusieurs plateformes est ... difficile. Cependant, dans le monde open source, il est «préférable» d'utiliser des outils tels que automake, autoconfet ainsi de suite pour générer les makefiles, etc. Si vous faites cela, une grande partie de la complexité liée à la version / plate-forme est traitée dans les coulisses .

Enfin, vous avez marqué la question avec "java". Mon point de vue est que vous ne devriez pas utiliser makepour créer des applications Java (sauf si vous construisez également des bibliothèques de code natives). Il existe des outils de construction spécifiques à Java qui sont beaucoup plus faciles à utiliser ... et font un meilleur travail que make.

Si vous travaillez avec des systèmes d'exploitation open source ou de type Unix, oui. Prenez courage, ils ne sont pas si compliqués. L'apprentissage vous makefera gagner beaucoup de temps à long terme.

Les Makefiles sont importants sur les systèmes UNIX (par exemple AIX, Linux, OS X). Cependant, je pense que leur importance absolue "tu dois le savoir" a diminué ces dernières années. Par exemple, vous ne les trouvez pas vraiment dans le développement Windows (Visual Studio, etc.) et XCode (sous OS X) utilise un système complètement différent. Je ne suis pas beaucoup dans Java, mais là je pense qu'ils utilisent des fichiers ant et ainsi de suite.

Il existe un système très cool appelé CMake qui génère des fichiers de construction natifs pour le système d'exploitation sur lequel vous vous trouvez. Par exemple, si vous écrivez votre spécification de projet dans CMake, vous pouvez créer un projet de génération Visual Studio sur Windows, un projet XCode sur Mac et un Makefile sur Linux. D'une certaine manière, CMake remplace autoconf et automake.

Je crée généralement des fichiers CMake pour mes "gros projets" mais je connais Make au cas où je voudrais écrire un Makefile rapide "juste faire". C'est bon pour votre culture culturelle, car il y a des tonnes et des tonnes de bibliothèques de logiciels qui utilisent Makefiles, et vous aurez inévitablement besoin de modifier les compilateurs et les emplacements de bibliothèque spécifiques. Mais vous constaterez que les gros projets (comme KDE) migrent vers CMake et autres, car Make a quelques limitations qui font la tête laide lorsque les projets se compliquent.

Je suis partial car je pense que les makefiles sont un système terrible. Vous devez apprendre la syntaxe générale pour pouvoir modifier un makefile existant. Mais je ne pense pas que tout apprendre à ce sujet ni en créer un à partir de zéro soit utile.

Comme pour de nombreux aspects de la sortie IDE, un makefile généré automatiquement est souvent structuré de manière inefficace.

Avec un niveau de compréhension approprié, il est souvent possible d'améliorer considérablement les performances (builds plus rapides, etc.). Cependant, à moins que vous ne sachiez vraiment ce qui se passe, vous êtes plus susceptible de FUBAR, lorsque vous manipulez un fichier autogène.

Je recommande fortement de pouvoir comprendre ce qui se passe ... que vous choisissiez par la suite de commencer à en éditer un existant, ou à créer le vôtre, est un problème distinct.

Le fait de pouvoir utiliser avec succès makeou quelque chose du genre vous permet de cocher la case "comprend comment modéliser les dépendances entre les parties d'un programme composé de plusieurs modules".

Apprendre à écrire des Makefiles est une bonne idée pour plusieurs raisons.

1. Make est un langage qui vous permet d'encoder les dépendances entre les composants via des règles. Vous aurez beaucoup d'expérience avec l'écriture de code de cette façon, et cela élargit vos outils pour réfléchir à la résolution de problèmes de programmation.
2. Les principes que vous apprenez avec Make peuvent être utilisés avec Ant, Maven et Rake si vous choisissez d'apprendre la programmation dans le monde Java ou Ruby.
3. De nombreux IDE ont des fichiers magiques qui contiennent des informations de configuration pour vous aider à créer votre logiciel. Si vous ne me croyez pas, essayez d'écrire un script pour construire votre logiciel sans l'IDE. Lorsque vous écrivez vos propres Makefiles, vous devenez très conscient des dépendances entre votre code, vos bibliothèques et vos variables d'environnement. À mesure que les systèmes s'agrandissent, cela s'avère être un outil utile pour déboguer votre système.

Vous devez toujours essayer de comprendre le système de build que vous utilisez.

Cela ne signifie pas nécessairement que vous devez être en mesure de créer tous les fichiers de construction à la main. La partie importante est de comprendre ce que le système de construction fait pour votre projet et la capacité générale de compiler manuellement de petits projets (comme dans "taper des commandes sur un terminal").

J'ai juste tendance à penser que la création (simple) de Makefiles est l'étape la plus simple pour comprendre ce qui se passe, mais vous pourriez avoir d'autres moyens de comprendre comment construire des choses.

Pourquoi / quand apprendre les Makefiles

Si vous continuez à programmer pour Windows uniquement et ne vous attendez pas à ce que quelqu'un d'autre compile votre code, n'hésitez pas à compiler le code comme vous le souhaitez.

Si vous voulez programmer le compilateur agnostique (comme dans "laissez les autres décider quel compilateur ou IDE ils veulent utiliser"), alors vous devriez apprendre un autre système de construction que de laisser votre IDE "s'en occuper".

Si vous souhaitez programmer pour différentes plates-formes, vous devez certainement utiliser un système de construction répandu.

Cela ne signifie toujours pas que vous devez savoir en détail comment les Makefiles générés automatiquement. Il vous suffit de savoir comment fonctionnent les fichiers d'entrée pour le système de génération. Ceux-ci se trouvent parfois avoir une syntaxe similaire.

Personnellement, j'aime vraiment les Makefiles et je les utilise pour beaucoup de choses. Pas seulement la compilation de code. Je crée un Makefile pour chaque pdf plus grand que je crée (avec LaTeX) et pour chaque projet dont j'ai besoin pour automatiser quelques tâches (construction, empaquetage, téléchargement, mise à jour des dépendances à partir des référentiels sources, sauvegardes manuelles pull / push)

Cependant, je travaille beaucoup sur le terminal et je travaille avec Linux. Je n'utilise pas ce que vous appelleriez un IDE autre que vim (puissant éditeur de texte) et les outils de console. Cela pourrait être très différent pour vous.

Si vous vous êtes déjà plaint de devoir exécuter différentes commandes de ré-occurrence juste pour "mettre à jour" / package / upload / .. un "projet", alors apprendre à écrire des Makefiles pourrait vous être utile.

Si vous avez et utilisez des outils / GUI / IDE pour tout, alors vous pourriez ne rien tirer de cette connaissance.