Le système de contrôle de version Git a été introduit pour la première fois le 7 avril 2005 par Linus Torvalds, le créateur du noyau Linux. À l'occasion du 20e anniversaire de ce projet majeur, désormais adopté par la quasi-majorité des équipes de développement, nous nous sommes entretenus avec Linus sur l'histoire de Git. Nous lui avons notamment demandé pourquoi il en a délégué la maintenance et quelles sont les étapes clés du projet qu'il considère comme les plus importantes.
En 2005, vous étiez déjà le chargé de maintenance du noyau Linux, qui était alors en plein essor. Pourquoi avez-vous décidé de créer un nouveau système de contrôle de version ?
Je me suis lancé dans cette aventure précisément parce que je détestais profondément les outils de contrôle de version existants.
J'avais utilisé des systèmes de contrôle de version traditionnels (CVS/RCS/SCCS) à la fois en tant qu'utilisateur final (pour suivre des projets open source comme GCC) et en tant que développeur (quand je travaillais chez Transmeta, nous utilisions exclusivement CVS) et j'en avais une aversion profonde.
À l'époque, la plupart des projets qui utilisaient CVS étaient passés à SVN, mais en vérité, j'ai toujours pensé que SVN n'était qu'une pâle copie de CVS malgré les quelques améliorations apportées à l'interface utilisateur ; aucun des défauts fondamentaux n'avaient été corrigés et de nouveaux problèmes étaient même apparus.
Impossible d'énumérer ici tous les problèmes rencontrés avec CVS et les autres systèmes du même type. Ils sont de toute façon devenus obsolètes. Les développeurs les plus jeunes n'ont même probablement jamais eu à les utiliser. J'ai toujours refusé de m'en servir pour le noyau Linux, même si quelques sous-systèmes (notamment le côté mise en réseau) utilisaient CVS pour gérer leur code dans les années 1990.
À l'époque, je vivais dans la région de la baie de San Francisco, et Larry McVoy, qui était à l'origine notamment du projet lmbench, avait lancé la société BitMover, qui proposait un nouveau modèle de contrôle de version appelé BitKeeper (BK).
BK n'était pas open source, mais Larry appréciait les projets open source et pensait que l'absence d'un système de contrôle de version pertinent freinait le développement du noyau Linux. Il n'avait pas tort, mais les systèmes de gestion du code source (SCM) traditionnels ne me convenaient absolument pas. Larry a pris le temps de nous montrer, à David Miller (chargé de maintenance réseau et utilisateur de CVS) et à moi, les avantages de BitKeeper.
BK n'était pas parfait. Il s'appuyait sur Source Code Control System (SCCS) comme tant d'autres SCM traditionnels et souffrait donc du même modèle restrictif d'« historique par fichier », qui pose un réel problème, notamment lors du renommage et de la suppression de fichiers.
BK présentait tout de même quelques avantages. Même s'il utilisait SCCS de base, il corrigeait des problèmes vraiment essentiels et gérait le développement distribué convenablement. Il offrait par ailleurs un véritable historique global (et non par fichier). Par conséquent, le merge de code provenant de différents arbres fonctionnait réellement.
Avec CVS, créer une branche et la fusionner était un événement majeur que vous deviez planifier et discuter en équipe. Avec BK, chaque dépôt correspondait à une branche. C'est une pratique courante à présent. Bien évidemment, Git l'a encore améliorée en proposant plusieurs branches par dépôt, mais même le modèle BK beaucoup plus limité représentait déjà une avancée majeure à l'époque.
Encore une fois, BK n'était pas parfait. Son modèle basé sur un historique par fichier posait de réels problèmes, car les opérations de renommage et de merge de fichiers n'étaient tout simplement pas fiables, entraînant inévitablement des dysfonctionnements comparables à ceux rencontrés avec Attic pour les utilisateurs de CVS. Par ailleurs, BK manquait de robustesse en matière d’évolutivité, des limites qui ne devenaient toutefois réellement problématiques qu’à mesure que le projet gagnait en ampleur ou en complexité.
Mais la nécessité d'acquérir une licence pour pouvoir l'utiliser constituait un véritable obstacle. Bien que de nombreux chargés de maintenance du noyau avaient fini par l'adopter (nous l'avons d'ailleurs utilisé de 2002 à 2005), cette contrainte restait une source de frictions qui a atteint son paroxysme fin 2004, rendant l'utilisation de BK pour le développement du noyau intenable quelques mois plus tard.
Ainsi, pendant trois ans, j'ai enfin pu utiliser un contrôle de version qui fonctionnait et qui m'aidait à résoudre de nombreux problèmes. Je ne pouvais plus me passer d'un système de contrôle de version. Entretemps, aucun outil open source plus performant n’avait vu le jour au sein de la communauté open source.
Bien sûr, il était de notoriété publique que CVS et SVN ne fonctionnaient pas bien. Certaines équipes ont même tenté d'autres approches, parfois encore pires (comme un suivi de correctifs sophistiqué) ; d'autres ont eu de bonnes idées, mais qui aboutissaient pourtant à de nouvelles erreurs de conception (comme Monotone).
Après un certain temps et des recherches infructueuses, j'ai finalement décidé de créer mon propre système.
Techniquement, il ne m'a fallu que quelques jours pour créer la première version de Git, comme le prouve l'historique des commits. Dès que celle-ci a atteint un niveau de fonctionnalité suffisant, j'ai pu commencer à appliquer les correctifs proposés par d'autres contributeurs. Quelques jours plus tard, ma version était activement utilisée pour le développement du noyau.
Mais cette rapidité apparente cache un travail préparatoire de plusieurs mois de réflexion. Écrire du code est relativement facile. Le plus important, c'est la conception initiale. L'historique des commits que j'évoquais plus tôt ne montre pas tout le travail de fond effectué en amont.
Et pour être honnête, cette première version était ultra rudimentaire et relativement basique par rapport aux nombreuses fonctionnalités que Git propose aujourd'hui. Mais elle incluait déjà les éléments clés de la structure fondamentale de Git.
Pouvez-vous nous donner un bref aperçu des débuts du projet Git ?
En somme, j'avais décidé de suspendre le développement du noyau tant que je n'aurais pas d'alternative qui me convenait : un système distribué, performant et capable de garantir la détection de toute corruption de fichiers.
Je tiens cependant à souligner que je n'étais pas intéressé par les SCM en tant que tels. Ce qui m'importait, c'était le résultat final, pas le processus. Pour moi, Git n'avait pas le même intérêt que le noyau Linux : j'utilise Linux parce que je trouve que le fonctionnement des noyaux est fascinant, mais j'ai créé Git par obligation, pas par passion.
D'où le fait que j'en ai délégué la maintenance.
Pourquoi avez-vous confié la maintenance de Git à Junio Hamano après quelques mois ? Pourquoi avez-vous choisi Junio ?
Transmettre la maintenance de Git était un choix évident. Je savais dès le départ que je me concentrerais de nouveau uniquement sur le noyau dès que j'aurais trouvé une personne de confiance à qui déléguer la maintenance.
Cela ne signifie pas pour autant que j'ai tout laissé tomber en priant pour que tout se passe bien. J'ai assuré la maintenance de Git pendant environ quatre mois, car je sentais que je devais trouver la perle rare qui s'investirait sur le long terme.
Junio a été l'une des toutes premières personnes impliquées dans ce projet, dès la première semaine de développement. Mais je ne lui ai pas attribué ce rôle dès le départ. Il m'a fallu un certain temps pour voir qui restait, qui écrivait du code pertinent et qui prenait des décisions stratégiques.
Junio s'est montré exceptionnel. On me donne bien trop de crédit pour les quelques mois que j’ai passés sur Git, notamment pour la célébration du 20e anniversaire de l’existence du projet. Je revendique avoir optimisé la conception centrale et lancé le projet, mais c'est vraiment grâce à Junio (et à des centaines d’autres contributeurs) que Git est ce qu’il est aujourd’hui.
La version initiale du système de contrôle de version Mercurial est sortie seulement 12 jours après la version initiale de Git, le 19 avril 2005. Beaucoup prétendent que l'expérience utilisateur de Mercurial était supérieure à celle de Git, mais de nos jours, Git est nettement plus populaire. Pour quelles raisons d'après vous ?
C'est en grande partie dû aux effets de réseau des SCM qui ont permis à CVS de survivre aussi longtemps malgré ses limites.
Le fait que le noyau Linux utilise Git a joué un rôle majeur. Plus tard, la communauté Ruby on Rails a largement contribué à sa popularité, avant que l'utilisation de Git ne se généralise dans toutes les communautés de développeurs.
Mais je pense aussi que la conception de Git est fondamentalement supérieure. Son architecture est à la fois très simple et extrêmement puissante, ce qui, selon moi, a facilité son adaptation à d'autres environnements, comme JGit et des implémentations plus récentes telles que le système de fichiers virtuel MSgit, et bien d'autres encore.
Bien que Git avait la réputation d’être un outil difficile à prendre en main, les utilisateurs habitués à d'autres systèmes SCM le trouvaient contre-intuitif. Cette complexité provenait en partie du fait que Git avait adopté certains choix audacieux que jamais un utilisateur habitué aux systèmes traditionnels n'aurait osé faire.
Le projet Git a toujours été actif depuis que vous en avez confié la maintenance à Junio, et sa communauté développe en permanence de nouvelles fonctionnalités. Selon vous, quelles ont été les étapes clés depuis que vous avez quitté le projet ?
Difficile pour moi de répondre à cette question. J'ai évidemment tout fait pour que Git convienne à mes propres besoins. Les fonctionnalités que j'utilisais moi-même étaient opérationnelles dès le premier jour. Faire en sorte que Git fonctionne sur Windows était évidemment une étape importante pour beaucoup de développeurs, mais cela n'a eu absolument aucun impact sur moi ;)
Il est évident que Git possède toute l'infrastructure nécessaire pour le rendre beaucoup plus facile à utiliser, mais je pense que les étapes majeures ont surtout concerné les projets construits autour de l'infrastructure Git. Ces développements sont par la suite souvent intégrés aux fonctionnalités de Git, mais, en réalité, les étapes clés sont souvent liées à des projets externes.
Par exemple, les grandes plateformes d'hébergement Git ont constitué des étapes importantes. Le modèle distribué de Git a grandement facilité leur création, mais la véritable étape a été la façon dont elles ont rendu Git tellement plus accessible et pratique pour les utilisateurs et les équipes travaillant sur divers projets.
Si vous aviez la possibilité de travailler à nouveau sur Git à plein temps, qu'aimeriez-vous implémenter ?
Absolument rien. Git me convenait parfaitement dès le début. Mon utilisation est en fait assez limitée et je ne m'intéresse vraiment qu'à un seul projet.
Comme je l'ai expliqué précédemment, je n'ai jamais vraiment été passionné par les SCM. Git a fini par se différencier positivement des autres SCM, car je l'ai traité comme un système de fichiers distribué basé sur les logs, et non comme un SCM traditionnel.
Y a-t-il une fonctionnalité ou une décision de conception dans Git que vous regrettez avec le recul ?
Des décisions de conception ? Non. Je suis convaincu que la conception globale est excellente, et vous pouvez discuter des concepts fondamentaux de Git sans jamais vous perdre dans les détails complexes de son implémentation.
Il est essentiel dans un projet d'avoir un certain nombre de principes de conception générale pour guider sa direction conceptuelle.
Les gens pensent parfois que l'étape de mise en œuvre doit suivre aveuglément les principes fondamentaux de la conception générale. Et c'est faux. La mise en œuvre aura son lot de cas particuliers compliqués parce les utilisateurs ont des besoins parfois étranges. L'essentiel est de définir une conception générale claire qui servira de référence au projet et à laquelle vous pourrez réfléchir avant de vous confronter à la réalité.
Et je pense que Git offre un équilibre parfait avec un système basique de stockage d'objets (que les experts en contrôle de version appellent « arbres de Merkle structurés » et que les spécialistes des systèmes de fichiers appellent « stockage avec adressage par contenu »). Cette conception centrale est très simple, mais elle ne représente en réalité qu'une infime partie de la totalité du code du projet. La majeure partie du code de Git concerne en effet toutes les opérations et fonctionnalités que l'on peut construire autour de ce modèle central. Malgré cela, cette simplicité et cette clarté fondamentales offrent au projet une structure d'ensemble solide, compréhensible et cohérente.
C'est une structure semblable à celle d'Unix dont le principe est que « tout est un fichier » ou à sa gestion de processus. Ces « concepts » guident la conception, mais 99 % du code a pour objectif de créer des fonctionnalités utiles pour des utilisations concrètes.
J'ai deux mantras en technologie : « Si j'ai pu voir aussi loin, c'est parce que j'étais juché sur les épaules de géants » (Newton) et « Le génie, c'est 1 % d'inspiration et 99 % de transpiration » (Edison).
Bien que je sois très satisfait des grandes lignes de la conception, avec le recul, si je devais développer Git aujourd'hui, je changerais certains détails.
Mais honnêtement, ce sont des détails mineurs comparés à toutes les fonctionnalités de qualité qui ont été créées par la communauté au cours des deux dernières décennies.
Le noyau Linux a commencé à utiliser Rust comme langage de programmation pour certains de ses sous-systèmes. Pensez-vous qu'il soit logique de commencer à utiliser des langages de programmation aussi récents que celui-ci dans Git ?
En ce qui concerne Git, mélanger les langages n'est pas une bonne idée, car cela reste toujours un processus complexe.
Dans le noyau Linux, le résultat final est un binaire unique, même si une grande partie peut être chargée dynamiquement sous forme de modules.
Et cela rend plus difficile l'utilisation de plusieurs langages. En revanche, le noyau doit prendre en compte la sécurité de la mémoire et, par conséquent, envisager d'utiliser des langages plus récents.
Si un développeur veut écrire certaines parties de Git en Rust ou dans un autre langage, il est beaucoup plus logique d'opter pour une mise en œuvre séparée plutôt que de mélanger les différents langages dans un seul binaire.
La conception du noyau Git est suffisamment simple pour autoriser des implémentations parallèles. Vous pouvez ensuite cibler des cas spécifiques pour lesquels l'utilisation d'un langage différent fait sens.
JGit en est un parfait exemple. L'utilisation d'un autre langage était motivée par la présence d'un environnement web différent pour lequel ce choix de langage était beaucoup plus naturel.
Il existe déjà des implémentations de certaines fonctionnalités Git de base en Rust qui font sens dans des contextes spécifiques, mais je doute que cela justifie une approche globale du type « convertissons tout en Rust ».
Je recommande aux équipes qui souhaitent travailler avec Rust de cibler des domaines où ses avantages sont plus évidents. Je ne pense pas que C ait été si problématique dans le code source standard de Git.
De nouveaux systèmes de contrôle de version voient le jour tous les deux ou trois ans. Pensez-vous que Git restera pertinent à l'avenir ?
J'ai déjà mentionné les effets de réseau dans les SCM. Selon moi, seul un système bien meilleur que Git sera en mesure de le remplacer. Ou alors il sera tellement compatible qu'il s'agira tout simplement d'une nouvelle implémentation de Git.
De plus, la situation des SCM a beaucoup évolué : Git n'a pas les énormes failles fondamentales des SCM qui l'ont précédé. Il est donc assez difficile de le surpasser.
Je m'attends donc à ce que Git reste pertinent à l'avenir : les développeurs travailleront sur des améliorations autour de Git plutôt que de le remplacer par de nouveaux systèmes.
Remarque : cet entretien a été édité pour en raccourcir la longueur et améliorer la clarté.
En savoir plus sur Git
- Nouveautés de Git 2.49.0
- Nouveautés de Git 2.48.0
- Format « reftable » de Git : guide pour les débutants
- Commits Git : comment et pourquoi maintenir un historique propre
- Git fetch vs git pull : quelle est la différence entre ces deux commandes Git ?
- Git en ligne de commande sous Windows avec Git Bash
- Améliorez votre workflow avec Git rebase
- Projet Git
