Collaborations et versions | Exercices corrigés

Concepts & Exercices

Collaboration = Versions + Communication + Coordination

Équation collaborative

Git

git commit

Système de gestion de versions

Branches

git branch

Développement parallèle

Fusion

git merge

Intégration des modifications

🎯

Définition : Gestion des différentes versions d'un projet informatique.

🔄

Objectif : Tracer les modifications et faciliter le travail en équipe.

👥

Collaboration : Permettre à plusieurs développeurs de travailler ensemble.

🔧

Contrôle : Gérer les conflits et les versions stables.

Exercice 1

Initialiser un dépôt Git et effectuer un premier commit

Exercice 2

Créer une branche pour une nouvelle fonctionnalité

Exercice 3

Fusionner une branche avec la branche principale

Exercice 4

Gérer un conflit de fusion entre deux développeurs

Exercice 5

Utiliser l'historique pour revenir à une version antérieure

Corrigé : Exercices 1 à 3

1 Initialisation Git

Définition :

Dépôt Git : Répertoire surveillé par Git pour suivre les modifications du code.

Méthode d'initialisation :

Créer un dossier pour le projet
Initialiser le dépôt avec git init
Ajouter les fichiers avec git add
Effectuer le premier commit avec git commit

# Initialisation d'un dépôt Git
mkdir projet-nouveau
cd projet-nouveau

# Initialiser le dépôt
git init

# Créer un fichier README
echo "# Mon Projet" > README.md

# Ajouter le fichier au suivi
git add README.md

# Effectuer le premier commit
git commit -m "Initial commit: Ajout du README"

# Vérifier l'état du dépôt
git status
              

Étape 1 : Créer le répertoire

Créer un dossier pour votre projet et s'y déplacer.

Étape 2 : Initialiser le dépôt

Utiliser git init pour créer un dépôt vide.

Étape 3 : Ajouter des fichiers

Utiliser git add pour ajouter des fichiers au suivi.

Dépôt initialisé: git init → git add → git commit

Réponse finale :

Un dépôt Git est initialisé en créant un répertoire, en le rendant suivi par Git et en effectuant un premier commit.

Règles appliquées :

• Workflow : add → commit → push

• Messages : Utiliser des messages de commit clairs

• Suivi : Ajouter les fichiers au suivi avant de commiter

2 Création de branche

Définition :

Branche : Ligne de développement indépendante permettant de travailler sur des fonctionnalités séparément.

# Vérifier les branches existantes
git branch

# Créer une nouvelle branche pour une fonctionnalité
git checkout -b develop-fonctionnalite

# Alternative (Git 2.23+)
git switch -c develop-fonctionnalite

# Vérifier la branche active
git branch --show-current

# Créer un fichier dans la nouvelle branche
echo "Nouvelle fonctionnalité" > fonctionnalite.py

# Ajouter et committer
git add fonctionnalite.py
git commit -m "Ajout de la nouvelle fonctionnalité"
              

Étape 1 : Vérifier les branches

Utiliser git branch pour voir les branches existantes.

Étape 2 : Créer la nouvelle branche

Utiliser git checkout -b pour créer et basculer vers la nouvelle branche.

Étape 3 : Travailler dans la branche

Apporter les modifications et effectuer des commits dans la branche.

Branche créée: main → develop-fonctionnalite

Réponse finale :

Une branche est créée pour isoler le développement d'une fonctionnalité du code principal.

Règles appliquées :

• Isolation : Utiliser des branches pour des fonctionnalités distinctes

• Nommage : Utiliser des noms descriptifs pour les branches

• Travail séparé : Les modifications n'affectent pas la branche principale

3 Fusion de branche

Définition :

Fusion (Merge) : Intégration des modifications d'une branche dans une autre.

# Basculer vers la branche principale
git checkout main

# Mettre à jour la branche principale
git pull origin main

# Fusionner la branche de fonctionnalité
git merge develop-fonctionnalite

# Vérifier les modifications fusionnées
git log --oneline

# Supprimer la branche si elle n'est plus nécessaire
git branch -d develop-fonctionnalite

# Pousser les modifications vers le dépôt distant
git push origin main
              

Étape 1 : Se placer sur la branche cible

Basculer vers la branche où vous souhaitez intégrer les modifications.

Étape 2 : Mettre à jour la branche cible

Utiliser git pull pour synchroniser avec le dépôt distant.

Étape 3 : Fusionner la branche source

Utiliser git merge pour intégrer les modifications.

Fusion: develop-fonctionnalite → main

Réponse finale :

La fusion intègre les modifications d'une branche dans une autre en conservant l'historique des commits.

Règles appliquées :

• Ordre : Se placer sur la branche cible avant la fusion

• Synchronisation : Mettre à jour la branche cible avant fusion

• Nettoyage : Supprimer les branches inutiles après fusion

Corrigé : Exercices 4 à 5

4 Gestion de conflit

Définition :

