Point de départ

// ── Un journal de déploiements ────────────────────────────────────────────
// heure en heures depuis le début de l'observation (720 h = un mois).
const JOURNAL_A = [
  { t: 2,   commit: 1,   ok: true },
  { t: 6,   commit: 5,   ok: true },
  { t: 9,   commit: 8.5, ok: false, retabli: 9.7 },
  { t: 14,  commit: 13,  ok: true },
  { t: 20,  commit: 19,  ok: true },
  { t: 26,  commit: 25,  ok: true },
  { t: 31,  commit: 30,  ok: true },
  { t: 38,  commit: 37,  ok: true },
];
const JOURNAL_B = [
  { t: 200, commit: 20,  ok: false, retabli: 380 },
  { t: 500, commit: 260, ok: true },
  { t: 700, commit: 520, ok: false, retabli: 900 },
];

function indicateurs(journal, dureeObservation) {
  const n = journal.length;
  const echecs = journal.filter((d) => !d.ok);
  return {
    frequence: 0,        // ← à écrire : déploiements par semaine
    delai: 0,            // ← à écrire : moyenne de (t − commit), en heures
    tauxEchec: 0,        // ← à écrire : part des déploiements ayant échoué
    retablissement: 0,   // ← à écrire : moyenne de (retabli − t) sur les échecs
  };
}

function classer(i) {
  const note = (v, seuils) => seuils.findIndex((s) => v <= s);
  return "à écrire";     // ← élite / haute / moyenne / faible
}

// ── Simuler l'effet de la TAILLE DES LOTS ─────────────────────────────────
// Une même équipe, un même rythme de travail : 240 modifications par mois.
// Seule varie la fréquence de livraison.
function simuler(modificationsParMois, deploiementsParMois) {
  const parLot = modificationsParMois / deploiementsParMois;
  // Hypothèse empirique : la probabilité qu'un lot casse croît avec sa
  // taille, et le temps de diagnostic aussi — on ne sait pas quelle
  // modification est en cause parmi celles du lot.
  const probaEchec = Math.min(0.9, 1 - Math.pow(0.995, parLot));
  const diagnostic = 0.5 + parLot * 0.15;   // heures
  return { parLot, probaEchec, diagnostic };
}

// ── À VOUS ────────────────────────────────────────────────────────────────
// 1. Écrivez indicateurs() et classer(), puis comparez les deux équipes.
// 2. Faites varier deploiementsParMois de 1 à 240 : que deviennent le taux
//    d'échec et le temps de rétablissement ?
// 3. Une équipe passe de 4 à 30 déploiements par mois mais son taux d'échec
//    monte de 10 % à 45 %. A-t-elle progressé ?

console.log(JSON.stringify(indicateurs(JOURNAL_A, 720)));

Solution

const JOURNAL_A = [
  { t: 2, commit: 1, ok: true }, { t: 6, commit: 5, ok: true },
  { t: 9, commit: 8.5, ok: false, retabli: 9.7 }, { t: 14, commit: 13, ok: true },
  { t: 20, commit: 19, ok: true }, { t: 26, commit: 25, ok: true },
  { t: 31, commit: 30, ok: true }, { t: 38, commit: 37, ok: true },
];
const JOURNAL_B = [
  { t: 200, commit: 20, ok: false, retabli: 380 },
  { t: 500, commit: 260, ok: true },
  { t: 700, commit: 520, ok: false, retabli: 900 },
];

const moyenne = (t) => t.reduce((s, x) => s + x, 0) / (t.length || 1);

function indicateurs(journal, dureeObservation) {
  const echecs = journal.filter((d) => !d.ok);
  return {
    frequence: (journal.length / dureeObservation) * 168,          // par semaine
    delai: moyenne(journal.map((d) => d.t - d.commit)),            // heures
    tauxEchec: echecs.length / journal.length,
    retablissement: moyenne(echecs.map((d) => d.retabli - d.t)),   // heures
  };
}

