Ce post a été publié sur LinuxFr.org. Vous pouvez le lire là bas, ainsi que les commentaires associés

Parlons un peu de systèmes de build.

Mon métier consiste à programmer des jeux vidéos destinés aux plates-formes mobiles Android et iOS. Ce qui est commun aux deux plates-formes, c’est-à-dire la plus grosse partie de l’application, est écrit en C++, et ce qui est spécifique à la plate-forme est en Java ou en Objective-C. L’intérêt principal de tout faire en C++ est que les développeurs peuvent lancer l’application directement sur leur poste de travail, sous Linux ou OSX, et tester leurs modifs sans payer le prix d’un émulateur ou du transfert sur un appareil mobile.

L’inconvénient est que l’on se retrouve à gérer des builds sur quatre plates-formes.

Pour compiler une application pour iOS il faut nécessairement un projet Xcode, bien que les bibliothèques puissent être compilées classiquement en ligne de commande. Cela signifie qu’il faut maintenir un fichier de projet Xcode ou alors avoir un outil pour le générer.

Côté Android la compilation du code C++ se fait avec l’outil ndk-build, qui est en réalité une interface à GNU Make. Du coup les fichiers de projet sont évidemment des makefiles mais utilisant des variables et fonctions d’une sorte de framework dans le langage de Make. Là encore il faut maintenir des makefiles pour le projet, ou avoir un outil pour les générer.

Pour Linux et OSX la compilation peut se faire avec des outils plus classiques mais évidemment pas avec les fichiers de build iOS ou Android. Et encore une fois il faut maintenir ces fichiers de build.

À moins qu’on ait un outil pour les générer tous…

Quelques systèmes de build

Le problème de la gestion de la compilation d’un projet a été posé bien avant ta naissance ; c’est pour cela qu’il n’existe qu’une seule méthode pour le faire, qui fait consensus depuis des décennies.

Ha ! Ha ! Ha !

Je peux te citer déjà douze outils de tête. Voyons un peu la présentation faite sur leurs sites respectifs et essayons de rester de bonne foi.

Make

D’après le site :

GNU Make est un outil qui contrôle la génération d’exécutables et autres fichiers non-source d’un programme à partir des fichiers source du programme.

J’ai mis la description du site de GNU Make mais la première version de Make date d’avril 1976. Elle précède ainsi le projet GNU de sept ans.

Le principe de base de Make est assez simple, on lui passe un fichier Makefile qui indique « voilà le fichier que je veux créer, il dépend de ces autres fichiers, et voilà les commandes à exécuter pour le créer ». Avec le mécanisme des dépendances l’outil se débrouille pour créer les cibles dans l’ordre.

Il m’arrive encore de créer des petits Makefiles manuellement mais c’est vite pénible. Par exemple, si un binaire app est créé à partir d’un fichier a.cpp qui inclut un fichier b.hpp qui inclut lui-même un fichier c.hpp, en toute rigueur je dois lister ces trois fichiers en dépendances de la cible app pour que la compilation soit refaite quand l’un d’eux est modifié. On fait ça une fois puis on cherche un truc pour que les dépendances soient gérées automatiquement.

Un autre point difficile à gérer concerne la dépendance au fichier Makefile lui-même. Par exemple, si j’ajoute une option qui concerne l’édition des liens, celle-ci ne sera pas refaite par défaut.

Autotools

[Le premier objectif des Autotools] est de simplifier le développement de programmes portables. Le système permet au développeur de se concentrer sur l’écriture du programme, simplifiant de nombreux détails de portabilité entre systèmes Unix et même Windows, et permettant au développeur de décrire comment construire le programme via des règles simples plutôt que des Makefiles complexes.

Si vous avez déjà utilisé les autotools vous êtes probablement morts de rire en lisant ce paragraphe. Cette suite d’outils qui se présente comme simple et portable est en réalité ce qu’il y a de plus complexe en système de build et n’est portable que sur les systèmes Unix en évitant soigneusement Windows, le plus déployé des systèmes des trente dernières années.

Sans doute révolutionnaire à sa création, cet outil a extrêmement mal vieillit. Pour ma part j’ai eu l’occasion de compiler des logiciels tiers sous Windows avec ça et c’était tout simplement l’enfer. J’ai aussi tenté de l’utiliser pour mes propres projets et je me suis arrêté dans le tuto. Depuis je suis convaincu que ces outils sont faits pour les développeurs qui aiment transpirer.

