🔝 Retour au Sommaire

Félicitations ! Vous avez parcouru un long chemin. Vous savez maintenant créer des commits, gérer des branches, résoudre des conflits, et collaborer avec votre équipe via des dépôts distants. Vous maîtrisez les bases techniques de Git.

Mais connaître les commandes ne suffit pas. Tout comme savoir conduire une voiture ne fait pas de vous un bon conducteur, connaître Git ne fait pas automatiquement de vous un bon utilisateur de Git.

Ce module est différent des précédents. Au lieu de vous apprendre de nouvelles commandes, nous allons vous montrer comment bien utiliser celles que vous connaissez déjà. C'est le module de la maturité Git : celui qui transforme un utilisateur débutant en professionnel.

Imaginez deux cuisines :

Cuisine A :

• Ustensiles rangés n'importe où
• Ingrédients sans étiquettes
• Recettes griffonnées sur des bouts de papier
• Chacun fait à sa manière

Cuisine B :

• Chaque chose à sa place
• Étiquettes claires et dates de péremption
• Recettes standardisées et documentées
• Protocoles partagés par toute l'équipe

Dans quelle cuisine préféreriez-vous travailler ? Dans laquelle seriez-vous le plus efficace ?

C'est exactement la même chose avec Git. Les bonnes pratiques sont les recettes qui permettent à toute l'équipe de travailler ensemble de manière fluide et productive.

Git n'est pas qu'un outil technique, c'est un outil de communication. Chaque commit, chaque branche, chaque Pull Request raconte une histoire :

• Qu'est-ce qui a été fait ?
• Pourquoi ?
• Quel était le contexte ?

De bonnes pratiques garantissent que cette histoire est claire, compréhensible et utile à tous, aujourd'hui et dans 6 mois.

Quand une seule personne travaille sur un projet, les règles importent peu. Mais dès qu'on est plusieurs :

• Comment éviter de se marcher dessus ?
• Comment coordonner le travail ?
• Comment s'assurer que chacun comprend ce que font les autres ?

Les workflows et conventions partagées répondent à ces questions.

Le code d'aujourd'hui est le legacy de demain. Dans 6 mois, 1 an, 5 ans, quelqu'un (peut-être vous !) devra :

• Comprendre pourquoi tel changement a été fait
• Retrouver quand un bug a été introduit
• Revenir à une version stable
• Corriger rapidement un problème critique

Un historique propre et bien organisé est votre meilleure assurance pour l'avenir.

Les bonnes pratiques Git ne sont pas isolées. Elles font partie d'un ensemble plus large qui inclut :

• Revue de code
• Tests automatisés
• Intégration continue
• Documentation

Ensemble, ces pratiques forment un filet de sécurité qui maintient la qualité du projet au fil du temps.

Ce module couvre sept aspects fondamentaux des bonnes pratiques Git :

Vos commits sont votre documentation vivante. Vous apprendrez à :

• Structurer un message de commit
• Utiliser les conventions (Conventional Commits)
• Communiquer efficacement le "pourquoi" et le "quoi"

Impact : Un historique lisible et utile pour toute l'équipe.

Un commit = une idée. Vous apprendrez à :

• Découper votre travail en commits logiques
• Utiliser la staging area intelligemment
• Organiser vos modifications de manière cohérente

Impact : Un historique propre, facile à naviguer et à déboguer.

Gardez votre dépôt propre. Vous apprendrez à :

• Configurer efficacement .gitignore
• Gérer les fins de lignes avec .gitattributes
• Optimiser votre dépôt pour votre stack technique

Impact : Un dépôt sans pollution, adapté à votre environnement.

Comment travailler en équipe ? Vous découvrirez :

• Git Flow : structuré et robuste
• GitHub Flow : simple et moderne
• Trunk-Based Development : rapide et agile

Impact : Une collaboration fluide avec des processus clairs.

Structure et clarté. Vous apprendrez à :

• Nommer vos branches de manière cohérente
• Organiser les branches par type (feature/, bugfix/, hotfix/)
• Établir des conventions d'équipe

Impact : Navigation facile et compréhension immédiate du projet.

La qualité par la collaboration. Vous maîtriserez :

• Comment créer une bonne Pull Request
• Comment faire une revue de code constructive
• Les stratégies de merge (squash, rebase, merge commit)