Conflit : Situation où deux modifications affectent la même ligne de code dans une fusion.

# Exemple de conflit possible
# Fichier: fonctionnalite.py
"""
def calculer_moyenne(liste):
    # Modification de l'utilisateur A
    return sum(liste) / len(liste) if liste else 0
    
def trier_liste(liste):
    # Modification de l'utilisateur B
    return sorted(liste, reverse=True)
    
def trier_liste(liste):
    # Autre modification de l'utilisateur C
    if not liste:
        return []
    return sorted(liste)
"""

# Commandes pour résoudre le conflit
# 1. Essayer la fusion
git merge develop-autre-fonctionnalite

# 2. Résoudre manuellement les conflits
# Ouvrir le fichier et supprimer les marqueurs de conflit
# <<<<<<< HEAD
# ...
# =======
# ...
# >>>>>>> develop-autre-fonctionnalite

# 3. Ajouter le fichier résolu
git add fonctionnalite.py

# 4. Finaliser la fusion
git commit -m "Résolution du conflit dans fonctionnalite.py"
              

Étape 1 : Identifier le conflit

Git indique quels fichiers contiennent des conflits après la tentative de fusion.

Étape 2 : Ouvrir les fichiers en conflit

Repérer les sections marquées avec <<<<<<<, =======, >>>>>>>.

Étape 3 : Résoudre manuellement

Choisir la version correcte et supprimer les marqueurs de conflit.

Conflit résolu: Modifications fusionnées manuellement

Réponse finale :

Un conflit est résolu manuellement en décidant quelle version du code conserver.

Règles appliquées :

• Communication : Coordonner avec les autres développeurs

• Attention : Lire attentivement les sections en conflit

• Test : Vérifier que la solution fonctionne correctement

5 Historique et retour en arrière

Définition :

Historique : Ensemble des commits successifs qui tracent l'évolution du projet.

# Voir l'historique des commits
git log --oneline

# Exemple de sortie:
# a1b2c3d Correction d'un bug critique
# e4f5g6h Ajout de la fonctionnalité X
# i7j8k9l Refactoring du module principal
# 1234567 Initial commit

# Revenir à un commit spécifique
git checkout a1b2c3d

# Créer une branche à partir d'un ancien commit
git checkout -b sauvegarde a1b2c3d

# Annuler le dernier commit (sans perdre les modifications)
git reset --soft HEAD~1

# Annuler le dernier commit (en perdant les modifications)
git reset --hard HEAD~1

# Voir les modifications entre deux commits
git diff HEAD~1 HEAD
              

Étape 1 : Explorer l'historique

Utiliser git log pour voir les commits précédents.

Étape 2 : Identifier le commit cible

Repérer le hash du commit auquel vous souhaitez revenir.

Étape 3 : Effectuer l'action souhaitée

Soit basculer vers le commit, soit créer une branche, soit annuler des modifications.

Historique: Visualisation + Navigation + Annulation

Réponse finale :

L'historique Git permet de naviguer dans les versions du projet et d'annuler des modifications si nécessaire.

Règles appliquées :

• Prudence : Utiliser --soft pour conserver les modifications

• Confirmation : Vérifier le commit avant d'annuler

• Sauvegarde : Créer des branches avant de modifier l'historique

Cours bien détaillé

\text{Collaboration} = \frac{\text{Versions} \times \text{Communication}}{\text{Conflits}}

Collaboration efficace

🎯

Objectif : Gérer efficacement les modifications simultanées.

🔄

Workflow : Pull → Modif → Commit → Push → Merge.

👥

Équipe : Plusieurs développeurs peuvent travailler en parallèle.

🔧

Contrôle : Suivi complet de l'évolution du code.

💡

Conseil : Faire des commits fréquents et atomiques

🔍

Attention : Ne jamais modifier l'historique partagé

⚡

Astuce : Utiliser des branches pour isoler le travail

📋

Méthode : Adopter un workflow collaboratif (GitFlow)

✅

Vérification : Toujours vérifier les conflits avant fusion

Workflow collaboratif :

Clone : Copier le dépôt distant localement
Branch : Créer une branche pour sa tâche
Commit : Sauvegarder ses modifications
Push : Envoyer ses modifications sur le serveur
Pull Request : Proposer ses modifications
Merge : Intégrer les modifications approuvées

Commandes essentielles :

git clone : Copier un dépôt distant
git pull : Récupérer les dernières modifications
git push : Envoyer ses modifications
git status : Voir l'état des fichiers
git diff : Voir les différences
git log : Voir l'historique des commits

Règles importantes :

Commencer toujours par un git pull avant de commencer à travailler
Ne jamais pousser directement sur la branche principale
Créer des branches pour chaque fonctionnalité ou correction
Écrire des messages de commit clairs et descriptifs
Revenir à la branche principale pour fusionner les branches

Collaborations et versionsExercices corrigés

Collaborations et versions
Exercices corrigés