SCons

SCons est un outil Open Source de construction de logiciel—plus précisément, une nouvelle génération d’outil de construction. Voyez SCons comme un substitut amélioré et multi-plateforme pour l’utilitaire Make classique avec des fonctionnalités intégrées similaires à autoconf/automake et aux caches de compilation tels que ccache. Pour faire court, SCons est un moyen plus facile, plus fiable et plus rapide de construire un logiciel.

Wow, là c’est carrément le futur.

Les fichiers SCons s’écrivent directement en Python, ce qui est assez sympa puisqu’on se retrouve avec un vrai langage et un a accès à un tas de bibliothèques pour décrire le projet.

J’ai compilé quelques projets en SCons il y a une quinzaine d’années et je crois que je n’ai jamais rien vu d’aussi lent. Et pas seulement parce que c’est du Python…

Il faut dire que le comportement par défaut de l’outil est de détecter les modifications des fichiers sources en calculant un md5 des fichiers, pour éviter de recompiler des fichiers dont seule la date a changé. Quand on voit le prix d’un md5 je trouve ce choix très discutable. Ce comportement peut être modifié via une option mais même en passant sur une comparaison de timestamps et en appliquant toutes les astuces connues pour le rendre plus rapide, ça reste hyper lent.

Premake

Un système de configuration de construction puissamment simple Décrivez votre logiciel qu’une seule fois, via la syntaxe simple et facile à lire de Premake, et construisez-le partout. Générez des fichiers de projets pour Visual Studio, GNU Make, Xcode, Code::Blocks, et plus sous Windows, Mac OS X et Linux. Utilisez l’intégralité du moteur de script Lua pour que la configuration de la construction devienne du gâteau.

Pfiou, ça claque ! Ce n’est que le quatrième dans la liste et ça promet déjà de tout résoudre

Avec Premake les scripts de builds sont écrits en Lua et, à l’instar de SCons, cela permet de « programmer » son build en profitant de tout un tas de bibliothèques.

Sur le papier c’est très sympa, en pratique ça ne marche pas trop comme attendu. Il s’avère que la syntaxe de Premake est déclarative et ne se mélange pas bien avec le procédural de Lua. Par exemple, si j’écris

project "P"

if false then
    files
    {
      "file.cpp"
    }
end

On pourrait croire que le fichier file.cpp ne fera pas partie du projet P, et bien pas du tout, le if ne change rien du tout ici. Difficile de programmer dans ces conditions.

Nous utilisons Premake depuis presque quatre ans au boulot. Le choix s’est fait en sa faveur bien que l’outil était en alpha car il permettait de générer des fichiers pour Xcode et ndk-build via deux plugins indépendants, en plus des Makefiles classiques. Aussi, il avait l’air facile à hacker ce qui était rassurant.

Maintenant j’essaye de le remplacer autant que possible.

Parmi les problèmes récurrents le plus pénible est certainement le message error: (null), sans autre info, que l’outil affiche parce qu’une erreur s’est glissée dans un script. Bonne chance pour déboguer ça. J’aime aussi beaucoup le message Type 'premake5 --help' for help qui s’affiche quand je fais une faute de frappe sur la ligne de commande. Là encore il n’y a aucune information utile et il faut se débrouiller pour trouver où on s’est trompé. Autre souci : il n’y a pas moyen de mettre des propriétés de link spécifiques à une bibliothèque. C’est embêtant quand on a besoin d’un -Wl,--whole-archive.

Le développement de Premake en lui-même a l’air très laborieux. Quatre ans après il est toujours en alpha, avec une release datant d’août 2017. Le module Xcode a été intégré mais ne gère que OSX. Il a fallu réappliquer toutes nos modifs pour iOS. Quant au module pour le NDK il ne fonctionne plus suite à des changements dans Premake (hey, c’est une alpha…). Là encore il a fallu repatcher.

Il y a de nombreux contributeurs, dont des gros, mais chacun a l’air d’aller dans sa propre direction sans qu’il y ait d’objectif commun. Il y a par exemple deux générateurs de Makefiles, gmake et gmake2 (j’attends impatiemment yagmake). Il y a des fonctionnalités qui ne marchent qu’avec Visual Studio, d’autres trucs qui fonctionnaient il y a quatre ans et qui ne fonctionnent plus. Ça m’a l’air d’être typiquement le projet qui veut tout faire parfaitement et qui au final ne fait rien de bien. Bref, le produit n’est pas à la hauteur du pitch.