function classer(i) {
  // Seuils simplifiés d'après les paliers DORA.
  const niveau = (v, s) => (v <= s[0] ? "élite" : v <= s[1] ? "haute" : v <= s[2] ? "moyenne" : "faible");
  const inverse = (v, s) => (v >= s[0] ? "élite" : v >= s[1] ? "haute" : v >= s[2] ? "moyenne" : "faible");
  return {
    frequence: inverse(i.frequence, [7, 1, 0.25]),
    delai: niveau(i.delai, [1, 24, 168]),
    tauxEchec: niveau(i.tauxEchec, [0.15, 0.3, 0.45]),
    retablissement: niveau(i.retablissement, [1, 24, 168]),
  };
}

console.log("— 1. deux équipes, un mois d'observation —");
for (const [nom, j] of [["équipe A", JOURNAL_A], ["équipe B", JOURNAL_B]]) {
  const i = indicateurs(j, 720), c = classer(i);
  console.log("   " + nom);
  console.log("      fréquence      " + i.frequence.toFixed(1).padStart(6) + " /semaine   " + c.frequence);
  console.log("      délai          " + i.delai.toFixed(1).padStart(6) + " h          " + c.delai);
  console.log("      taux d'échec   " + (i.tauxEchec * 100).toFixed(0).padStart(6) + " %          " + c.tauxEchec);
  console.log("      rétablissement " + i.retablissement.toFixed(1).padStart(6) + " h          " + c.retablissement);
}
console.log("   L'équipe A n'est pas « meilleure » : elle a un FLUX différent, et");
console.log("   les quatre indicateurs basculent ENSEMBLE. C'est le point à vérifier.");

console.log("");
console.log("— 2. la taille des lots explique tout —");
function simuler(modificationsParMois, deploiementsParMois) {
  const parLot = modificationsParMois / deploiementsParMois;
  const probaEchec = Math.min(0.9, 1 - Math.pow(0.995, parLot));
  const diagnostic = 0.5 + parLot * 0.15;
  return { parLot, probaEchec, diagnostic };
}
console.log("   déploiements/mois | modifs/lot | taux d'échec | rétablissement");
for (const d of [1, 2, 4, 12, 30, 120, 240]) {
  const s = simuler(240, d);
  console.log("   " + String(d).padStart(17) + " | " + String(s.parLot).padStart(10) +
    " | " + (s.probaEchec * 100).toFixed(0).padStart(11) + " %" +
    " | " + s.diagnostic.toFixed(1).padStart(11) + " h");
}
console.log("   Même équipe, même volume de travail, même rythme de frappe : on n'a");
console.log("   changé QUE la fréquence de livraison, et les deux indicateurs de");
console.log("   STABILITÉ suivent la vitesse. Le compromis supposé entre les deux");
console.log("   n'existe pas — c'est l'accumulation en gros lots qui produit à la");
console.log("   fois la lenteur et l'instabilité.");

console.log("");
console.log("— 3. le piège de mesure —");
const avant = { frequence: 4 / 4.3, delai: 300, tauxEchec: 0.10, retablissement: 40 };
const apres = { frequence: 30 / 4.3, delai: 40, tauxEchec: 0.45, retablissement: 40 };
for (const [nom, i] of [["avant", avant], ["après", apres]]) {
  const c = classer(i);
  console.log("   " + nom + " : fréquence " + c.frequence.padEnd(8) +
    " | délai " + c.delai.padEnd(8) + " | échec " + c.tauxEchec);
}
console.log("   La vitesse a bondi, la stabilité s'est effondrée : l'équipe a");
console.log("   déplacé le problème, pas amélioré son flux. Les quatre indicateurs");
console.log("   se lisent ENSEMBLE, jamais un seul — et jamais pour évaluer");
console.log("   quelqu'un, sous peine de les rendre immédiatement inutiles.");

Avant de commencer

• Git installé, et un dépôt public actif de votre choix cloné en local
• Un tableur ou un langage de script pour les calculs

Énoncé