Impact : Code de meilleure qualité et partage des connaissances.

Communiquer l'évolution de votre projet. Vous découvrirez :

• Le format MAJOR.MINOR.PATCH
• Comment et quand incrémenter les versions
• Gérer les tags Git et les releases

Impact : Communication claire avec les utilisateurs de votre projet.

Ce module suit une logique d'échelle :

Individuel          →        Équipe         →        Projet
    ↓                          ↓                       ↓
  Commits                   Branches                Release
 Messages                   Workflows                Versions
Organisation                 PR/Reviews

Nous commençons par les pratiques individuelles (messages de commit, commits atomiques), puis nous élargissons aux pratiques d'équipe (workflows, branches, revues), pour finir par les pratiques projet (versionnement).

Ce module suppose que vous maîtrisez :

• ✅ Les commandes Git de base (add, commit, push, pull)
• ✅ La gestion des branches (checkout, merge, rebase)
• ✅ La résolution de conflits
• ✅ Le travail avec des dépôts distants
• ✅ Les concepts de staging area et d'historique

Si ce n'est pas le cas, revisitez les modules précédents.

Les bonnes pratiques ne sont pas des règles rigides gravées dans le marbre. Ce sont des guides éprouvés qui ont fait leurs preuves dans de nombreux projets.

Points importants :

• 🎯 Adaptez : Chaque projet, chaque équipe est unique
• 🧠 Comprenez : Sachez pourquoi une pratique existe
• 💪 Pratiquez : Les bonnes habitudes se construisent avec le temps
• 🤝 Discutez : Les meilleures pratiques émergent du dialogue en équipe
• 📈 Itérez : Améliorez continuellement vos processus

Attention : Ne tombez pas dans le piège de vouloir tout appliquer parfaitement dès le premier jour.

✅ Approche recommandée :

1. Commencez par 1-2 pratiques
2. Appliquez-les systématiquement
3. Quand elles deviennent naturelles, ajoutez-en d'autres
4. Réajustez selon les retours de l'équipe

❌ Approche à éviter :

• Essayer tout en même temps
• Être rigide sans réfléchir
• Imposer des pratiques sans discussion
• Abandonner dès la première difficulté

# Historique confus
commit 3a5b7c9  
Update

commit 8d4e2f1  
Fix stuff

commit 1f9a3b7  
WIP

commit 7c2d8e4  
Final version (for real this time)

Conséquences :

• 😕 Impossible de comprendre l'historique
• ⏰ Temps perdu à chercher quand un bug a été introduit
• 💥 Conflits fréquents lors des merges
• 🤷 Personne ne sait qui travaille sur quoi
• 🔥 Déploiements risqués

# Historique clair
commit 3a5b7c9  
feat(auth): ajoute l'authentification OAuth2

commit 8d4e2f1  
fix(payment): corrige le calcul de la TVA

commit 1f9a3b7  
refactor(api): simplifie la gestion des erreurs

commit 7c2d8e4  
docs: met à jour le guide d'installation

Bénéfices :

• ✨ Historique lisible et compréhensible
• 🔍 Facile de retrouver l'origine d'un bug avec git bisect
• 🤝 Collaboration fluide et sans friction
• 📊 Vue claire de l'avancement du projet
• 🚀 Déploiements en confiance

Comment savoir si vos pratiques s'améliorent ?

✅ Vous remarquez que :

• Les conflits de merge diminuent
• Les reviews de code sont plus rapides
• Les bugs sont trouvés plus vite
• L'onboarding de nouveaux membres est plus facile
• Les discussions techniques s'appuient sur l'historique
• Moins de temps perdu en "archéologie de code"

Si vous voulez mesurer objectivement :

• Temps moyen de merge d'une Pull Request
• Nombre de conflits par semaine
• Couverture de tests dans les nouvelles PR
• Temps pour identifier l'origine d'un bug
• Satisfaction de l'équipe (sondages réguliers)

Les bonnes pratiques Git ne vivent pas dans le vide. Elles font partie d'une culture d'équipe plus large :

1. Communication :

• Expliquer ses choix
• Demander des clarifications
• Partager ses découvertes

2. Bienveillance :

• Accepter les feedbacks
• Donner des feedbacks constructifs
• Comprendre que tout le monde apprend

3. Rigueur :