CMake

CMake est une suite d’outils open source et multi-plateforme conçus pour construire, tester et empaqueter des logiciels. CMake est utilisé pour contrôler le processus de compilation du logiciel via des fichiers de configuration indépendants du compilateur et de la plate-forme, et il génère des fichiers Makefiles natifs ou des projets qui peuvent être utilisé avec l’environnement de compilation de votre choix.

CMake est tout simplement mon outil de build préféré de ces quinze dernières années.

Tout est dit.

Bon OK, j’explique. CMake lit des fichiers CMakeLists.txt qui décrivent les projets à compiler dans un langage qui lui est propre. À partir de cela il génère des fichiers Makefile ou autres (des projets Xcode ou Visual Studio par exemple) qui permettent de construire le projet.

Ce qui m’a convaincu dans cet outil est qu’il est plutôt rapide (bien qu’il ne soit pas le plus rapide) et qu’il gère parfaitement les règles de reconstruction des cibles. Par exemple, si j’ajoute un paramètre de ligne de commande pour l’édition des liens, alors l’édition des liens va être refaite. Si je modifie un fichier CMakeLists.txt et que j’exécute make sans relancer CMake, alors CMake se relance tout seul (les Makefiles ont une règle de dépendance vers les CMakeLists.txt, pas con!) Je peux aussi simplement définir les répertoires d’entêtes, options de compilation et autres paramètres spécifiques à chaque projet, en précisant s’il le paramètre doit être visible des projets dépendants ou non.

L’outil est assez bien fichu et est très populaire dans le milieu du C++.

Un des points les plus souvent reprochés à CMake est son langage, notamment à l’époque de la version 2 de l’outil qui était excessivement verbeuse et en plus en ALL CAPS. On avait l’impression de se faire crier dessus à longueur de fichier. Aujourd’hui ces soucis sont résolus et le problème semble surtout être que cela fait un langage de plus à apprendre et qui ne sert à rien d’autre (contrairement à SCons et Premake par exemple). Perso je n’y vois pas de difficulté, c’est un bête langage à macros avec des mécanismes bien pratique pour nommer des groupes de paramètres.

Comme d’habitude la qualification « indépendants du compilateur et de la plate-forme » des fichiers de configuration est très discutable dans la mesure où il y a tout ce qu’il faut pour glisser des commandes système dans le build.

Les principaux problèmes que j’ai pu rencontrer avec une version récente de CMake concernent l’export de projet. En effet il y a une commande install(EXPORTS) qui permet de créer un fichier de configuration CMake pour inclure la cible en tant que dépendance dans un projet tiers. Malheureusement cette commande exporte par défaut les chemins absolus des dépendances de la cible et il faut bricoler pour exporter les dépendances proprement (en les enrobant dans des cibles importées par exemple).

Un autre souci est que CMake génère plein de fichiers intermédiaires et qu’avec la pratique généralisée de lancer le build à la racine du projet on se retrouve à polluer toute l’arborescence. Idéalement il faudrait que l’outil refuse de faire un build in-source.

Ninja

Ninja est un petit système de construction se concentrant sur la vitesse. Il est différent des autres systèmes de construction sur deux aspects majeurs : il est conçu pour que ses fichiers d’entrées soient générés par un système de construction de plus haut niveau, et il est aussi conçu pour exécuter les builds le plus rapidement possible.

Ah cool, encore un outil qui se veut rapide, c’est exactement ce qu’il nous manquait. En plus quand on voit SCons et Premake qui se prétendent déjà les plus rapides, on a tout de suite confiance. Cela dit, contrairement à SCons et Premake, Ninja n’est pas un générateur de script de build. Il serait plutôt à comparer à Make.

Je n’ai jamais utilisé Ninja mais si jamais mes builds devenaient très lents je n’hésiterais pas à y jeter un coup d’œil. À moins que je ne passe à Meson.

Meson

Meson est un système open source de construction voulant être à la fois extrêmement rapide et, encore plus important, aussi accessible que possible.

Bon là je désespère. Encore un outil qui veut être le plus rapide et toujours pas d’outil qui prétend fonctionner correctement.

Je n’ai jamais utilisé Meson mais on m’a dit que c’est-nouveau-c’est-bien-tu-devrais-essayer.