1. Extraire l'historique des livraisons — Clonez un dépôt public qui publie des versions étiquetées, et sortez la liste de ses étiquettes avec leur date. Vous voulez une ligne par livraison. Indice : git tag --sort=creatordate --format='%(creatordate:short) %(refname:short)' donne exactement cela.
2. Calculer la fréquence de déploiement — Sur les six derniers mois, combien de livraisons par semaine ? Situez le résultat dans les paliers du cours : élite, haute, moyenne, faible.
3. Calculer le délai de livraison — Pour cinq étiquettes prises au hasard, mesurez l'écart entre la date du commit le plus ancien qu'elles contiennent et la date de l'étiquette. C'est une approximation du délai entre l'écriture et la mise à disposition. Indice : git log --format=%ci v1.2.0..v1.3.0 | tail -1 donne la date du premier commit de l'intervalle.
4. Estimer les deux indicateurs de stabilité — Cherchez les versions correctives publiées moins de 48 h après une version : ce sont vos candidats « échec de changement ». Le délai entre les deux approxime le temps de rétablissement.
5. Rédiger un post-mortem — À partir de l'incident fourni ci-dessous, écrivez un compte rendu en cinq parties. INCIDENT : le 14 mars à 10 h 04, un déploiement fait passer le taux d'erreur de 0,1 % à 4 %. L'alerte part à 10 h 31. La cause est comprise à 10 h 44 : une migration a renommé une colonne, et l'ancienne version des travailleurs de fond, non redéployée, échouait. Retour arrière à 10 h 46 — sans effet, la colonne étant déjà renommée. Correctif appliqué à 11 h 20. Indice : Les cinq parties : ce qui s'est passé, la chronologie, l'impact MESURÉ, pourquoi c'était possible, et les actions avec responsable et échéance.

C'est réussi quand

• ✓ Vos quatre indicateurs sont chiffrés, et vous savez dire dans quel palier se situe le dépôt
• ✓ Votre post-mortem ne nomme personne
• ✓ Chacune de vos actions correctives est vérifiable et porte une échéance

Correction

git tag --sort=creatordate \
--format='%(creatordate:short) %(refname:short)' | tail -40

# Délai de livraison pour une étiquette donnée
git log --format=%ci v1.2.0..v1.3.0 | tail -1   # premier commit
git log -1 --format=%ci v1.3.0                   # publication

Point de départ

// ── 1. Fusion contre rebasage ─────────────────────────────────────────────
// Un commit : identifiant, message, parents.
let compteur = 0;
const commit = (msg, parents) => ({ id: "c" + (++compteur), msg, parents });

function creerDepot() {
  const a = commit("A : socle", []);
  const b = commit("B : lecture config", [a]);
  const c = commit("C : correctif principal", [b]);      // sur main
  const d = commit("D : début fonctionnalité", [b]);     // sur la branche
  const e = commit("E : fin fonctionnalité", [d]);
  return { a, b, c, d, e };
}

function fusionner(depot) {
  // La fusion CONSERVE d et e tels quels, et crée un commit à deux parents.
  const m = commit("M : fusion de la branche", [depot.c, depot.e]);
  return [depot.a, depot.b, depot.c, depot.d, depot.e, m];
}

function rebaser(depot) {
  // ← à écrire : rejouer d et e AU-DESSUS de c. Ce sont de NOUVEAUX commits.
  return [];
}

function afficher(nom, commits) {
  console.log("   " + nom);
  for (const c of commits) {
    const p = c.parents.map((x) => x.id).join(", ") || "—";
    console.log("      " + c.id.padEnd(4) + c.msg.padEnd(28) + "parents : " + p);
  }
}

// ── 2. Effet de la durée de vie des branches ──────────────────────────────
// Modèle simple : chaque jour, chaque contributeur produit une modification.
// Une branche accumule ses modifications jusqu'à son intégration. Le risque
// de conflit croît avec le nombre de modifications faites AILLEURS pendant
// qu'elle vivait.
function simuler({ contributeurs, jours, dureeBranche }) {
  const modifsParJour = contributeurs;
  const integrations = Math.floor(jours / dureeBranche) * contributeurs;
  const tailleLot = dureeBranche;                    // modifications par lot
  const modifsAilleurs = 0;                          // ← à écrire
  const probaConflit = 0;                            // ← à écrire
  return { integrations, tailleLot, modifsAilleurs, probaConflit,
           delaiIntegration: dureeBranche / 2 };
}

