Skip to content

guide-formateur.md

Latest commit

 

History

History
551 lines (398 loc) · 13 KB

guide-formateur.md

File metadata and controls

551 lines (398 loc) · 13 KB

Guide du Formateur

Cours Git et GitHub pour Ingénieurs en Électronique

📋 Vue d'ensemble

Ce guide est destiné aux formateurs qui dispensent le cours "Git et GitHub pour Ingénieurs en Électronique". Il contient des conseils pédagogiques, des timings détaillés, et des solutions aux problèmes courants.

🎯 Objectifs Pédagogiques Globaux

À la fin de la formation de 4 heures, les étudiants doivent être capables de :

  1. Comprendre les concepts fondamentaux du contrôle de version
  2. Utiliser Git pour gérer leurs projets individuels
  3. Collaborer efficacement avec GitHub
  4. Appliquer les bonnes pratiques de gestion de code
  5. Gérer des projets de firmware et de documentation technique

📚 Structure du Cours

Module 1 : Introduction et Concepts Fondamentaux (60 min)

  • Objectif : Comprendre pourquoi et comment utiliser Git
  • Format : 70% théorie, 30% pratique
  • Exercices : Installation et configuration

Module 2 : Commandes Git Essentielles (60 min)

  • Objectif : Maîtriser les commandes de base
  • Format : 40% théorie, 60% pratique
  • Exercices : Création de dépôt, branches, résolution de conflits

Module 3 : Collaboration avec GitHub (60 min)

  • Objectif : Travailler en équipe avec GitHub
  • Format : 50% théorie, 50% pratique
  • Exercices : Dépôt GitHub, Pull Requests, collaboration

Module 4 : Pratiques Avancées (60 min)

  • Objectif : Appliquer les bonnes pratiques professionnelles
  • Format : 30% théorie, 70% pratique
  • Exercices : Projet complet avec CI/CD

⏱️ Planning Détaillé

Module 1 (60 minutes)

Temps Activité Durée Notes
0:00 Accueil et présentations 5 min Tour de table
0:05 Introduction : Pourquoi Git ? 10 min Slides 1-8
0:15 Concepts fondamentaux 15 min Slides 9-17
0:30 Exercice 1 : Installation 10 min Assistance individuelle
0:40 Interfaces et aide 10 min Slides 18-20
0:50 Vocabulaire et architecture 10 min Slides 21-26
1:00 Pause 5 min

Module 2 (60 minutes)

Temps Activité Durée Notes
1:05 Commandes de base 15 min Slides 1-10, démo live
1:20 Exercice 2 : Premier dépôt 10 min
1:30 Branches et fusion 15 min Slides 11-20, démo live
1:45 Exercice 3 : Branches 15 min
2:00 Commandes avancées 10 min Slides 21-28
2:10 Pause 10 min

Module 3 (60 minutes)

Temps Activité Durée Notes
2:20 GitHub basics 15 min Slides 1-11, démo live
2:35 Exercice 5 : Premier dépôt GitHub 15 min
2:50 Pull Requests et collaboration 15 min Slides 12-16
3:05 Exercice 6 : Collaboration 20 min En binômes
3:25 Issues et gestion de projet 10 min Slides 15-23
3:35 Pause 10 min

Module 4 (60 minutes)

Temps Activité Durée Notes
3:45 Workflows et bonnes pratiques 10 min Slides 1-8
3:55 Documentation et CI/CD 15 min Slides 9-16
4:10 Exercice 7 : Projet avec CI/CD 20 min
4:30 Troubleshooting et outils 10 min Slides 17-24
4:40 Récapitulatif et questions 10 min
4:50 Exercice 8 (optionnel) : Projet final 25 min Ou à faire à la maison
5:15 Conclusion et évaluation 5 min

🛠️ Préparation Avant le Cours

Matériel Nécessaire

Pour le formateur :

  • Ordinateur avec Git installé
  • Projecteur ou écran partagé
  • Compte GitHub
  • Exemples de projets Arduino préparés
  • Accès Internet stable

Pour les étudiants :

  • Ordinateurs avec droits administrateur
  • Accès Internet
  • Éditeur de texte (VS Code recommandé)
  • Comptes GitHub créés (idéalement avant le cours)

Vérifications Techniques

1 semaine avant :

  • Envoyer email avec prérequis
  • Demander création comptes GitHub
  • Partager liens d'installation Git

1 jour avant :

  • Tester le projecteur/partage d'écran
  • Vérifier la connexion Internet
  • Préparer les exemples de code
  • Imprimer l'aide-mémoire (optionnel)

