Optimiser, ce n'est pas écrire du code astucieux : c'est suivre une méthode — mesurer, corriger un seul point, vérifier le résultat, protéger le gain.
⏱️ Durée : environ 115 minutes · 🎓 Niveau : avancé · 🏅 Badge : Optimiseur méthodique
🎬 L'histoire
Après quatre mois, HashBox a vu défiler une dizaine d'« optimisations ». Certaines ont réellement aidé. D'autres ont rendu le code illisible sans gain mesurable. Une a introduit un bug subtil : un cache qui renvoyait de vieux prix. Une autre a été défaite trois semaines plus tard, quand quelqu'un a modifié le code sans savoir que la performance en dépendait, et que personne n'a rien détecté.
« Une optimisation sans mesure est une opinion, dit Sam. Une optimisation sans test de correction est un pari. Une optimisation sans garde-fou est un souvenir. Il faut les trois : mesurer, vérifier, protéger. »
Dans cette dernière mission, tu appliques toute la méthode du module : baseline, hypothèse, changement unique, mesure, vérification d'équivalence, garde-fou de non-régression et rapport.
🎯 Ta mission
À la fin, je serai capable de :
- suivre le protocole baseline → hypothèse → changement → mesure → vérification
- décider si une optimisation vaut son coût (gain, complexité, maintenance)
- garantir l'équivalence fonctionnelle avant et après optimisation
- écrire des garde-fous déterministes (comptage d'opérations, tests de complexité) et relatifs
- rédiger un rapport de performance reproductible (protocole, données brutes, résultat)
🧩 Défi d'échauffement (5 XP)
Un garagiste dit : « Votre voiture consomme trop, j'ai remplacé le filtre à air, les bougies, le carburateur et réglé les pneus. » Elle consomme maintenant un peu moins. Peut-il dire laquelle de ces actions a servi ? Qu'aurait-il fallu faire pour le savoir, et pour que le gain ne disparaisse pas au prochain entretien ?
💡 Le concept
Le protocole d'optimisation
flowchart LR
B["1. Baseline"] --> P["2. Profiler"]
P --> H["3. Hypothèse"]
H --> C["4. Un seul changement"]
C --> M["5. Mesurer"]
M --> V["6. Vérifier l'équivalence"]
V --> G["7. Garde-fou"]
G --> B
Description du schéma : sept étapes en boucle : établir une baseline, profiler, formuler une hypothèse, appliquer un seul changement, mesurer, vérifier que le résultat est équivalent, puis poser un garde-fou avant de recommencer sur le point chaud suivant.
| Étape | Exigence |
|---|---|
| Baseline | charge représentative, protocole de la mission 2, données brutes conservées |
| Profiler | désigner le goulot par des mesures (mission 3) |
| Hypothèse | « si je fais X, Y devrait baisser de Z % parce que… » — falsifiable |
| Un changement | sinon on ne sait pas ce qui a aidé |
| Mesurer | mêmes conditions, intervalle d'incertitude |
| Vérifier | résultats identiques (tests, comparaison de sorties, propriétés) |
| Garde-fou | un test qui empêchera le retour en arrière |
Faut-il optimiser ?
Donald Knuth : « Nous devrions oublier les petites optimisations, disons 97 % du temps : l'optimisation prématurée est la racine de tous les maux. Pourtant, nous ne devrions pas laisser passer nos opportunités dans ces 3 % critiques. »
Calcule la valeur d'une optimisation :
gain = (temps économisé par exécution) × (nombre d'exécutions) × (valeur du temps/coût)
coût = temps de développement + complexité ajoutée × maintenance + risque de bug
Optimise si le gain l'emporte nettement, et si la performance est un besoin réel (budget dépassé, coût d'infrastructure, plaintes d'utilisateurs). Sinon, préfère la clarté.
Ordre des remèdes (du plus rentable au moins rentable)
- Ne pas faire le travail (supprimer, éviter les appels redondants) ;
- Faire moins (filtrer tôt, paginer, ne lire que les colonnes utiles) ;
- Mieux organiser : algorithme et structure de données (HEF-020, HEF-030) ;
- Faire une fois : cache, précalcul, regroupement (missions 6 à 8) ;
- Faire en parallèle (mission 9) ;
- Micro-optimiser (en dernier recours, sur le seul point chaud).
Vérifier l'équivalence
Une version plus rapide qui renvoie un résultat différent n'est pas une optimisation. Méthodes :
- tests existants (HEF-110) ;
- comparaison de sorties de l'ancienne et de la nouvelle version sur des milliers d'entrées aléatoires (tests différentiels, graine fixée) ;
- propriétés (le résultat est trié, la somme est conservée) ;
- conserver l'ancienne version comme référence dans les tests.
Garde-fous durables
Les tests de temps « il doit prendre moins de 50 ms » sont fragiles (dépendent de la machine). Mieux :
| Garde-fou | Principe | Fiabilité |
|---|---|---|
| Comptage d'opérations | compter requêtes SQL, allocations, comparaisons, appels réseau | déterministe |
| Test de complexité | vérifier que le nombre d'opérations croît linéairement quand N double | déterministe |
| Rapport relatif | la nouvelle version est ≥ 3 fois plus rapide que la référence (même machine, même exécution) | robuste |
| Budget absolu en CI | seuils larges sur machine dédiée | utile mais bruité |
| Surveillance en production | percentiles, alertes (HEF-120) | indispensable |
Le rapport de performance
| Section | Contenu |
|---|---|
| Question et contexte | quel problème, quel budget |
| Protocole | machine, version, données, nombre de répétitions, échauffement |
| Données brutes | fichier joint |
| Analyse | médiane, percentiles, intervalles |
| Goulot identifié | profil, preuve |
| Changement | description, diff, justification |
| Résultat avant/après | avec incertitude |
| Vérification | équivalence prouvée comment |
| Risques et coûts | complexité, maintenance, limites |
| Garde-fou |
Un lecteur doit pouvoir refaire la mesure et obtenir la même conclusion.
🧠 Astuce : la meilleure optimisation est souvent un changement d'échelle : au lieu de faire plus vite 1 000 petites requêtes, en faire une. Cherche les gains de ×10, ignore les gains de 5 %.
🔍 Exemple pas à pas
Problème : optimiser une fonction de recommandation en suivant le protocole : baseline chronométrée et profilée, trois changements successifs, équivalence vérifiée par comparaison différentielle, garde-fous déterministes (comptage d'opérations, test de complexité), et rapport.
import cProfile, io, math, pstats, random, statistics, time
# ---------------- le code d'origine ----------------
COMPTEURS = {"comparaisons": 0}
def recommander_v0(membres, historiques, cours_populaires, k=3):
# pour chaque membre, recommande les k cours les plus suivis par des membres « voisins » qu'il n'a pas déjà suivis
resultat = {}
for m in membres:
deja = historiques[m]
scores = {}
for autre in membres:
if autre == m:
continue
communs = 0
for c in historiques[autre]: # intersection par boucle imbriquée
for d in deja:
COMPTEURS["comparaisons"] += 1
if c == d: communs += 1
if communs >= 2:
for c in historiques[autre]:
if c not in deja:
scores[c] = scores.get(c, 0) + communs
classes = sorted(scores.items(), key=lambda kv: (-kv[1], kv[0]))
resultat[m] = [c for c, _ in classes[:k]]
return resultat
def ():
rng = random.Random(graine)
cours = [ i ((, n_membres // ))]
membres = [ i (n_membres)]
historiques = {m: rng.sample(cours, rng.randint(, )) m membres}
membres, historiques, cours
M, H, C = donnees()
():
mesures = []
_ (n):
d = time.perf_counter(); f(*args); mesures.append(time.perf_counter() - d)
statistics.median(mesures)
base = recommander_v0(M, H, C)
t0 = chrono(recommander_v0, M, H, C)
pr = cProfile.Profile(); pr.enable(); recommander_v0(M, H, C); pr.disable()
()
t0 >
():
ens = {m: (h) m, h historiques.items()}
resultat = {}
m membres:
deja, scores = ens[m], {}
autre membres:
autre == m:
communs = (ens[autre] & deja)
communs >= :
c historiques[autre]:
c deja:
scores[c] = scores.get(c, ) + communs
classes = (scores.items(), key= kv: (-kv[], kv[]))
resultat[m] = [c c, _ classes[:k]]
resultat
():
ens = {m: (h) m, h historiques.items()}
par_cours = {}
m membres:
c ens[m]: par_cours.setdefault(c, []).append(m)
resultat = {}
m membres:
deja, communs = ens[m], {}
c deja:
autre par_cours[c]:
autre != m: communs[autre] = communs.get(autre, ) +
scores = {}
autre, n communs.items():
n >= :
c historiques[autre]:
c deja: scores[c] = scores.get(c, ) + n
classes = (scores.items(), key= kv: (-kv[], kv[]))
resultat[m] = [c c, _ classes[:k]]
resultat
nom, f ((, recommander_v1), (, recommander_v2)):
t = chrono(f, M, H, C)
f(M, H, C) == base
()
graine ():
rng = random.Random(graine)
m, h, c = donnees(rng.randint(, ), graine)
ref = recommander_v0(m, h, c)
recommander_v1(m, h, c) == ref recommander_v2(m, h, c) == ref, graine
()
chrono(recommander_v2, M, H, C) < t0 /
():
m, h, c = donnees(n, graine=)
ens = {x: (v) x, v h.items()}; par_cours = {}
x m:
cc ens[x]: par_cours.setdefault(cc, []).append(x)
ops =
x m:
cc ens[x]: ops += (par_cours[cc])
ops
():
COMPTEURS[] =
m, h, c = donnees(n, graine=); recommander_v0(m, h, c); COMPTEURS[]
a0, b0 = operations_v0(), operations_v0()
a2, b2 = operations_v2(), operations_v2()
exposant0 = math.log2(b0 / a0); exposant2 = math.log2(b2 / a2)
()
exposant0 > exposant2 <
():
< operations_v2() / operations_v2() < ,
test_garde_fou_complexite()
()
rapport = {: , : (t0 * ),
: , : [, ],
: , : }
(rapport.values())
Lecture :
- La baseline est chronométrée (médiane de 5) et profilée. L'hypothèse n°1 vise le goulot identifié (l'intersection en boucle imbriquée) ; un seul changement à la fois.
- Après chaque changement, la sortie est identique à la référence — et pas seulement sur un exemple : 300 jeux aléatoires comparent v0, v1 et v2.
- Le garde-fou ne chronomètre pas (fragile) : il compte les opérations et vérifie que doubler les données ne fait que doubler (environ) le travail pour v2, alors que v0 le multipliait par ~4. Ce test est déterministe et indépendant de la machine.
- Le rapport reprend le protocole : question, baseline, goulot, changements, équivalence, garde-fou.
✍️ À toi, avec aide (10 XP)
Décide, chiffres à l'appui, si ces trois optimisations valent la peine :
- Une fonction exécutée 10 millions de fois par jour passe de 3 ms à 1 ms. Le travail coûte 1 jour de développement (400 €) ; un cœur de serveur coûte 0,04 €/heure. Complexité ajoutée : modérée.
- Une tâche manuelle exécutée 1 fois par mois passe de 20 min à 2 min. Le travail coûte 3 jours (1 200 €).
- Un traitement exécuté 50 fois par jour par des utilisateurs en attente : passe de 8 s à 2 s. Un utilisateur attendant coûte en moyenne 0,5 € de productivité par minute de plus. Le travail coûte 2 jours (800 €).
Pour chacun : gain annuel, coût, retour, décision.
💡 Indice 1
Gain annuel = temps économisé × fréquence × 365 × coût du temps.
💡 Indice 2
Pour (1), convertis les cœurs-secondes en cœurs-heures puis en €.
💡 Indice 3
Pour (3), le temps économisé est 6 s par exécution.
✅ Réponse
# 1. serveur : 2 ms économisées × 10 M/jour × 365 = 7,3 M s = 2 028 h → × 0,04 €
g1 = 0.002 * 10_000_000 * 365 / 3600 * 0.04
# 2. tâche mensuelle : 18 min × 12 = 216 min = 3,6 h ; au coût d'un salarié (≈ 40 €/h)
g2 = 18 * 12 / 60 * 40
# 3. utilisateurs : 6 s × 50 × 365 = 109 500 s = 1 825 min × 0,5 €
g3 = 6 * 50 * 365 / 60 * 0.5
for n, g, c in ((1, g1, 400), (2, g2, 1200), (3, g3, 800)):
print(f"cas {n} : gain annuel {g:8.0f} € | coût {c:5d} € | retour {g / c:5.2f} fois")
assert round(g1) == 81 and round(g2) == 144 and abs(g3 - 912.5) < 1
- 81 €/an pour un coût de 400 € : non rentable sur le seul coût de calcul (on le justifierait seulement si ces 3 ms étaient aussi de la latence ressentie par l'utilisateur).
🚀 À toi, en solo (20 XP)
Test d'exposant de complexité. Écris un outil exposant(f, tailles, mesurer) qui estime l'ordre de croissance d'une fonction :
- pour chaque taille N, produit la mesure (nombre d'opérations compté, ou temps médian) ;
- ajuste une droite sur
log(mesure)contrelog(N)(régression par moindres carrés) et renvoie la pente (l'exposant) et le coefficient de détermination R² ; - teste-le sur quatre fonctions de comportement connu (linéaire, N log N, quadratique, cubique) en comptant les opérations ;
- teste le garde-fou : une fonction qui devrait être linéaire mais devient quadratique est détectée ;
- applique-le à ta propre fonction de recommandation (v0, v1, v2) et compare les exposants.
✅ Pistes de correction
import math, random
def exposant(tailles, mesures):
xs, ys = [math.log(n) for n in tailles], [math.log(m) for m in mesures]
mx, my = sum(xs) / len(xs), sum(ys) / len(ys)
pente = sum((x - mx) * (y - my) for x, y in zip(xs, ys)) / sum((x - mx) ** 2 for x in xs)
residus = sum((y - (my + pente * (x - mx))) ** 2 for x, y in zip(xs, ys))
total = sum((y - my) ** 2 for y in ys)
return pente, 1 - residus / total if total else 1.0
def ops_lineaire(n):
c = 0
for _ in range(n): c += 1
return c
def ops_nlogn(n):
c = 0
_ (n): c += (, (math.log2(n)))
c
():
c =
i (n):
j (n): c +=
c
():
c =
i (n):
j (n):
k (n // ): c +=
c
TAILLES = [, , , , ]
nom, f ((, ops_lineaire), (, ops_nlogn), (, ops_quadratique), (, ops_cubique)):
p, r2 = exposant(TAILLES, [f(n) n TAILLES])
()
< exposant(TAILLES, [ops_lineaire(n) n TAILLES])[] <
< exposant(TAILLES, [ops_nlogn(n) n TAILLES])[] <
< exposant(TAILLES, [ops_quadratique(n) n TAILLES])[] <
< exposant(TAILLES, [ops_cubique(n) n TAILLES])[] <
():
p, _ = exposant(tailles, [f(n) n tailles])
p <= exposant_max,
garde_fou(ops_lineaire, TAILLES, )
:
garde_fou(ops_quadratique, TAILLES, ); SystemExit()
AssertionError e:
(, e)
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Optimiser sans mesure ni profil | On améliore ce qui est froid | Baseline, profil, hypothèse |
| Plusieurs changements à la fois | On ne sait pas ce qui a aidé | Un changement, une mesure |
| Ne pas vérifier l'équivalence | Une version rapide mais fausse | Tests différentiels, version de référence |
| Aucun garde-fou | Le gain disparaît au prochain changement | Comptage d'opérations, test de complexité, budget en CI |
🐉 Mini-boss (60 XP)
Dossier de performance complet de HashBox (projet de fin de module). Choisis le traitement de ton choix (ou prends « import des inscriptions + calcul des statistiques mensuelles + export ») avec un budget : 1 million d'enregistrements en moins de 10 secondes et moins de 200 Mo de mémoire.
- écris la version initiale et sa suite de tests de correction ;
- mesure la baseline avec ton banc (mission 2), temps et mémoire ;
- profile (CPU et mémoire), désigne les goulots avec preuves ;
- applique au moins quatre optimisations successives issues du module (algorithme/structure, E/S, base de données ou cache, concurrence), chacune avec hypothèse, mesure avec incertitude et vérification d'équivalence différentielle ;
- pose des garde-fous déterministes (opérations comptées, exposant, requêtes, allocations) et un garde-fou relatif ;
- décide à quel moment tu t'arrêtes (budget atteint, rendement décroissant) en chiffrant le coût/bénéfice ;
- rédige le rapport complet (protocole, données brutes, analyse, avant/après, risques, suite) et fournis un script qui reproduit toutes les mesures ;
- conclus par une rétrospective de 10 lignes : quelle optimisation a eu le meilleur rapport gain/effort, laquelle n'en valait pas la peine, et ce que tu changerais dans ta méthode.
✅ Pistes de correction
Un bon dossier : tableau d'étapes (changement, hypothèse, temps médian ± intervalle, mémoire, équivalence : 500 jeux aléatoires), gains typiques dans l'ordre (index/structure de données ×10-50, E/S regroupées ×5-20, cache ×2-5, parallélisme ×1,5-3 si applicable), rendement décroissant évident, garde-fous (test d'exposant, compteur de requêtes SQL, budget relatif ≥ 3× la référence), analyse coût/bénéfice justifiant l'arrêt, rapport reproductible (script unique). La rétrospective honnête mentionne au moins une idée qui n'a rien apporté ou qui a été abandonnée.
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Avant de modifier du code lent, il faut :
- A. mesurer et profiler pour identifier le goulot
- B. réécrire le code en C
- C. ajouter du cache partout
2. Après une optimisation, il faut vérifier que :
- A. le code est plus court
- B. le résultat est strictement équivalent à la version précédente
- C. le fichier est plus petit
3. Un garde-fou de performance robuste compte de préférence :
- A. les lignes de commentaires
- B. les fichiers du dépôt
- C. les opérations (requêtes, comparaisons) plutôt que les secondes
4. 🔁 Révision mission 09 : Les threads Python accélèrent surtout :
- A. les tâches limitées par les entrées-sorties (attentes)
- B. le calcul numérique pur
- C. la compilation
5. 🔁 Révision mission 09 : Face à une surcharge, la contre-pression consiste à :
- A. augmenter la file sans limite
- B. refuser ou ralentir le travail entrant plutôt que d'accumuler une file infinie
- C. redémarrer le serveur
✅ Réponses
- A.
- B.
- C.
- A.
- B.
🪞 Je réfléchis (10 XP)
- Quelle optimisation de ton projet a été faite sans mesure, et en connais-tu le gain réel ?
- Quel garde-fou protège aujourd'hui la performance de ton traitement le plus critique ?
🎒 À retenir
- Protocole : baseline, profil, hypothèse, un changement, mesure, équivalence, garde-fou.
- Ordre des remèdes : ne pas faire, faire moins, mieux organiser, faire une fois, en parallèle, micro-optimiser.
- Optimiser seulement si le gain l'emporte sur le coût et le risque.
- Garde-fous déterministes : opérations comptées, exposant de complexité.
- Rapport reproductible : protocole, données brutes, résultat avec incertitude.
🏅 Récompenses
Total possible : 120 XP · 🏅 Badge Optimiseur méthodique
← Mission 09 — Concurrence et charge
🎉 Félicitations
Tu as terminé HEF-130 — Performance. Tu sais modéliser la capacité d'un système, mesurer proprement avec une incertitude, profiler CPU et mémoire, optimiser entrées-sorties, réseau, requêtes et caches, raisonner sur concurrence et saturation, puis conduire et valider une optimisation avec des garde-fous durables.
→ Prochain module : HEF-140 — Systèmes distribués
HEF-130 — Performance