Pourquoi pas, enfin moi je cherche surtout un truc qui me génère de quoi faire un build iOS, Android, OSX et Linux. Un truc qui juste marche quoi.

FASTbuild

FASTBuild est un système de construction open source et de haute performance supportant une haute montée en charge de la compilation, la mise en cache et la distribution sur le réseau.

Non mais franchement…

Là encore je n’ai pas utilisé cet outil. La promesse est sympa mais je ne vois pas trop l’intérêt par rapport aux deux mille autres outils du même genre.

Sharpmake

Sharpmake est un générateur de projets et solutions pour Visual Studio. Il est similaire à CMake et Premake, mais il est conçu pour être rapide et passer à l’échelle.

Celui-ci est développé par Ubisoft initialement en interne et libéré en septembre 2017. Apparemment il n’y a plus d’activité dans le dépôt depuis octobre de la même année. Comme son nom l’indique, les scripts de build sont écrits en C#.

D’après la doc il sait aussi générer des projets pour Xcode et des Makefiles. J’ai longtemps considéré l’utiliser en remplaçant de Premake mais d’une part c’est écrit en C#, donc c’est mort pour l’utiliser sous Linux, et d’autre part je sens bien que tout ce qui n’est pas Windows et Visual Studio va être bancal.

Maven

Apache Maven un outil de compréhension et de gestion de projet logiciel. Basé sur le concept de modèle d’objet de projet, Maven peut gérer la construction, le compte-rendu et la documentation d’un projet depuis un élément central d’information.

Je ne sais pas vous mais moi je comprends à peine le descriptif. C’est peut-être ma traduction qui est foireuse.

Maven est un outil du monde Java. J’ai pu l’utiliser un peu via des scripts déjà prêts et il n’y a pas grand-chose à lui reprocher de ce point de vue. Ça m’a l’air assez cool pour la gestion des dépendances.

C’est un outil qui a l’air très professionnel. Ah mais attend… c’est pour ça qu’on comprend rien au descriptif ! La première version date de 2004 et c’est donc tout naturellement que le langage le plus populaire du début du siècle a été choisi pour les scripts de build, je parle bien sûr du 🎉 XML 🎉.

Ant

Apache Ant est une bibliothèque Java et un outil en ligne de commande dons la mission est de piloter des processus décrits dans des fichiers de construction en tant que cibles et points d’extensions dépendant les uns des autres.

Là encore ça sent le professionnalisme. Les fichiers Ant sont des sortes de Makefiles mais écrits en XML. Faut-il le préciser, Ant est lui aussi un outil du monde Java.

Gradle

Accélérez la productivité des développeurs Depuis les applications mobiles aux micro-services, des petites startups aux grandes entreprises, Gradle aide les équipes à construire, automatiser et livrer de meilleurs logiciels, plus rapidement.

Je te laisse deviner à quel langage est destiné cet outil.

Gradle est l’outil de référence pour les builds des applications Android et c’est donc dans ce cadre que j’ai pu l’utiliser. Les scripts Gradle sont écrits en Groovy, un langage que je n’ai jamais utilisé par ailleurs. Perso je trouve pas ça génial mais c’est peut-être simplement parce ce que c’est loin de ce que l’on fait en C++.

Les trucs qui me fatiguent le plus avec Gradle sont d’abord le temps de compilation. La compilation du projet Java de nos jeux, une partie qui contient pourtant peu de code, prend quasiment une minute. L’autre souci est de trouver de la doc claire et facile à digérer. La doc officielle représente à peu près 24% du web^([référence nécessaire]), ce qui fait que la moindre interrogation demande déjà plusieurs heures de lectures, et les exemples de StackOverflow et divers blogs sont assez disparates.

Que choisir

Déjà douze outils et rien n’a l’air de dominer le marché :/ Sans doute faudrait-il inventer un nouvel outil pour les remplacer tous, quelque chose d’hyper rapide, évolutif, mais aussi adapté aux processes de déploiement intraprocéduraux sur concentrateur décentralisés pour les plus professionnels d’entre nous, avec des scripts dans un langage populaire, type GOTO++.

Malgré tout ce choix je n’ai rien trouvé qui résolve mon problème : générer un projet pour iOS, Android, Linux et OSX avec un seul script. Si vous avez une idée, ça m’intéresse.