Le jour J :

  • Arriver 15 min en avance
  • Tester tout le matériel
  • Préparer les slides
  • Avoir un plan B (sans Internet)

🎓 Conseils Pédagogiques

Approche Générale

Principe 80/20 :

  • 80% des besoins couverts par 20% des commandes
  • Se concentrer sur l'essentiel
  • Mentionner les fonctionnalités avancées sans les détailler

Apprentissage par la pratique :

  • Démonstrations en direct
  • Exercices immédiatement après la théorie
  • Erreurs volontaires pour montrer le dépannage

Adaptation au public :

  • Exemples liés à l'électronique (Arduino, ESP32, etc.)
  • Vocabulaire technique approprié
  • Cas d'usage concrets

Gestion du Groupe

Niveaux hétérogènes :

  • Identifier rapidement les niveaux
  • Exercices bonus pour les avancés
  • Assistance individuelle pour les débutants
  • Encourager l'entraide

Participation :

  • Poser des questions régulièrement
  • Encourager les questions
  • Valoriser les contributions
  • Créer un environnement bienveillant

Timing :

  • Respecter les pauses
  • Être flexible sur les exercices
  • Avoir des exercices de secours
  • Pouvoir accélérer ou ralentir

💡 Démonstrations en Direct

Module 1 : Première Démo

Objectif : Montrer le workflow complet en 5 minutes

# 1. Créer un projet
mkdir demo-led
cd demo-led
git init

# 2. Créer un fichier
echo "# Demo LED" > README.md

# 3. Voir le statut
git status

# 4. Ajouter et commiter
git add README.md
git commit -m "Initial commit"

# 5. Voir l'historique
git log

Points à souligner :

  • Simplicité du workflow
  • Importance de git status
  • Messages de commit descriptifs

Module 2 : Démo Branches

Objectif : Montrer la puissance des branches

# 1. Créer une branche
git checkout -b feature-test

# 2. Faire des modifications
echo "Test" > test.txt
git add test.txt
git commit -m "Ajout test"

# 3. Retour sur main
git checkout main

# 4. Montrer que test.txt n'existe pas sur main
ls

# 5. Fusionner
git merge feature-test

# 6. Montrer que test.txt existe maintenant
ls

Points à souligner :

  • Isolation des modifications
  • Facilité de basculement
  • Fusion simple

Module 3 : Démo GitHub

Objectif : Montrer le cycle complet avec GitHub

# 1. Créer un dépôt sur GitHub (montrer l'interface)

# 2. Cloner
git clone git@github.com:username/demo.git
cd demo

# 3. Faire des modifications
echo "Modification" >> README.md
git commit -am "Update README"

# 4. Pousser
git push origin main

# 5. Montrer sur GitHub (rafraîchir la page)

Points à souligner :

  • Synchronisation automatique
  • Historique visible sur GitHub
  • Collaboration facilitée

🚨 Problèmes Courants et Solutions

Problème 1 : Git non installé

Symptôme : git: command not found

Solutions :

  • Windows : Installer Git for Windows
  • macOS : xcode-select --install ou Homebrew
  • Linux : sudo apt-get install git

Prévention : Email de prérequis 1 semaine avant

Problème 2 : Erreur SSH

Symptôme : Permission denied (publickey)

Solutions :

  1. Vérifier la clé : ssh -T git@github.com
  2. Générer une nouvelle clé si nécessaire
  3. Alternative : utiliser HTTPS temporairement

Prévention : Prévoir du temps pour la configuration SSH

Problème 3 : Conflit de merge

Symptôme : CONFLICT (content): Merge conflict

Solutions :

  1. Montrer les marqueurs de conflit
  2. Expliquer comment choisir
  3. Démontrer la résolution
  4. Utiliser un outil visuel (VS Code)

Prévention : Exercice dédié à la résolution de conflits

Problème 4 : Commit sur mauvaise branche

Symptôme : "J'ai commité sur main au lieu de ma branche"

Solutions :

# Créer une branche à partir du commit actuel
git branch nouvelle-branche

# Revenir en arrière sur main
git reset --hard HEAD~1

# Aller sur la nouvelle branche
git checkout nouvelle-branche

Problème 5 : Fichiers sensibles commités

Symptôme : "J'ai commité mon mot de passe"

Solutions :

# Supprimer le fichier de l'historique
git filter-branch --force --index-filter \
  "git rm --cached --ignore-unmatch secrets.h" \
  --prune-empty --tag-name-filter cat -- --all

# Forcer le push
git push origin --force --all

Prévention : Insister sur .gitignore dès le début

📊 Évaluation des Acquis

Quiz Rapide (5 minutes)

