Gantt
Un éditeur de
diagrammes de Gantt
| Auteur: |
François Pinard |
| Date: |
1985, 2004 |
Un diagramme de Gantt est une représentation
graphique du déroulement, dans le temps, des
diverses activités constitutives d'un projet.
Par exemple, les schémas de planification de la
méthode dite globale sont des diagrammes de
Gantt.
Gantt a pour but d'ingérer
une description simplifiée d'un projet et des
activités qui le composent, de produire un
échéancier de ces activités tout en respectant
certaines contraintes, puis de faire l'édition
de quelques diagrammes et tableaux résultant de
cet échéancier.
Ce document présente, dans l'ordre:
- la commande d'appel de
Gantt en exécution,
- la manière de décrire un projet pour
Gantt,
- plusieurs détails syntaxiques et
lexicaux,
- quelques informations sur l'algorithme
d'ordonnancement,
- une brève description de chaque
résultat édité,
- un court historique du programme
Gantt,
- une liste de problèmes connus et de
suggestions reçues.
Gantt accepte zéro ou
plusieurs fichiers en argument, possiblement
précédés d'une ou de plusieurs options. Il
s'utilise ainsi:
gantt [OPTION]... [FICHIER]...
En l'absence de toute option et de tout
fichier, il fournit un bref résumé du format de
l'appel et termine immédiatement. En présence
de fichier mais en absence de toute option,
l'option -g est présumée.
Chaque argument FICHIER donne le nom du
fichier contenant la description d'un projet à
traiter, dans un format qui est décrit plus
loin. Si aucun n'est fourni, mais que des
options sont présentes, la description est
alors lue de l'entrée standard.
La sortie standard recevra, selon le choix
d'options, les listes contenant les diagrammes
ou les tableaux édités, ou encore l'explication
des libellés. Si l'option -l est fournie, les sorties
utilisent le Latin-1 comme jeu de caractères,
plutôt que le UTF-8 de Unicode. Si des erreurs
importantes sont détectées durant la
compilation ou l'ordonnancement des projets,
l'erreur standard reçoit un diagnostic, et
l'exécution du programme s'interrompt.
Accessoirement, l'option -v produit quelques lignes
sur l'erreur standard montrant la progression
du programme, elle peut aider à localiser une
erreur dans certaines circonstances.
Chaque journée est possiblement séparée en
plusieurs tranches de temps, une tranche étant
la plus petite unité de temps qui puisse être
allouée pour l'exécution d'une activité.
L'option -dTRANCHES fournit toutes les
heures de séparation entre deux tranches (il y
a une tranche de plus qu'il n'y a de
séparations), chaque heure de séparation est un
nombre décimal entre 1 et 23, et ces heures
sont séparées entre elles par des virgules.
Dans les diagrammes produits, chaque tranche de
temps donne lieu à une colonne. Malgré que les
tranches peuvent contenir un nombre inégal
d'heures, elles sont considérées comme
équivalentes au moment de l'allocation des
tranches aux activités. Les séparations de
tranches ne servent qu'à convertir une heure
explicite, dans les données, dans la tranche
qui lui correspond. Si cette option n'est pas
spécifiée, elle est présumée être -d10,12,15,17, définissant
ainsi 5 tranches de temps dans chaque journée
(de 00:00 à 10:00, de 10:00 à 12:00, de 12:00 à
15:00, de 15:00 à 17:00 et de 17:00 à 24:00).
Utiliser -d, (juste une virgule) pour
indiquer que chaque jour ne contient qu'une
seule tranche de temps, autrement dit, que
l'allocation se fait en jours entiers.
L'option -o demande le calcul de
l'ordonnancement originel, qui ne
dépend probablement pas de la date courante.
Sans cette option, la partie non encore
réalisée de chaque activité est ré-ordonnancée
à partir du jour d'aujourd'hui:
Gantt ajuste alors un nouveau
plan par l'étude des fractions réalisées des
diverses activités.
L'option -wN (où N est un nombre décimal,
lequel sera présumé valoir 79 si l'option n'est
pas choisie) limite le nombre de colonnes
utiles disponibles dans une ligne, pour la
production des diagrammes. Le diagramme est
automatiquement découpé, au besoin, afin qu'il
ne dépasse pas la grandeur d'une ligne.
L'option -rN repousse le jour
d'aujourd'hui de N jours dans le futur (ou
vers le passé sur N est négatif), ce qui peut
changer le jour de départ des diagrammes; si
N est flottant, l'heure du
jour d'aujourd'hui est prise en considération
pour décider le jour de départ.
On peut aussi limiter le nombre de jours
rapportés dans les diagrammes par l'option
-jN, où N est un nombre entier ou
flottant. L'option -f indique que, à moins
d'indication contraire dans la déclaration des
exécutants, ceux-ci n'ont pas congé les fins de
semaine. L'option -c exige une réalisation
contiguë de l'activité par l'exécutant,
c'est-à-dire que la cédule doit utiliser des
tranches successives, possiblement interrompues
par les congés ou autres jours
d'indisponibilité, mais pas par une autre
activité par le même exécutant
(note: cette option n'est pas
complètement implantée). L'option -nN limite le nombre
d'activités à retenir, séparément pour chaque
fichier d'entrée, les activités retenues sont
alors les premières déterminées par l'ordre de
parcours.
L'option -a demande l'édition d'un
diagramme de Gantt pour l'ensemble des
activités, l'option -e demande l'édition d'un
diagramme de Gantt pour chacun des exécutants
du projet, et l'option -t demande l'édition d'un
tableau des attributions des activités aux
exécutants. Si aucune des options -a, -e ou -t n'est utilisée, le
programme présume l'option -a. Implicitement, un
diagramme est précédé de titres répétant la
première ligne de chaque fichier Allout, et
suivi d'explications détaillées de chaque
libellé utilisé dans ce diagramme; l'option
-s a pour effet de supprimer
ces titres et ces explications. L'option
-i découpe le diagramme en
plusieurs diagrammes plus petits afin
d'intercaler les explications après chaque jour
(plutôt que de les afficher toutes regroupées à
la fin); cette option supprime aussi les
titres.
Pour chacun des diagrammes ou tableaux
précédents, l'option -mN contrôle la largeur
imprimable pour les libellés identifiant, dans
la marge gauche, activités ou les exécutants,
cette largeur vaut 16 au départ. Cette largeur
est automatiquement réduite si elle est
inutilement grande. Les libellés trop longs
sont amputés de leur partie droite, mais jamais
à moins de 8 caractères.
Chaque fichier contient la description d'un
projet, en format Allout. Le format Allout
permet de représenter une hiérarchie synoptique
de concepts et de les manipuler via un éditeur
d'esquisses (folding editor), tels Emacs ou
Vim, qui offrent des modes spécialisés
d'édition pour Allout. Par exemple, voir:
http://fp-etc.progiciels-bpi.ca/allout-vim/doc.txt
pour la documentation du format Allout dans
le contexte de Vim.
Sommairement, dans une hiérarchie Allout,
chaque ligne terminale non vide, c'est-à-dire
qui n'est pas un en-tête de sous-structure,
représente une activité du projet et fournit le
libellé de cette activité. Certaines lignes
peuvent contenir une ou plusieurs clauses,
lesquelles détaillent alors diverses propriétés
de l'activité. Dans certains cas plus
particuliers, ces clauses décrivent un
exécutant pour l'ensemble du projet plutôt que
de détailler une activité. Toutes ces choses
sont illustrées dans la section Exemple de
projet, plus loin.
L'utilisateur est tout-à-fait libre
d'utiliser la hiérarchie Allout pour regrouper
et commenter les activités comme bon lui
semble. La manière dont il organise sa
hiérarchie est reflétée dans les listes
explicatives, à moins qu'elles ne soient
supprimées par l'option -s. Cette option permet de
faire suivre chaque diagramme d'une explication
pour chaque libellé apparaissant dans la marge
gauche du diagramme. L'explication d'une
activité ou d'un exécutant, c'est la liste de
tous les en-têtes partant du tronc de la
hiérarchie et se rendant le plus directement
possible jusqu'à l'activité ou l'exécutant en
question.
Les clauses peuvent être introduites à la
fin d'une ligne de texte, en séparant cette
ligne des clauses par un double deux-points
::, lui-même précédé et suivi
d'espace blanc, ces clauses concernent alors
l'activité décrite par le texte précédant les
::. Les clauses peuvent aussi
remplir une ligne complète qui doit alors
démarrer par un simple deux-points :, lui-même suivi d'un ou
plusieurs blancs (rien ne doit précéder ce
deux-points hormis de l'espace blanc, et
possiblement aussi, les caractères spécifiques
à Allout pour l'introduction d'une étiquette de
niveau). ces clauses concernent alors
l'activité décrite dans la ligne précédente.
Les clauses sont séparées entre elles par de
l'espace blanc et, si l'on excepte le cas de
l'heure qui suit possiblement une date, les
clauses ne contiennent pas elles-mêmes d'espace
blanc.
Il est possible de changer en un seul
endroit les propriétés non explicites de toute
une série d'activités, et c'est bien commode.
Il suffit de grouper toutes ces activités dans
un sous-arbre Allout, et de chapeauter ce
sous-arbre par les propriétés voulues. Plus
précisément, si une déclaration d'activité
apparaît en position de titre d'une
sous-structure Allout, les clauses de cette
déclaration sont implicitement présumées pour
toutes les activités déclarées à l'intérieur de
cette sous-structure.
Aucune clause n'est obligatoire dans une
déclaration d'activité.
-
=ACTIVITÉ
Une clause débutant par un signe
= introduit un
libellé pour l'activité, auquel on peut
se référer dans d'autres clauses du
projet, et qui l'identifie ensuite dans
les diagrammes et tableaux produits. Il
doit être unique dans un projet
donné.
Si le premier caractère est un
pour-cent %, il s'agit d'une
activité discrète, qui ne sera pas
mentionné dans les rapports produits.
Ce concept peut être utile pour
introduire des contraintes invisibles
entre des activités (par exemple: un
délai de mûrissement), ou pour cacher
des activités qui intéressent un projet
moins directement (par exemple: un
temps de vacances).
En l'absence de cette clause, le
libellé est déduit du contenu de la
dernière ligne de l'explication pour
cette activité. Il n'est alors pas
requis que le contenu de cette ligne
soit unique, à la condition qu'il n'y
soit pas fait référence dans aucune des
clauses de ce projet.
-
DURÉE+FIXE
Une clause peut-être constitué par
deux nombres flottants séparés par un
signe +. Le nombre à gauche
du signe + est la durée de
cette activité, le nombre à droite du
signe + est le temps fixe
de cette activité.
La durée annonce l'effort requis
pour l'activité, dans un système
d'unités laissé à la discrétion de
l'utilisateur. Par exemple, la durée
peut être exprimée en jours, ou encore
en heures. Le plus simple est
probablement d'utiliser une convention
uniforme à l'intérieur d'un fichier
Allout donné. Mais la véritable
contrainte est exactement celle-ci: la
vitesse des exécutants susceptibles
d'être attribués à une activité doit
être consistante avec le système
d'unités de cette activité, Voir la
spécification de vitesse pour plus
d'information. Le programme effectue un
ajustement de la durée en fonction de
la vitesse de l'exécutant responsable
de l'activité, afin que les diagrammes
reflètent le temps réel prévu pour la
compléter. Le temps fixe indique un
nombre de jours (nécessairement des
jours, et non pas des unités de
l'utilisateur) nécessaires pour la
réalisation de l'activité.
Contrairement à durée, ce temps ne
subit pas d'ajustement en fonction de
la vitesse de l'exécutant responsable.
L'effet de durée et fixe est combiné et
les temps, l'un ajusté, l'autre pas,
s'additionnent.
DURÉE et FIXE peuvent être
séparément ou simultanément omis, une
valeur omise est présumée nulle. Si
DURÉE est présent
alors que FIXE est omis, le
signe + peut être omis lui
aussi. Un signe + isolé implique que
les deux valeurs sont nulles. Lorsque
les deux valeurs sont nulles,
l'activité ne monopolise aucun effort
de son exécutant. Si cette clause est
absente et n'a pas de valeur implicite,
la durée est présumée nulle, et le
temps fixe est présumé à un jour.
-
*FRACTION
Une clause qui débute par un
astérisque * suivi d'un nombre
flottant sert à indiquer la fraction
déjà réalisée d'une activité. Si cette
clause est absente et n'a pas de valeur
implicite, la fraction est présumée 0,
signifiant que l'activité est toujours
complètement à faire.
Si l'option -o est active sur la
commande d'appel, cette clause n'a
aucun effet sur l'algorithme de
fabrication de l'horaire, et ne vise
qu'à illustrer les diagrammes produits
(des astérisques * servent à montrer
la portion réalisée). Si l'option
-o n'est pas choisie,
le programme ne considère que le futur,
et seules les parties non-réalisées des
activités participent à la fabrication
de l'horaire,
-
DATE, <=DATE, <DATE, >=DATE, >DATE
Une clause peut contenir une date en
format ISO 8601 (seules les écritures
AAAA-MM-JJ ou
AAAA-MM-JJ HH:MM sont acceptées)
possiblement précédée d'un opérateur de
comparaison, mais sans blanc. Elle
indique une contrainte de temps pour
l'activité.
La clause DATE signale que
l'activité doit idéalement se faire à
la date indiquée. <=DATE indique une
date d'échéance pour l'activité, alors
que <DATE indique le
lendemain de l'échéance (ou la tranche
suivante si une heure est mentionnée).
>=DATE indique la
plus petite date pour démarrer
l'activité, alors que >DATE indique que
l'activité ne doit pas démarrer avant
le jour suivant la date donnée (ou
avant la tranche suivante si une heure
est mentionnée).
Dans le seul cas où DATE est utilisé sans
opérateur, il est permis de séparément
remplacer AAAA, MM ou JJ par ...., .. et .. respectivement,
transformant ainsi la date en gabarit
de date, et l'activité en activité
générique.
-
>ACTIVITÉ,
<ACTIVITÉ
Une clause peut contenir le code
d'une activité, précédé d'un opérateur
de comparaison. Elle indique une
dépendance entre deux activités.
La clause >ACTIVITÉ indique
que l'activité courante ne peut débuter
qu'une fois l'autre activité,
identifiée par le code ACTIVITÉ est
terminée. La clause <ACTIVITÉ indique
que l'activité identifiée par le code
ACTIVITÉ ne peut
débuter qu'une fois l'activité courante
terminée.
-
@EXÉCUTANT
Une clause peut contenir le code
d'un exécutant, précédé d'un arrobas
@. Elle indique
l'affectation d'un responsable pour
cette activité. Cet exécutant
responsable doit être déjà déclaré,
préalablement, dans le même fichier
Allout. L'activité ne peut être
réalisée à un moment où l'exécutant
n'est pas déjà libre.
Si cette clause est absente et n'a
pas de valeur implicite, le programme
choisit automatiquement un exécutant
parmi ceux qui ont été déclarés. Si
aucun exécutant n'a encore été déclaré
au moment de la déclaration de
l'activité, le programme crée un
exécutant nommé Exécutant et
l'assigne comme responsable de
l'activité.
Si seul l'arrobas @ apparaît, et
qu'aucun code d'exécutant n'est fourni,
alors l'activité s'applique à tous les
exécutants en même temps, et sert alors
à définir un congé. Dans ce cas
particulier, il est obligatoire que
durée soit 0. et que fixe soit 1.
-
+PÉRIODE N
Une clause débutant par un signe
+, suivi d'un nombre
flottant, et terminée par la lettre
N majuscule (sans
blanc qui précède cette lettre),
indique la période de répétition d'une
activité générique. Si PÉRIODE est omis, il
est présumé valoir 1.
Dans une déclaration d'exécutant, la
clause =@EXÉCUTANT obligatoire,
mais aucune autre clause n'est requise.
-
=@EXÉCUTANT
Une clause débutant par un signe
= suivi d'un arrobas
@ introduit un code
d'exécutant, auquel on peut se référer
dans d'autres clauses du projet, et qui
l'identifie ensuite dans les diagrammes
et tableaux produits.
Si le premier caractère du code de
l'exécutant est un pour-cent %, il s'agit alors
d'un exécutant discret, dont la mention
sera exclue des rapports produits. Ce
concept peut être utile pour faire
noter, sans "consommer de ressources",
certains moments importants dans
l'exécution du projet (comme: réunions,
rapports, générations, etc...).
Avant d'être référencé par son code
dans une activité de projet, ou même
utilisé pour une assignation
automatique, un exécutant doit être
préalablement déclaré à l'intérieur du
même fichier Allout. Il est permis de
déclarer à nouveau un exécutant
(c'est-à-dire, en utilisant un code
d'exécutant déjà connu) avec des
propriétés différentes, une activité
utilise alors pour un code d'exécutant
donné la dernière des déclarations
précédentes.
-
LMMJVSD
Une clause constituée des 7
caractères, soit une lettre majuscule
selon les jours de la semaine du lundi
au dimanche, soit un tiret (ou un signe
moins) -, signale les jours
où l'exécutant est disponible pour
réaliser des activités. Une lettre
indique un jour de disponibilité, un
tiret - un jour
d'indisponibilité.
Si cette clause est absente, elle
est présumée valoir LMMJV-- en l'absence
de l'option -f, ou LMMJVSD en sa
présence.
-
/VITESSE
Une clause commençant par une barre
oblique et suivie par un nombre
flottant donne la vitesse de
l'exécutant, exprimé en unités de durée
qu'il peut traiter en un jour.
Lorsque des clauses définissent un
exécutant, la vitesse indique la
disponibilité de cet exécutant pour le
projet, s'il n'est pas disponible à
temps plein. Sa valeur doit toujours
être plus grande que 0. Elle sert à
calculer le temps réel d'une activité
lorsqu'elle est attribuée à cet
exécutant. Par exemple, si les durées
sont comptées en jours, une vitesse de
.75 indique que l'exécutant ne peut
attribuer que les trois-quarts de son
temps pour le projet. On obtiendrait le
même résultat avec une vitesse valant
6. si, de manière consistante dans
toutes les déclarations de durée des
activités, on attribue 8. unités par
jour.
En absence de toute vitesse, elle
est présumée 1. C'est donc dire que si
les durées sont comptées autrement
qu'en jours, la vitesse doit être
explicitement spécifiée, en pratique,
pour tous les exécutants d'un
projet.
En utilisant astucieusement plusieurs
déclarations d'exécutant pour une même
personne, avec des vitesse ou des jours de
disponibilité différents, il est possible de
contrôler un peu plus précisément comment
partager le temps de cette personne entre
divers projets.
Le calendrier d'un projet démarre à la
plus petite de toutes les dates qui sont
mentionnées dans des clauses, et s'il n'y en
a aucune, alors au jour de l'exécution de
Gantt, le jour
d'aujourd'hui. Sans l'option -o, donc en mode de
ré-évaluation des parties non-réalisées des
projets, le calendrier ne commence pas avant
le jour d'aujourd'hui. Le calendrier s'étend
dans le futur autant que cela est nécessaire.
Toutefois, l'option -jN peut servir à limiter
le nombre de jours à imprimer dans les
diagrammes produits.
Si la clause @ apparaît pour une
activité, sans mentionner d'exécutant,
l'activité représente un jour de congé, qui
risque de tomber dans le calendrier du
projet. Il n'est pas nécessaire d'indiquer
les samedis ni les dimanches, qui sont
automatiquement inclus dans les congés, à
moins que l'option -f n'ait été spécifiée.
Les jours de congés n'apparaissent pas
dans les diagrammes produits. Toute activité
prévue exactement pour un jour de congé (et
donc qui ne peut pas être exécutée plus tôt)
apparaît dans les diagrammes comme un retard
porté au jour ouvrable suivant.
Afin de donner vie, un tantinet soit peu,
à la description qui précède, voici un
exemple de description de projet pour
Gantt, qui illustre
d'ailleurs plusieurs des possibilités
décrites plus haut. Apparaîtront plus loin
des exemples de résultats obtenus à partir de
cet exemple...
* Projet s450 - Contrôle du temps CP sur le Cray.
.. Exécutants
. : Francois Pinard
[=@fp /.5]
. : Jean-François Gagnon
[=@jfg /.5]
. : Neil Gardner
[=@ng /.5]
. : Cray Canada inc.
[=@cci /.6]
.. Calendrier
. : Départ
[+ 1985-05-01]
. : Congé
[+1 1985-05-20 @]
. : Congé
[+1 1985-06-24 @]
. : Congé
[+1 1985-07-01 @]
. : Vacances
[+6 1985-05-31 @fp]
. : Vacances
[+5 1985-06-24 @fp]
. : Vacances
[+3 1985-06-02 @ng]
. : Vacances
[+2 1985-06-28 @jfg]
.. Activités
. : %cos0190
[+6]
. : ape.defin
[3.5 @ng *1]
. : ape.codif
[4 @ng *.5]
. : ape.prepa
[4.5 @ng *.95]
. : ape.produ
[.1 @ng *1]
. : ape.ajust
[1.5 >ape.defin >ape.codif >ape.prepa >ape.produ @ng *.5]
. : uvald.comdk
[1.5 @fp *.95]
. : uvald.moddic
[3 >uvald.comdk @fp *.8]
. : uvald.sauve
[1 @fp]
. : xmit.init
[1.5 >ape.ajust >uvald.moddic @jfg *.05]
. : xmit.maj
[4 @jfg *.8]
. : xmit.zero
[1 @jfg *.8]
. : xmit.exp
[1 >xmit.init >xmit.maj >xmit.zero >uval.exp @jfg]
. : uval.dacp
[.5 @jfg *1]
. : uval.stp
[1 >uval.dacp @jfg *.2]
. : uval.verrou
[1.5 @jfg *.5]
. : uval.exp
[3 >uval.stp @jfg]
. : uval.proc
[1 >xmit.exp @jfg]
. : cp.anal
[1.5 >ape.defin @cci *1]
. : cp.maj
[3.5 >uvald.moddic >cp.anal @cci *.25]
. : us.cl
[2 >csd.dim @fp *.65]
. : us.note
[1 @fp]
. : us.anal
[4 @fp]
. : us.ignore
[1 >us.anal @fp]
. : csd.dim
[.5 >%cos0190 @cci *.9]
. : csd.code
[1 @cci *1]
. : csd.jcsdef
[2 >%cos0190 >csd.code @cci *.9]
. : csd.jcm
[3 >uval.exp >xmit.exp >csd.code @cci]
. : struc.obj
[3 @fp]
. : struc.def
[1 >struc.obj @fp]
Le moteur d'ordonnancement choisit le moment
d'exécution de chaque activité, l'une après
l'autre, selon les critères suivants:
-
aucune activité ne sera
inscrite à l'horaire avant que toutes les
activités dont elles dépend y soient déjà
inscrites;
-
lorsqu'un activité est
ajoutée à l'horaire, elle doit débuter
après la fin de toutes les activités dont
elle dépend,
-
lorsqu'une activité est
ajoutée à l'horaire, elle ne doit pas
créer de conflit d'horaire pour
l'exécutant qui lui est affecté (si ce
dernier est déjà monopolisé par une autre
activité);
-
une activité doit
s'exécuter en bloc, en ce sens qu'elle ne
peut pas être interrompue pour être
poursuivie plus tard;
-
lorsqu'une activité est
ajoutée à l'horaire, elle débute le plus
tôt possible, parmi les moments où elle
pourrait possiblement débuter;
-
toutes choses étant
égales par ailleurs,
Gantt inscrira d'abord
les activités ayant la plus petite date
d'échéance (clause <DATE);
-
toutes choses étant
égales par ailleurs,
Gantt inscrira d'abord
les activités ayant la plus petite date
de levée (clause >DATE);
-
toutes choses étant
égales par ailleurs,
Gantt inscrira d'abord
les activités apparaissant en premier
dans un parcours en
largeur.
En fait, une hiérarchie Allout pour un
projet donné représente un arbre
contenant des activités. Contrairement
aux parcours habituels des arbres (le
pre-order ou le post-order des techniques
depth-first), le parcours en
largeur favorise au maximum le
parallélisme entre les diverses branches
de l'arbre (technique
breadth-first). Les branches
moins profondes de chaque hiérarchie
Allout sont virtuellement étirées de
manière à ce que toutes les parties de
cette hiérarchie terminent environ en
même temps. Si plusieurs fichiers Allout
sont simultanément traités, cette
collection de hiérarchies est parcourue
en largeur elle aussi, mais sans
étirement d'une hiérarchie complète.
Dans le cas où l'option -o n'est pas choisie,
Gantt prend en considération
l'ensemble des parties encore à venir de chaque
activité. Les dépendances s'exercent sur des
fractions d'activité plutôt que sur les
activités entières: Gantt
proposera donc une solution même si l'on
déclare réalisée, ne serait-ce qu'en partie,
une activité qui dépend d'une autre qui, elle,
n'est pas complètement terminée.
Gantt alloue le temps par
tranches entières de un jour de temps réel. Cet
arrondissement est retardé le plus longtemps
possible. Mais lorsqu'il a lieu, une partie
fractionnaire plus petite que 0.05 est ignorée,
alors qu'un partie fractionnaire d'au moins
0.05 est arrondie à l'entier suivant.
Le diagramme des activités schématise le
déroulement des activités dans le temps.
Sur le diagramme, les activités sont
identifiées de haut en bas, au début de
chaque ligne. Le temps s'écoule de gauche à
droite, le calendrier apparaît en haut. Les
dimanches sont soulignés par le symbole ·,
dans le cadre et sur la trame de fond. Une
colonne de deux-points (:) souligne aussi le jour
courant (celui de l'exécution du programme
Gantt:
aujourd'hui!).
Dans le corps du schéma, chaque activité
débute par un ( au premier jour, suivi
d'un -
pour chaque jour supplémentaire de
réalisation et par un ) au dernier jour. Si une
activité débute et termine le même jour, un
O tient lieu des deux
parenthèses en même temps. Un o, quant à lui,
signale une activité qui ne consomme pas de
ressources. Par contre, pour une activité en
cours de réalisation, un ou plusieurs
* recouvrent l'activité, de
gauche à droite, proportionnellement à sa
fraction réalisée. Le symbole ( est le premier à être
ainsi recouvert par un *. Gantt
fournit au moins un * si la réalisation a
débuté, mais il garantit aussi le ) (ou le o ou le O) jusqu'au moment de la
réalisation complète de l'activité en
question. Le symbole @, quant à lui, met en
évidence les dépassements d'échéance.
Les quelques + qui émaillent le corps du
schéma indiquent les dépendances entre les
activités. Si deux activités sont
dépendantes, un + suivra le ) qui termine la première
au jour précis où la seconde débute, un autre
+ précédera le ( qui débute la seconde au
jour précis où la première se termine.
Le diagramme des activités suivant a été
produit à partir de la description fournie en
exemple, plus haut dans ce document:
· ·----·----·--------·----·----·----·------------·-----·
| 0 0 0 |
| 5 6 7 |
| 00000001111112222222330000011111111222222000000111 |
| 12367890345671234789013456701234789015678234589012 |
·--------------·----·----·--------·----·----·----·------------·-----·
| ape.defin | *******+ : + |
| ape.codif | · ****---) · : · · · + · |
| ape.prepa | : ********)+ |
| ape.produ | * : + |
| ape.ajust | · + · ++ · : · · ·+**)+ · |
| uvald.comdk | **)+ : |
| uvald.moddic | +*****) + : + |
| uvald.sauve | · ·() · : · · · · |
| xmit.init | + : +*-) + |
| xmit.maj | ******-) : + |
| xmit.zero | · *) · : · · · + · |
| xmit.exp | + + : + + ()+ |
| uval.dacp | *+ : |
| uval.stp | · · +*) +· : · · · · |
| uval.verrou | **) : |
| uval.exp | + (----) + + |
| uval.proc | · · · : · · · +() |
| cp.anal | +***+ : |
| cp.maj | ++**---) : |
| us.cl | · + · · : · · ***) · |
| us.note | () : |
| us.anal | (------) + |
| us.ignore | · · · :+ · () · · |
| csd.dim | +o : + |
| csd.code | ** + : + |
| csd.jcsdef | + · + · ***) · · · · |
| csd.jcm | + : + +(---) |
| struc.obj | : (----)+ |
| struc.def | · · · : · · · · +() |
·--------------·----·----·--------·----·----·----·------------·-----·
Le diagramme des exécutants donne un
schéma de l'occupation de chaque exécutant en
fonction du temps.
Dans ce schéma, les symboles ont la même
signification que dans le diagramme des
activités, sauf en ce que les activités ne
sont pas explicitement identifiées. Les
dépendances entre les activités ne sont pas
marquées non plus.
Ce diagramme est plus facilement lu en le
juxtaposant, si l'on veut, au diagramme des
activités.
Le diagramme des exécutants suivant a été
produit à partir de la description fournie en
exemple, plus haut dans ce document:
· ·----·----·--------·----·----·----·------------·-----·
| 0 0 0 |
| 5 6 7 |
| 00000001111112222222330000011111111222222000000111 |
| 12367890345671234789013456701234789015678234589012 |
·--------------·----·----·--------·----·----·----·------------·-----·
| fp | **)*****)()()(------)(----)()***)** (---)(----)() |
| jfg | ******-)*)**)**)(----) *-)()()() |
| ng | ***********---)*** : (-)********)**)**** · |
| cci | ** o*****---)***)** (---) |
·--------------·----·----·--------·----·----·----·------------·-----·
Le tableau des attributions met en
relation les activités et les exécutants.
Pour chaque activité, ce tableau donne les
initiales de l'exécutant qui en a la
responsabilité, ainsi que le nombre de
jours-personne requis par l'activité et la
date de fin planifiée pour cette
activité.
De plus, à la fin du tableau, apparaît le
nombre de jours-personne total pour le projet
entier. (Ce total ne compte pas les activités
discrètes ou celles dont l'exécutant est
discret.)
Le diagramme des activités suivant a été
produit à partir de la description fournie en
exemple, plus haut dans ce document:
·--------------·----------·-------·------------·
| Activité | Respons. | J.-P. | Date fin |
·--------------·----------·-------·------------·
| ape.defin | ng | 3.5 | 1985-05-09 |
| ape.codif | ng | 4.0 | 1985-05-22 |
| ape.prepa | ng | 4.5 | 1985-06-18 |
| ape.produ | ng | 0.1 | 1985-05-23 |
| ape.ajust | ng | 1.5 | 1985-06-21 |
| uvald.comdk | fp | 1.5 | 1985-05-03 |
| uvald.moddic | fp | 3.0 | 1985-05-13 |
| uvald.sauve | fp | 1.0 | 1985-05-15 |
| xmit.init | jfg | 1.5 | 1985-06-27 |
| xmit.maj | jfg | 4.0 | 1985-05-10 |
| xmit.zero | jfg | 1.0 | 1985-05-14 |
| xmit.exp | jfg | 1.0 | 1985-07-04 |
| uval.dacp | jfg | 0.5 | 1985-05-15 |
| uval.stp | jfg | 1.0 | 1985-05-17 |
| uval.verrou | jfg | 1.5 | 1985-05-23 |
| uval.exp | jfg | 3.0 | 1985-05-31 |
| uval.proc | jfg | 1.0 | 1985-07-08 |
| cp.anal | cci | 1.5 | 1985-05-14 |
| cp.maj | cci | 3.5 | 1985-05-23 |
| us.cl | fp | 2.0 | 1985-06-17 |
| us.note | fp | 1.0 | 1985-05-17 |
| us.anal | fp | 4.0 | 1985-05-30 |
| us.ignore | fp | 1.0 | 1985-06-11 |
| csd.dim | cci | 0.5 | 1985-05-09 |
| csd.code | cci | 1.0 | 1985-05-02 |
| csd.jcsdef | cci | 2.0 | 1985-05-29 |
| csd.jcm | cci | 3.0 | 1985-07-11 |
| struc.obj | fp | 3.0 | 1985-07-10 |
| struc.def | fp | 1.0 | 1985-07-12 |
·--------------·----------·-------·------------·
| total | | 57.1 | |
·--------------·----------·-------·------------·
Gantt a été programmé par
l'auteur en janvier 1985 (sous le nom
diagantt), pour lui faciliter
l'expérimentation d'une nouvelle méthode de
gestion de projets, en prenant le projet
CIDS-P252 comme prototype. L'effort requis pour
faire, manu militari, quelques diagrammes de
Gantt, combiné à la perspective de devoir
reprendre plusieurs fois ce travail en quelques
semaines, s'est avéré une incitation pour faire
ce programme. En mai 1985, l'usage de plus en
plus régulier de Gantt et la
lourdeur du traitement des retards m'a amené à
quelques améliorations et simplifications.
En décembre 2004, Gantt a
été traduit de Pascal à Python, et j'en ai
profité pour lever plusieurs restrictions,
changer complètement la syntaxe pour dépendre
des fichiers Allout, et ajouter un peu plus de
fonctionnalité.
Quoiqu'il utilise des heuristiques
raisonnables, Gantt ne fait
pas d'effort dramatique pour découvrir une
solution qui respecte nécessairement toutes les
échéances demandées. La solution qu'il propose
n'est donc pas optimale.
Il pourrait être intéressant que
Gantt identifie et mette en
évidence le ou les chemins critiques de
l'horaire produit.
|
|
|