• Suivre les conventions établies
• Ne pas prendre de raccourcis
• Penser aux autres

4. Amélioration continue :

• Rétrospectives régulières
• Expérimentation de nouvelles pratiques
• Remise en question des habitudes

Chaque équipe devrait avoir un document (CONTRIBUTING.md, WORKFLOW.md) qui définit :

• Convention de nommage des branches
• Format des messages de commit
• Processus de revue de code
• Workflow adopté (Git Flow, GitHub Flow, etc.)
• Critères de merge

Ce document :

• Est vivant : évoluez-le avec l'équipe
• Est partagé : accessible à tous
• Est appliqué : pas juste théorique
• Est expliqué : aux nouveaux arrivants

❌ Faux. Même sur un projet solo :

• Vous êtes votre collaborateur futur
• Dans 6 mois, vous aurez tout oublié
• Un bon historique est votre documentation

❌ Vision court-termiste. Les bonnes pratiques :

• Prennent 30 secondes de plus par commit
• Font gagner des heures lors des débugs
• Sont un investissement, pas un coût

❌ Faux. Les messages sont lus :

• Lors des revues de code
• Lors du débogage avec git blame
• Lors de la recherche d'historique
• Par les futurs contributeurs

❌ Trop tard. Les bonnes pratiques :

• Sont plus faciles à adopter dès le début
• Deviennent impossibles à appliquer rétroactivement
• Créent une dette technique si ignorées

❌ Faux. Les bonnes pratiques :

• Bénéficient à tous les projets, quelle que soit leur taille
• Sont encore plus importantes dans les petites équipes
• Facilitent la croissance du projet

Ne lisez pas passivement. Pour chaque pratique :

• Essayez-la immédiatement sur un projet
• Faites des erreurs et apprenez d'elles
• Observez l'impact sur votre workflow

Cette semaine : Concentrez-vous sur les messages de commit
Semaine suivante : Ajoutez les commits atomiques
Semaine d'après : Ajoutez .gitignore propre
...et ainsi de suite.

Les bonnes pratiques sont plus efficaces quand toute l'équipe les adopte :

• Discutez-en en réunion
• Proposez des conventions
• Faites des sessions de formation
• Soyez patient avec les nouveaux arrivants

Créez un fichier CONVENTIONS.md dans votre projet :

# Conventions Git de l'équipe

## Messages de commit
- Format : type(scope): description
- Types : feat, fix, docs, refactor, test, chore

## Branches
- feature/* : nouvelles fonctionnalités
- bugfix/* : corrections de bugs
- hotfix/* : corrections urgentes production

## Pull Requests
- 2 approbations requises
- Tests CI/CD obligatoires
- Squash merge par défaut

Vous et votre équipe allez faire des erreurs. C'est normal. L'important est :

• D'apprendre de ces erreurs
• De s'améliorer progressivement
• De rester bienveillant avec soi-même et les autres

Voici ce que nous allons couvrir, dans l'ordre :

• Messages de commit clairs et utiles
• Commits atomiques et organisation
• Configuration du dépôt (.gitignore, .gitattributes)

Objectif : Devenir un contributeur professionnel

• Workflows collaboratifs (Git Flow, GitHub Flow, Trunk-Based)
• Organisation et nommage des branches
• Revue de code avec Pull Requests

Objectif : Travailler efficacement en équipe

• Versionnement sémantique (SemVer)
• Releases et tags
• Communication des changements

Objectif : Gérer l'évolution d'un projet dans le temps

Vous avez maintenant une vision d'ensemble de ce module et de son importance. Les bonnes pratiques Git ne sont pas un luxe ou une perte de temps : elles sont essentielles pour tout projet professionnel.

Rappelez-vous :

• 🎯 Adoptez progressivement les pratiques
• 💪 Pratiquez régulièrement
• 🤝 Partagez avec votre équipe
• 📈 Améliorez continuellement
• 🧘 Soyez patient et bienveillant

Les bonnes pratiques Git transformeront non seulement votre utilisation de Git, mais aussi la qualité globale de vos projets et la fluidité de votre collaboration.

Commençons par la base la plus fondamentale : apprendre à écrire de bons messages de commit. C'est la compétence qui aura le plus d'impact immédiat sur votre travail quotidien.

⏭️ Écrire de bons messages de commit