UA8 : Gestion d’un projet de spécialité à l’aide du logiciel GanttProject (partie 1/2)

## Objectifs et prérequis **Objectifs** : À la fin de ce chapitre, l’élève sera capable de : - Télécharger, installer et lancer le logiciel libre **GanttProject** ; - Décrire les principaux éléments de son interface (menus, barres d’outils, vues Gantt et ressources) ; - Construire la structure de découpage d’un projet (WBS) ; - Définir les tâches, leurs durées et les types de dépendances (FS, SS, FF, SF) ; - Calculer les dates au plus tôt (AU +), au plus tard (AU –) et les marges (slack) ; - Identifier le chemin critique d’un projet simple. **Prérequis** : - Notions de base en gestion de projet (objectif, livrable, jalon) ; - Maîtrise de l’usage d’un ordinateur sous Windows/Linux/macOS (téléchargement, installation) ; - Capacité à lire et interpréter un tableau simple. > **À retenir** : Un projet est défini par un ensemble de tâches interconnectées visant à atteindre un objectif déterminé dans le temps et avec des ressources limitées. --- ## Introduction contextualisée Dans le cadre du baccalauréat séries F4, les élèves doivent mener un **projet de spécialité** qui intègre les compétences acquises en informatique (algorithmique, bases de données, réseaux, etc.). La réussite de ce projet repose sur une bonne planification : il faut savoir quelles tâches réaliser, dans quel ordre, avec quelles ressources et dans quels délais. Le logiciel **GanttProject** (version 2.8 au moment de la rédaction du programme MINESEC/IGE) répond précisément à ce besoin : il permet de représenter graphiquement le planning sous forme de diagramme de Gantt, de gérer les dépendances entre tâches et de visualiser le chemin critique. Ce chapitre constitue la première partie d’une séquence de deux unités dédiées à l’utilisation de cet outil. > **À retenir** : Le diagramme de Gantt a été inventé par Henry Gantt vers 1910 pour suivre la production industrielle ; il reste aujourd’hui un standard de la gestion de projet. --- ## I. Obtention du logiciel GanttProject et description de son interface ### A. Téléchargement et installation 1. **Accéder au site officiel** : ouvrir le navigateur et se rendre sur `https://www.ganttproject.biz`. 2. **Choisir la version** adaptée au système d’exploitation (Windows 64‑bit, macOS, Linux deb ou tar.gz). 3. **Télécharger le fichier d’installation** (ex. `ganttproject-2.8.1-r20230915.exe` pour Windows). 4. **Lancer l’installateur** : double‑clic, accepter le contrat de licence, choisir le dossier d’installation (par défaut `C:\Program Files\GanttProject`). 5. **Terminer** : cocher l’option « Lancer GanttProject » puis cliquer sur « Finish ». > **À retenir** : GanttProject est distribué sous licence GPL v3 ; il est donc libre d’utilisation, de modification et de redistribution. ### B. Présentation de l’interface L’interface se compose de cinq zones principales : | Zone | Contenu | Fonction principale | |------|---------|---------------------| | **Barre de menus** | Fichier, Édition, Vue, Projet, Outils, Aide | Accès aux commandes globales (nouveau projet, enregistrement, impression, préférences). | | **Barre d’outils** | Icônes : Nouveau, Ouvrir, Enregistrer, Couper, Copier, Coller, Annuler, Rétablir, Zoom, etc. | Accès rapide aux actions fréquentes. | | **Volet de gauche** | Arborescence du projet (tâches, sous‑tâches, jalons, ressources) | Navigation hiérarchique ; permet d’ajouter, supprimer, indenté/déindenté des tâches. | | **Zone centrale** | Diagramme de Gantt (axe horizontal = temps, barres = tâches) | Visualisation du planning ; édition directe des durées et dépendances. | | **Volet de droite** | Onglets : Ressources, Charge, Détails | Gestion des ressources humaines/matérielles, suivi de la charge, affichage des propriétés de la tâche sélectionnée. | > **À retenir** : Dans le diagramme de Gantt, chaque barre représente une tâche ; sa longueur correspond à sa durée, son positionnement indique les dates de début et de fin. ### C. Exemple 1 : création d’un projet simple **Objectif** : créer un projet « Préparation du exposé de spécialité » comportant trois tâches : 1. Recherche documentaire (3 jours) 2. Rédaction du support (2 jours) 3. Répétition orale (1 jour) **Étapes** : 1. **Fichier → Nouveau** → nommer le projet `ExposéSpé`. 2. Dans le volet de gauche, cliquer droit sur « Racine » → **Nouvelle tâche** → saisir `Recherche documentaire`, durée `3j`. 3. Répéter l’opération pour `Rédaction du support` (2 j) et `Répétition orale` (1 j). 4. Pour ajouter une sous‑tâche, sélectionner la tâche mère, puis **Nouvelle tâche fille** (ex. sous‑tâche « Consultation d’articles » sous Recherche documentaire). 5. Ajuster l’échelle de temps via le menu **Vue → Zoom** (choisir « Jours »). **Résultat** : trois barres côte à côte, aucune dépendance définie (les tâches peuvent se dérouler en parallèle). > **À retenir** : Sans dépendance explicite, GanttProject considère que toutes les tâches démarrent au même instant (date de début du projet). ### D. Exemple 2 : personnalisation de l’affichage - **Changer la couleur d’une tâche** : clic droit sur la barre → **Couleur de la barre** → choisir un ton (ex. bleu pour les tâches de recherche, vert pour la rédaction). - **Afficher les marges** : menu **Vue → Afficher les marges** → apparaissent des lignes fines indiquant le slack (voir partie II). - **Imprimer le diagramme** : **Fichier → Imprimer → Aperçu** → choisir orientation Paysage, échelle 100 % → **Imprimer**. > **À retenir** : La personnalisation des couleurs améliore la lisibilité du planning, surtout lorsqu’on distingue les tâches critiques (souvent en rouge) des tâches non critiques. --- ## II. Planification des tâches ### A. Décomposition du travail (WBS) La **Work Breakdown Structure** (WBS) consiste à diviser le projet en livrables puis en tâches élémentaires. Chaque niveau de la WBS doit respecter les règles suivantes : - **Exhaustivité** : toutes les activités nécessaires au livrable sont présentes. - **Mutual exclusivité** : aucune tâche n’appartient à deux livrables différents. - **Niveau de détail adapté** : la durée d’une tâche doit être estimable avec une incertitude raisonnable (généralement entre 0,5 j et 10 j pour un projet de spécialité). > **À retenir** : Une WBS bien construite facilite l’estimation des coûts, la répartition des responsabilités et le suivi de l’avancement. ### B. Types de dépendances GanttProject gère quatre types de liens, notés selon la convention **PREDECESSOR → SUCCESSOR** : | Type | Signification | Exemple de notation | |------|----------------|---------------------| | **FS** (Finish‑to‑Start) | La tâche succédante ne peut commencer que lorsque la tâche précédente est terminée. | `A → B` (FS) | | **SS** (Start‑to‑Start) | Les deux tâches doivent commencer en même temps. | `A → B` (SS) | | **FF** (Finish‑to‑Finish) | Les deux tâches doivent se terminer en même temps. | `A → B` (FF) | | **SF** (Start‑to‑Finish) | La tâche succédante ne peut se terminer que lorsque la tâche précédente a commencé. | `A → B` (SF) | > **À retenir** : Le type FS est le plus utilisé (≈ 80 % des liens dans les projets pédagogiques). ### C. Calcul des dates au plus tôt (AU +), au plus tard (AU –) et des marges Pour chaque tâche *i* on définit : - $ES_i$ : date au plus tôt de début (Early Start) - $EF_i = ES_i + d_i$ : date au plus tôt de fin (Early Finish) où $d_i$ est la durée. - $LF_i$ : date au plus tard de fin (Late Finish) - $LS_i = LF_i - d_i$ : date au plus tard de début (Late Start) Les formules de propagation (passage avant et arrière) sont : **Passage avant (calcul ES/EF)** : $$ ES_i = \max_{(j\rightarrow i)\in\text{prédécesseurs}} EF_j \quad\text{avec } ES_{\text{début}}=0 $$ $$ EF_i = ES_i + d_i $$ **Passage arrière (calcul LS/LF)** : $$ LF_i = \min_{(i\rightarrow k)\in\text{successeurs}} LS_k \quad\text{avec } LF_{\text{fin}}=EF_{\text{dernière tâche}} $$ $$ LS_i = LF_i - d_i $$ La **marge totale** (ou slack) d’une tâche est : $$ \text{Slack}_i = LS_i - ES_i = LF_i - EF_i $$ Une tâche est **critique** si son slack vaut zéro. > **À retenir** : Le chemin critique est la séquence de tâches dont le slack est nul ; toute variation de durée sur ce chemin retarde la date de fin du projet. ### D. Exemple 1 : projet avec dépendances simples (type FS) **Scénario** : projet « Mise en place d’un petit réseau scolaire » comportant quatre tâches : 1. Étude des besoins (2 j) – prédécesseur : aucun 2. Achat du matériel (3 j) – prédécesseur : 1 (FS) 3. Installation physique (4 j) – prédécesseur : 2 (FS) 4. Configuration logicielle (2 j) – prédécesseur : 3 (FS) **Calcul** : | Tâche | $d_i$ (j) | $ES_i$ | $EF_i$ | $LS_i$ | $LF_i$ | Slack | |-------|----------|--------|--------|--------|--------|-------| | 1. Étude | 2 | 0 | 2 | 0 | 2 | 0 | | 2. Achat | 3 | 2 | 5 | 2 | 5 | 0 | | 3. Installation | 4 | 5 | 9 | 5 | 9 | 0 | | 4. Configuration | 2 | 9 | 11 | 9 | 11 | 0 | Toutes les slack valent zéro → **chemin critique** = 1 → 2 → 3 → 4, durée totale = 11 j. > **À retenir** : Dans un enchaînement pur FS, le chemin critique coïncide avec l’ensemble des tâches. ### E. Exemple 2 : projet avec marges et dépendances mixtes **Scénario** : projet « Réalisation d’une application mobile » avec cinq tâches : - A. Analyse des besoins (2 j) – aucun prédécesseur - B. Conception UI/UX (3 j) – prédécesseur : A (FS) - C. Développement backend (4 j) – prédécesseur : A (FS) - D. Développement frontend (3 j) – prédécesseur : B (FS) **et** C (FS) - E. Tests et validation (2 j) – prédécesseur : D (FS) **Calcul passage avant** : - $ES_A = 0$, $EF_A = 2$ - $ES_B = EF_A = 2$, $EF_B = 2+3 = 5$ - $ES_C = EF_A = 2$, $EF_C = 2+4 = 6$ - $ES_D = \max(EF_B,EF_C) = \max(5,6) = 6$, $EF_D = 6+3 = 9$ - $ES_E = EF_D = 9$, $EF_E = 9+2 = 11$ **Passage arrière** (date de fin du projet = $EF_E = 11$) : - $LF_E = 11$, $LS_E = 11-2 = 9$ - $LF_D = LS_E = 9$, $LS_D = 9-3 = 6$ - $LF_C = LS_D = 6$, $LS_C = 6-4 = 2$ - $LF_B = LS_D = 6$, $LS_B = 6-3 = 3$ - $LF_A = \min(LS_B,LS_C) = \min(3,2) = 2$, $LS_A = 2-2 = 0$ **Slack** : - A : $LS_A-ES_A = 0-0 = 0$ (critique) - B : $3-2 = 1$ jour de marge - C : $2-2 = 0$ (critique) - D : $6-6 = 0$ (critique) - E : $9-9 = 0$ (critique) Le chemin critique est donc **A → C → D → E** (durée 2+4+3+2 = 11 j). La tâche B possède un slack de 1 j ; elle peut être retardée d’un jour sans impacter la date de fin. > **À retenir** : La présence de plusieurs prédécesseurs (comme pour D) implique que son ES est le maximum des EF de ses prédécesseurs. --- ## Synthèse du chapitre - GanttProject est un logiciel libre de gestion de projet basé sur le diagramme de Gantt. - Son interface se répartit en barre de menus, barre d’outils, volet de navigation (gauche), diagramme central et volet de détails (droite). - La planification débute par la création d’une WBS, suivie de la définition des tâches, de leurs durées et des dépendances (FS, SS, FF, SF). - Les dates au plus tôt et au plus tard se calculent par un passage avant (max des EF des prédécesseurs) puis un passage arrière (min des LS des successeurs). - La marge totale (slack) d’une tâche vaut $LS_i-ES_i$ ; une tâche critique présente un slack nul. - Le chemin critique, constitué des tâches à slack nul, détermine la durée minimale du projet. --- ## Glossaire | Terme | Définition | |-------|------------| | Diagramme de Gantt | Représentation graphique d’un projet où l’axe horizontal indique le temps et chaque barre représente une tâche. | | WBS (Work Breakdown Structure) | Décomposition hiérarchique du projet en livrables puis en tâches élémentaires. | | Dépendance FS | Finish‑to‑Start : la tâche succédante ne peut commencer que lorsque la tâche précédente est terminée. | | Date au plus tôt (ES) | Moment le plus tôt auquel une tâche peut commencer, compte tenu de ses prédécesseurs. | | Date au plus tard (LF) | Moment le plus tard auquel une tâche doit finir sans retarder la fin du projet. | | Marge totale (Slack) | Différence entre les dates au plus tard et au plus tôt d’une tâche ; indique sa flexibilité. | | Tâche critique | Tâche dont le slack est nul ; toute variation de sa durée affecte la date de fin du projet. | | Chemin critique | Suite de tâches critiques reliant le début à la fin du projet ; détermine la durée minimale du projet. | --- ## Exercices d'application corrigés ### Exercice 1 **Énoncé** : Un projet de création d’un site web comporte trois tâches : 1. Cahier des charges (2 j) – aucun prédécesseur 2. Conception graphique (3 j) – prédécesseur : 1 (FS) 3. Intégration HTML/CSS (4 j) – prédécesseur : 2 (FS) a) Dessiner le diagramme de Gantt (texte) indiquant les ES, EF, LS, LF et le slack de chaque tâche. b) Identifier le chemin critique et la durée totale du projet. **Corrigé** : **a) Calcul** | Tâche | $d$ | $ES$ | $EF$ | $LS$ | $LF$ | Slack | |-------|-----|------|------|------|------|-------| | 1. Cahier des charges | 2 | 0 | 2 | 0 | 2 | 0 | | 2. Conception graphique | 3 | 2 | 5 | 2 | 5 | 0 | | 3. Intégration HTML/CSS | 4 | 5 | 9 | 5 | 9 | 0 | **b) Chemin critique** : 1 → 2 → 3 (toutes les tâches sont critiques). Durée totale = $EF_3 = 9$ j. --- ### Exercice 2 **Énoncé** : Un projet de mise en place d’un laboratoire de sciences comporte quatre tâches : - A. Sélection du matériel (2 j) – aucun prédécesseur - B. Réception du matériel (3 j) – prédécesseur : A (FS) - C. Installation des postes (4 j) – prédécesseur : A (FS) - D. Formation des enseignants (2 j) – prédécesseurs : B (FS) et C (FS) Calculer les ES, EF, LS, LF, le slack de chaque tâche et déterminer le chemin critique. **Corrigé** : Passage avant : - $ES_A=0$, $EF_A=2$ - $ES_B=EF_A=2$, $EF_B=2+3=5$ - $ES_C=EF_A=2$, $EF_C=2+4=6$ - $ES_D=\max(EF_B,EF_C)=\max(5,6)=6$, $EF_D=6+2=8$ Passage arrière (date de fin = $EF_D=8$) : - $LF_D=8$, $LS_D=8-2=6$ - $LF_B=LS_D=6$, $LS_B=6-3=3$ - $LF_C=LS_D=6$, $LS_C=6-4=2$ - $LF_A=\min(LS_B,LS_C)=\min(3,2)=2$, $LS_A=2-2=0$ Slack : - A : $0-0=0$ (critique) - B : $3-2=1$ jour - C : $2-2=0$ (critique) - D : $6-6=0$ (critique) Chemin critique : **A → C → D** (durée 2+4+2 = 8 j). La tâche B possède un slack de 1 j. --- ### Exercice 3 **Énoncé** : Dans le projet suivant, représenter les dépendances sous forme de tableau puis calculer les marges. | Tâche | Durée (j) | Prédécesseurs | Type | |-------|-----------|----------------|------| | P1 | 3 | – | – | | P2 | 2 | P1 | FS | | P3 | 4 | P1 | FS | | P4 | 1 | P2, P3 | FS | | P5 | 2 | P3 | FS | | P6 | 3 | P4, P5 | FS | **Corrigé** : Passage avant : - $ES_{P1}=0$, $EF_{P1}=3$ - $ES_{P2}=EF_{P1}=3$, $EF_{P2}=3+2=5$ - $ES_{P3}=EF_{P1}=3$, $EF_{P3}=3+4=7$ - $ES_{P4}= \max(EF_{P2},EF_{P3}) = \max(5,7)=7$, $EF_{P4}=7+1=8$ - $ES_{P5}=EF_{P3}=7$, $EF_{P5}=7+2=9$ - $ES_{P6}= \max(EF_{P4},EF_{P5}) = \max(8,9)=9$, $EF_{P6}=9+3=12$ Passage arrière (date de fin = $EF_{P6}=12$) : - $LF_{P6}=12$, $LS_{P6}=12-3=9$ - $LF_{P4}=LS_{P6}=9$, $LS_{P4}=9-1=8$ - $LF_{P5}=LS_{P6}=9$, $LS_{P5}=9-2=7$ - $LF_{P2}=LS_{P4}=8$, $LS_{P2}=8-2=6$ - $LF_{P3}= \min(LS_{P4},LS_{P5}) = \min(8,7)=7$, $LS_{P3}=7-4=3$ - $LF_{P1}= \min(LS_{P2},LS_{P3}) = \min(6,3)=3$, $LS_{P1}=3-3=0$ Slack : - P1 : $0-0=0$ (critique) - P2 : $6-3=3$ jours - P3 : $3-3=0$ (critique) - P4 : $8-7=1$ jour - P5 : $7-7=0$ (critique) - P6 : $9-9=0$ (critique) Chemin critique : **P1 → P3 → P5 → P6** (durée 3+4+2+3 = 12 j). --- ### Exercice 4 **Énoncé** : Un élève souhaite réaliser un projet de programmation comportant cinq tâches : - T1. Analyse du cahier des charges (1 j) – aucun prédécesseur - T2. Conception de l’algorithme (2 j) – prédécesseur : T1 (FS) - T3. Écriture du code (3 j) – prédécesseur : T2 (FS) - T4. Tests unitaires (2 j) – prédécesseur : T3 (FS) - T5. Rédaction du rapport (1 j) – prédécesseur : T4 (FS) a) Calculer les dates au plus tôt et au plus tard, les marges. b) Si la tâche T3 subit un retard de 2 j, quelle sera la nouvelle date de fin du projet ? **Corrigé** : **a) Calcul normal** Passage avant : - $ES_{T1}=0$, $EF_{T1}=1$ - $ES_{T2}=1$, $EF_{T2}=1+2=3$ - $ES_{T3}=3$, $EF_{T3}=3+3=6$ - $ES_{T4}=6$, $EF_{T4}=6+2=8$ - $ES_{T5}=8$, $EF_{T5}=8+1=9$ Passage arrière (date de fin = $EF_{T5}=9$) : - $LF_{T5}=9$, $LS_{T5}=9-1=8$ - $LF_{T4}=LS_{T5}=8$, $LS_{T4}=8-2=6$ - $LF_{T3}=LS_{T4}=6$, $LS_{T3}=6-3=3$ - $LF_{T2}=LS_{T3}=3$, $LS_{T2}=3-2=1$ - $LF_{T1}=LS_{T2}=1$, $LS_{T1}=1-1=0$ Slack : toutes les tâches ont un slack nul → chemin critique = T1→T2→T3→T4→T5, durée = 9 j. **b) Retard de T3 de 2 j** Nouvelle durée de T3 = 3 + 2 = 5 j. Recalcul uniquement à partir de T3 (les prédécesseurs restent inchangés) : - $ES_{T3}$ reste 3 (déterminé par T2) - $EF_{T3}=3+5=8$ - $ES_{T4}=EF_{T3}=8$, $EF_{T4}=8+2=10$ - $ES_{T5}=EF_{T4}=10$, $EF_{T5}=10+1=11$ Nouvelle date de fin = **11 j** (augmentation de 2 j, égale au retard de la tâche critique). --- ### Exercice 5 **Énoncé** : Dans le tableau suivant, certaines dépendances sont de type SS (Start‑to‑Start). Calculer les marges en tenant compte de ce type de lien. | Tâche | Durée (j) | Prédécesseur(s) | Type | |-------|-----------|-----------------|------| | A | 2 | – | – | | B | 3 | A | SS | | C | 4 | A | FS | | D | 2 | B, C | FS | | E | 1 | D | FS | **Corrigé** : Rappel : pour un lien SS, $ES_{successeur} = ES_{prédécesseur}$ (les débuts doivent coïncider). Passage avant : - $ES_A=0$, $EF_A=0+2=2$ - **B (SS)** : $ES_B = ES_A = 0$, $EF_B = 0+3=3$ - **C (FS)** : $ES_C = EF_A = 2$, $EF_C = 2+4=6$ - **D (FS)** : $ES_D = \max(EF_B,EF_C) = \max(3,6)=6$, $EF_D = 6+2=8$ - **E (FS)** : $ES_E = EF_D = 8$, $EF_E = 8+1=9$ Passage arrière (date de fin = $EF_E=9$) : - $LF_E=9$, $LS_E=9-1=8$ - $LF_D=LS_E=8$, $LS_D=8-2=6$ - $LF_C=LS_D=6$, $LS_C=6-4=2$ - **B (SS)** : pour un lien SS, la contrainte arrière est $LS_{prédécesseur} \le LS_{successeur}$ (le prédécesseur ne peut finir après le début du successeur). On calcule donc $LS_B = \min(LS_D, LS_C?) Actually we need to propagate backward respecting SS: the latest start of B cannot exceed the latest start of D (since D depends on B via FS) and also cannot exceed the latest start of C? Wait B is predecessor of D via FS, and also predecessor of nothing else. So we compute LS_B from its successors: only D (FS). For FS, $LS_B = LS_D - d_B = 6 - 3 = 3$. - $LF_A$ : prédécesseur de B (SS) et C (FS). Pour SS, $LF_A$ doit respecter $EF_A \le ES_B + d_B? Actually easier: we compute LS_A from its successors: B (SS) and C (FS). - Depuis B (SS) : $LS_A = LS_B$ (car les débuts doivent coïncider au plus tard) → $LS_A = LS_B = 3$ - Depuis C (FS) : $LS_A = LS_C - d_A = 2 - 2 = 0$ On prend le minimum (le plus contraignant) : $LS_A = \min(3,0) = 0$. - $LF_A = LS_A + d_A = 0+2=2$ Slack : - A : $LS_A-ES_A = 0-0 = 0$ (critique) - B : $LS_B-ES_B = 3-0 = 3$ jours de marge - C : $LS_C-ES_C = 2-2 = 0$ (critique) - $LS_D-ES_D = 6-6 = 0$ (critique) - $LS_E-ES_E = 8-8 = 0$ (critique) Chemin critique : **A → C → D → E** (durée 2+4+2+1 = 9 j). La tâche B possède un slack de 3 j car son début peut être décalé tant qu’il reste synchronisé avec le début de A (SS) et que son terme ne retarde pas D. --- ## Erreurs fréquentes | Erreur | Pourquoi elle se produit | Comment l’éviter | |--------|--------------------------|------------------| | **Confondre FS et SS** : l’élève pense que « commencer en même temps » implique que la tâche précédente doit être terminée. | Méconnaissance des définitions des types de dépendance. | Mémoriser le tableau des types (FS = fin‑début, SS = début‑départ, FF = fin‑fin, SF = début‑fin) et vérifier chaque lien en dessinant une petite flèche. | | **Oublier de mettre à jour l’échelle de temps** après avoir ajouté des tâches longues, ce qui fait que le diagramme apparaît compressé. | Utilisation du zoom par défaut sans ajuster. | Après chaque modification importante, ouvrir le menu **Vue → Zoom** et choisir une échelle adaptée (jours, semaines). | | **Calculer les marges en utilisant seulement les dates au plus tôt** (ou seulement les au plus tard). | Oubli de la nécessité du passage avant *et* arrière. | Toujours réaliser les deux passages : d’abord ES/EF, puis LS/LF, puis soustraire. | | **Considérer qu’une tâche avec slack nul est forcément sur le chemin critique** alors qu’elle peut être isolée (ex. tâche dépendante d’une seule branche qui n’est pas la plus longue). | Raisonnement trop généraliste. | Vérifier que la tâche appartient bien à une chaîne de dépendances où chaque maillon a slack nul. | | **Ne pas distinguer durée ouvrable et durée calendaire** (ex. compter les week-ends comme jours de travail). | Utilisation directe de la durée en jours sans tenir compte du calendrier du projet. | Dans GanttProject, définir les jours ouvrés via **Outils → Temps de travail** ou préciser dans l’énoncé que les jours sont ouvrés. | | **Modifier la durée d’une tâche sans mettre à jour les dépendances**, ce qui crée des incohérences (ex. une tâche qui finit avant son prédécesseur). | Édition directe de la barre sans vérifier les flèches de dépendance. | Après toute modification de durée, regarder si les flèches de dépendance restent vertes (cohérence) ; sinon, ajuster les prédécesseurs ou supprimer le lien. | --- *Fin du cours.*