// ── À VOUS ────────────────────────────────────────────────────────────────
// 1. Écrivez rebaser(). Comparez les identifiants : que constate-t-on, et
//    pourquoi ne rebase-t-on pas une branche partagée ?
// 2. Complétez simuler() : pendant qu'une branche vit d jours, les autres
//    contributeurs produisent (contributeurs − 1) × d modifications.
//    La probabilité de conflit croît avec ce nombre.
// 3. Comparez GitFlow (branches de 15 jours) et trunk-based (0,5 jour) sur
//    six contributeurs et trois mois. Reliez aux indicateurs DORA.

const d = creerDepot();
afficher("après fusion", fusionner(d));

Solution

let compteur = 0;
const commit = (msg, parents) => ({ id: "c" + (++compteur), msg, parents });

function creerDepot() {
  const a = commit("A : socle", []);
  const b = commit("B : lecture config", [a]);
  const c = commit("C : correctif principal", [b]);
  const d = commit("D : début fonctionnalité", [b]);
  const e = commit("E : fin fonctionnalité", [d]);
  return { a, b, c, d, e };
}

function fusionner(depot) {
  const m = commit("M : fusion de la branche", [depot.c, depot.e]);
  return [depot.a, depot.b, depot.c, depot.d, depot.e, m];
}

function rebaser(depot) {
  // On ne DÉPLACE pas d et e : on les REJOUE au-dessus de c, ce qui produit
  // deux commits neufs. Les originaux deviennent inatteignables.
  const dPrime = commit("D' : début fonctionnalité (rejoué)", [depot.c]);
  const ePrime = commit("E' : fin fonctionnalité (rejoué)", [dPrime]);
  return [depot.a, depot.b, depot.c, dPrime, ePrime];
}

function afficher(nom, commits) {
  console.log("   " + nom);
  for (const c of commits) {
    const p = c.parents.map((x) => x.id).join(", ") || "—";
    console.log("      " + c.id.padEnd(5) + c.msg.padEnd(36) + "parents : " + p);
  }
}

console.log("— 1. deux façons d'intégrer le même travail —");
const d1 = creerDepot();
afficher("FUSION : l'histoire est conservée, le graphe se ramifie", fusionner(d1));
console.log("");
const d2 = creerDepot();
const apres = rebaser(d2);
afficher("REBASAGE : une ligne droite, mais des commits NEUFS", apres);
console.log("");
console.log("   Le contenu final est le même. Les identifiants, non : D et E");
console.log("   n'existent plus, remplacés par D' et E'. Tant que la branche est");
console.log("   locale, personne ne s'en aperçoit — c'est l'usage recommandé. Si");
console.log("   un collègue avait déjà récupéré D et E, son dépôt contient une");
console.log("   histoire que le vôtre ne connaît plus, et Git voit deux lignées");
console.log("   divergentes. On réécrit ce qu'on n'a pas partagé, jamais l'inverse.");

console.log("");
console.log("— 2 et 3. l'effet de la durée de vie des branches —");
function simuler({ nom, contributeurs, jours, dureeBranche }) {
  const integrations = Math.round((jours / dureeBranche) * contributeurs);
  const tailleLot = dureeBranche;
  // Pendant qu'une branche vit d jours, les AUTRES produisent leurs propres
  // modifications sur la même base : c'est là que naissent les conflits.
  const modifsAilleurs = (contributeurs - 1) * dureeBranche;
  const probaConflit = Math.min(0.95, 1 - Math.pow(0.97, modifsAilleurs));
  return { nom, integrations, tailleLot, modifsAilleurs, probaConflit,
           delaiIntegration: dureeBranche / 2 };
}

const scenarios = [
  { nom: "GitFlow (branches de 15 j)", contributeurs: 6, jours: 90, dureeBranche: 15 },
  { nom: "intermédiaire (3 j)",        contributeurs: 6, jours: 90, dureeBranche: 3 },
  { nom: "trunk-based (0,5 j)",        contributeurs: 6, jours: 90, dureeBranche: 0.5 },
];
console.log("   stratégie                  | intégrations | modifs/lot | conflit | délai");
for (const s of scenarios) {
  const r = simuler(s);
  console.log("   " + r.nom.padEnd(26) + " | " + String(r.integrations).padStart(12) +
    " | " + String(r.tailleLot).padStart(10) +
    " | " + (r.probaConflit * 100).toFixed(0).padStart(6) + " %" +
    " | " + r.delaiIntegration.toFixed(1).padStart(4) + " j");
}
console.log("   Six contributeurs, trois mois, même volume de travail. Seule change");
console.log("   la durée de vie des branches — et l'on retrouve exactement les");
console.log("   quatre indicateurs du chapitre 1 : la taille des lots gouverne le");
console.log("   délai d'intégration, la fréquence, et le risque.");
console.log("   Une branche de trois semaines EST un lot de trois semaines : un");
console.log("   pipeline qui déploie dix fois par jour n'y change rien, il rend");
console.log("   seulement visible plus tôt un problème constitué depuis longtemps.");