Questions théoriques :

  1. Quelle est la différence entre Git et GitHub ?
  2. À quoi sert une branche ?
  3. Que fait la commande git pull ?
  4. Qu'est-ce qu'une Pull Request ?
  5. Pourquoi utiliser .gitignore ?

Questions pratiques :

  1. Comment créer un nouveau dépôt ?
  2. Comment voir l'historique des commits ?
  3. Comment annuler des modifications non commitées ?
  4. Comment créer une branche ?
  5. Comment résoudre un conflit ?

Projet d'Évaluation

Critères d'évaluation :

  • Dépôt Git initialisé correctement
  • Historique de commits propre et descriptif
  • Utilisation de branches
  • .gitignore approprié
  • README.md complet
  • Code fonctionnel
  • Tests présents
  • Documentation technique

Barème suggéré :

  • Structure du projet : 20%
  • Qualité des commits : 20%
  • Utilisation des branches : 15%
  • Documentation : 15%
  • Code fonctionnel : 20%
  • Bonnes pratiques : 10%

🎯 Adaptation du Cours

Pour un Public Débutant

Ajustements :

  • Plus de temps sur les concepts de base
  • Exercices plus guidés
  • Moins de commandes avancées
  • Plus de démonstrations

Durée recommandée : 5-6 heures

Pour un Public Avancé

Ajustements :

  • Moins de temps sur les bases
  • Plus de workflows avancés
  • Git rebase, cherry-pick, etc.
  • Hooks et automatisation

Durée recommandée : 3-4 heures

Format en Ligne

Adaptations :

  • Utiliser le partage d'écran
  • Breakout rooms pour exercices en binôme
  • Chat pour questions
  • Enregistrer la session
  • Pauses plus fréquentes (toutes les 45 min)

📚 Ressources Complémentaires

Pour le Formateur

Livres :

  • "Pro Git" par Scott Chacon
  • "Git Pocket Guide" par Richard E. Silverman

Sites web :

Vidéos :

  • Git and GitHub for Beginners (freeCodeCamp)
  • Git Tutorial for Beginners (Corey Schafer)

Pour les Étudiants

À distribuer :

  • Aide-mémoire Git (inclus dans le cours)
  • Liens vers tutoriels interactifs
  • Liste de projets open source pour pratiquer
  • Invitation au groupe Discord/Slack

🔄 Amélioration Continue

Feedback des Étudiants

À la fin du cours :

  • Questionnaire de satisfaction
  • Points forts / points à améliorer
  • Suggestions de contenu
  • Évaluation du formateur

Questions suggérées :

  1. Le rythme était-il adapté ? (trop lent / adapté / trop rapide)
  2. Les exercices étaient-ils pertinents ?
  3. Qu'avez-vous le plus apprécié ?
  4. Qu'auriez-vous aimé voir en plus ?
  5. Recommanderiez-vous ce cours ?

Suivi Post-Formation

1 semaine après :

  • Email de suivi
  • Ressources complémentaires
  • Invitation à une session Q&A

1 mois après :

  • Session de questions-réponses
  • Partage de projets réalisés
  • Feedback sur l'utilisation réelle

📝 Checklist du Formateur

Avant le Cours

  • Matériel vérifié
  • Exemples préparés
  • Comptes de test créés
  • Slides à jour
  • Exercices testés
  • Plan B préparé

Pendant le Cours

  • Accueil chaleureux
  • Objectifs clarifiés
  • Démonstrations claires
  • Questions encouragées
  • Timing respecté
  • Assistance individuelle

Après le Cours

  • Feedback collecté
  • Ressources partagées
  • Certificats distribués
  • Suivi planifié
  • Notes pour amélioration

🎓 Certification

Critères de Réussite

Pour obtenir le certificat :

  • Présence à 100% du cours
  • Participation aux exercices
  • Projet final validé (optionnel)
  • Quiz final > 70% (optionnel)

Modèle de Certificat

CERTIFICAT DE FORMATION

Ceci certifie que [Nom de l'étudiant]
a suivi avec succès la formation

"Git et GitHub pour Ingénieurs en Électronique"

Durée : 4 heures
Date : [Date]

Compétences acquises :
- Gestion de versions avec Git
- Collaboration avec GitHub
- Bonnes pratiques de développement
- CI/CD pour projets embarqués

Formateur : [Nom]
Signature : [Signature]

📞 Contact et Support

Pour les formateurs :

Ressources :

  • Dépôt GitHub du cours
  • Slides modifiables
  • Exercices personnalisables
  • Communauté de formateurs

Bonne formation ! 🚀

Ce guide est un document vivant. N'hésitez pas à le faire évoluer en fonction de votre expérience.