Avant de commencer

• Une machine Linux ou un WSL, avec Git, Node et curl
• L'archive de l'application tickets fournie par l'enseignant

Énoncé

1. Lancer l'application, et échouer — Démarrez l'application fournie, puis tentez de l'atteindre depuis un autre terminal avec curl. Elle ne répond pas. Ne modifiez rien tant que vous n'avez pas suivi les quatre questions du diagnostic. Indice : Le nom se résout-il ? Le port est-il écouté, et sur quelle interface ? La requête arrive-t-elle jusqu'au service ? Que répond-elle ?
2. Identifier l'interface d'écoute — Listez ce qui écoute sur la machine et comparez l'adresse d'écoute à celle que vous interrogez. Corrigez la configuration, sans toucher au code métier. Indice : ss -tlnp montre l'adresse ET le port. Une application liée à 127.0.0.1 est injoignable de l'extérieur.
3. Vérifier les droits — Le script de démarrage fourni n'est pas exécutable. Rendez-le exécutable pour son seul propriétaire, sans donner de droit d'écriture au groupe ni aux autres. Écrivez la valeur octale que vous employez et justifiez-la.
4. Créer le dépôt et sa stratégie — Initialisez un dépôt, poussez-le, protégez la branche principale, et écrivez un fichier CONTRIBUTING.md qui fixe la stratégie de branchement : durée de vie maximale d'une branche, taille maximale d'une demande de fusion, et délai maximal de relecture.
5. Fusion contre rebasage, sur un vrai conflit — À deux, modifiez la même ligne du même fichier sur deux branches. Intégrez la première par fusion, la seconde par rebasage. Comparez les deux historiques obtenus, puis dites laquelle des deux opérations vous vous interdiriez si la branche avait déjà été poussée. Indice : git log --graph --oneline --all rend la différence de forme immédiatement visible.

C'est réussi quand

• ✓ curl obtient une réponse depuis un autre terminal, et vous savez dire quelle question du diagnostic a révélé la cause
• ✓ Le script démarre et ses droits sont justifiés
• ✓ La branche principale refuse un push direct
• ✓ Vous savez énoncer la règle sur le rebasage d'une branche partagée

Correction

dig +short localhost           # 1. le nom se résout
ss -tlnp | grep 3000           # 2. LISTEN 127.0.0.1:3000  <-- la cause
curl -v http://localhost:3000  # 3. la requête n'arrive pas
# rien dans les journaux du service : le problème est en amont

chmod 744 demarrer.sh
# 7 = rwx pour le propriétaire
# 4 = r-- pour le groupe et les autres : lecture seule

## Branches
- Une branche par tâche, DURÉE DE VIE MAXIMALE : 1 jour ouvré.
- Intégration dans main au moins une fois par jour.
- Le travail inachevé est masqué par un drapeau de fonctionnalité,
jamais isolé dans une branche longue.

## Demandes de fusion
- 400 lignes modifiées au maximum ; au-delà, découper.
- Relecture sous 4 h ouvrées.
- Rebasage sur main AVANT la demande, jamais après partage.

git log --graph --oneline --all

*   9f2a1c4 (main) Merge branch 'ajout-filtre'     <-- fusion : le graphe fourche
|\
| * 3d8e7b1 ajout du filtre
* | 7c4b9a2 correctif du tri
|/
* 1a2b3c4 socle

* 5e6f7a8 (main) ajout du filtre (rejoué)          <-- rebasage : ligne droite
* 7c4b9a2 correctif du tri
* 1a2b3c4 socle