Une bonne abstraction cache ce qui change et expose ce qui dure. Une mauvaise cache ce qu'il faudrait voir.
⏱️ Durée : environ 80 minutes · 🎓 Niveau : intermédiaire · 🏅 Badge : Concepteur de contrats
🎬 L'histoire
HashBox veut pouvoir stocker les cours soit dans SQLite, soit dans des fichiers, soit chez un fournisseur cloud. Kodi crée une interface Stockage avec… 23 méthodes qui reflètent exactement l'API du fournisseur. Quand HashBox change de fournisseur, tout est à réécrire.
« Ton abstraction reproduit les détails au lieu de les cacher, dit Sam. Une interface doit être écrite pour les besoins du client, pas à l'image du fournisseur. »
Tu apprends à concevoir des interfaces qui durent.
🎯 Ta mission
À la fin, je serai capable de :
- définir interface, abstraction, implémentation et contrat
- concevoir une interface à partir des besoins du client
- écrire plusieurs implémentations interchangeables d'une même interface
- utiliser une fausse implémentation (fake) pour tester
- reconnaître les abstractions inutiles ou qui fuient (leaky abstractions)
🧩 Défi d'échauffement (5 XP)
Une prise électrique : n'importe quel appareil se branche, quelle que soit la centrale électrique derrière. Que doit garantir la prise (forme, tension) ? Que cache-t-elle ? Imagine maintenant une prise qui exposerait le type de centrale (nucléaire, solaire, charbon) : pourquoi ce serait un problème ?
💡 Le concept
Abstraction, interface, implémentation
- Abstraction : un modèle simplifié qui garde l'essentiel et cache les détails.
- Interface : l'ensemble des opérations qu'un client peut utiliser, avec leur contrat.
- Implémentation : la façon concrète de réaliser ce contrat.
Le client dépend de l'interface. On peut changer l'implémentation sans le toucher.
Définir une interface en Python
Avec Protocol (typage structurel : pas d'héritage nécessaire) :
from typing import Protocol
class DepotCours(Protocol):
def trouver(self, code: str) -> dict | None: ...
def ajouter(self, cours: dict) -> None: ...
def lister(self) -> list[dict]: ...
Avec une classe abstraite (ABC) : on impose l'héritage et on peut vérifier que les méthodes sont définies.
from abc import ABC, abstractmethod
class DepotCours(ABC):
@abstractmethod
def trouver(self, code): ...
Concevoir une bonne interface
- Partir du besoin du client : de quoi le code appelant a-t-il vraiment besoin ?
- Petite et ciblée (ségrégation) : quelques opérations bien choisies.
- Exprimée dans le vocabulaire du métier, pas du fournisseur (
marquer_comme_payee, pasexecute_sql_update). - Un contrat clair : préconditions, résultat, erreurs.
- Stable : l'interface change moins vite que les implémentations.
Plusieurs implémentations
Une même interface, des réalisations différentes : mémoire (tests), fichier, base SQL, service distant. Le code client ne sait pas laquelle il utilise.
Les doublures de test
| Doublure | Rôle |
|---|---|
| Fake | implémentation simplifiée mais fonctionnelle (dépôt en mémoire) |
| Stub | renvoie des réponses prédéfinies |
| Mock | vérifie qu'on l'a appelé comme prévu |
| Spy | enregistre les appels pour les vérifier après |
Les fakes donnent souvent les tests les plus lisibles.
Quand NE PAS abstraire
- Règle de trois : on abstrait au troisième cas semblable, pas au premier. Une abstraction prématurée devine mal les besoins futurs.
- Une interface avec une seule implémentation qui ne changera jamais est souvent du bruit.
- Une abstraction qui ne cache rien (un simple renommage de l'API du fournisseur) ajoute une couche sans valeur.
Les abstractions qui fuient
La loi des abstractions qui fuient : toute abstraction non triviale laisse transpirer ses détails. Exemples : un dépôt « générique » dont les requêtes deviennent lentes selon le fournisseur ; une interface « fichier » qui masque la latence réseau. Mieux vaut une abstraction honnête sur ses limites (délais d'attente, erreurs possibles) qu'une abstraction qui promet l'impossible.
🔍 Exemple pas à pas
Problème : un dépôt de cours avec deux implémentations interchangeables et un service qui ne sait rien du stockage.
from typing import Protocol
import sqlite3
class DepotCours(Protocol):
def trouver(self, code: str) -> dict | None: ...
def ajouter(self, cours: dict) -> None: ...
def lister(self) -> list[dict]: ...
class DepotMemoire:
"""Fake : parfait pour les tests."""
def __init__(self):
self._cours = {}
def trouver(self, code):
return self._cours.get(code)
def ajouter(self, cours):
if cours["code"] in self._cours:
raise ValueError("code déjà utilisé")
self._cours[cours["code"]] = dict(cours)
def lister(self):
(._cours.values(), key= c: c[])
:
():
._bd = sqlite3.connect()
._bd.execute()
():
ligne = ._bd.execute(, (code,)).fetchone()
{: ligne[], : ligne[]} ligne
():
:
._bd:
._bd.execute(, (cours[], cours[]))
sqlite3.IntegrityError:
ValueError()
():
[{: c, : t} c, t ._bd.execute()]
:
():
.depot = depot
():
titre.strip():
ValueError()
.depot.ajouter({: code, : titre.strip()})
():
cours = .depot.trouver(code)
cours[] cours
depot (DepotMemoire(), DepotSQLite()):
catalogue = Catalogue(depot)
catalogue.publier(, )
catalogue.publier(, )
catalogue.titre_de() ==
catalogue.titre_de() ==
:
catalogue.publier(, )
AssertionError()
ValueError:
[c[] c depot.lister()] == [, ]
()
Lecture :
- la même suite de vérifications s'applique à toutes les implémentations : c'est un test de contrat ;
- les tests rapides du service utilisent le fake mémoire ; un test plus lent vérifie que
DepotSQLiterespecte le contrat ; - le contrat inclut le comportement en cas d'erreur (
ValueErrorsur un doublon), pas seulement le cas heureux : c'est ce que l'on promet aux clients.
✍️ À toi, avec aide (10 XP)
Conçois l'interface d'un service d'envoi de messages pour HashBox :
- Écris la liste des besoins du client (le code qui notifie les membres) en une phrase.
- Définis un
ProtocolMessagerieminimal. - Écris deux implémentations :
MessagerieConsole(affiche) etMessagerieEnregistrement(garde les messages en mémoire, pour les tests). - Écris un
ServiceBienvenuequi reçoit uneMessagerieet teste-le avec l'enregistrement.
💡 Indice 1
Le besoin : « envoyer un texte à une adresse ».
💡 Indice 2
Une seule méthode suffit : envoyer(destinataire, texte).
💡 Indice 3
L'enregistrement garde une liste de tuples (destinataire, texte).
✅ Réponse
from typing import Protocol
class Messagerie(Protocol):
def envoyer(self, destinataire: str, texte: str) -> None: ...
class MessagerieConsole:
def envoyer(self, destinataire, texte):
print(f"[à {destinataire}] {texte}")
class MessagerieEnregistrement:
def __init__(self):
self.messages = []
def envoyer(self, destinataire, texte):
self.messages.append((destinataire, texte))
class ServiceBienvenue:
def __init__(self, messagerie: Messagerie):
self.messagerie = messagerie
def accueillir(self, nom, email):
self.messagerie.envoyer(email, f"Bienvenue {nom} sur HashBox !")
m = MessagerieEnregistrement()
ServiceBienvenue(m).accueillir(, )
m.messages == [(, )]
ServiceBienvenue(MessagerieConsole()).accueillir(, )
🚀 À toi, en solo (20 XP)
Test de contrat réutilisable. Écris une fonction verifier_contrat_depot(creer_depot) qui reçoit une fabrique de dépôts et vérifie le contrat suivant (pour une interface DepotMembres avec ajouter(nom, email), par_email(email), supprimer(email), compter()) :
- ajouter puis retrouver par e-mail ;
- ajouter un e-mail en double lève
ValueError; - supprimer un e-mail inexistant lève
KeyError; compterreflète les ajouts et suppressions ;- la recherche par e-mail est insensible à la casse.
Implémente deux dépôts (mémoire et SQLite) et vérifie que les deux passent. Introduis volontairement un bug dans l'un et montre que le test de contrat l'attrape.
✅ Pistes de correction
import sqlite3
class DepotMemoire:
def __init__(self):
self._d = {}
def ajouter(self, nom, email):
cle = email.lower()
if cle in self._d:
raise ValueError("e-mail déjà utilisé")
self._d[cle] = nom
def par_email(self, email):
nom = self._d.get(email.lower())
return None if nom is None else {"nom": nom, "email": email.lower()}
def supprimer(self, email):
del self._d[email.lower()]
def compter(self):
return len(self._d)
class DepotSQLite:
def __init__(self):
self._bd = sqlite3.connect()
._bd.execute()
():
:
._bd:
._bd.execute(, (email.lower(), nom))
sqlite3.IntegrityError:
ValueError()
():
r = ._bd.execute(, (email.lower(),)).fetchone()
r {: r[], : r[]}
():
._bd:
._bd.execute(, (email.lower(),)).rowcount == :
KeyError(email)
():
._bd.execute().fetchone()[]
():
d = creer_depot()
d.ajouter(, )
d.par_email()[] ==
d.compter() ==
:
d.ajouter(, ); AssertionError()
ValueError:
:
d.supprimer(); AssertionError()
KeyError:
d.supprimer()
d.compter() == d.par_email()
fabrique (DepotMemoire, DepotSQLite):
verifier_contrat_depot(fabrique)
()
():
():
email ._d:
ValueError
._d[email] = nom
:
verifier_contrat_depot(DepotBogue)
(AssertionError, KeyError, ValueError, TypeError):
()
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Interface calquée sur le fournisseur | Changer de fournisseur = tout réécrire | Interface dans le vocabulaire du métier |
| Abstraire trop tôt | Interface devinée, mal ajustée | Règle de trois |
| Interface trop large | Implémentations pénibles | Petites interfaces ciblées |
| Contrat non testé | Les implémentations divergent | Test de contrat commun |
🐉 Mini-boss (40 XP)
Architecture de stockage de fichiers. HashBox stocke des supports de cours. Besoins du client : enregistrer(nom, contenu) -> identifiant, lire(identifiant) -> contenu, supprimer(identifiant), existe(identifiant).
- Définis l'interface
StockageFichiers. - Implémente trois versions : mémoire (fake), dossier local (fichiers sur disque dans un dossier temporaire) et une version qui ajoute de la compression autour d'un autre stockage (décorateur).
- Écris un test de contrat commun, y compris pour les erreurs (lire un identifiant inconnu).
- Écris un
ServiceSupportsqui dépend uniquement de l'interface et teste-le avec le fake. - Explique où l'abstraction fuit (latence, taille maximale, atomicité) et comment tu le documentes dans le contrat.
✅ Pistes de correction
Un bon travail : Protocol à quatre méthodes ; StockageMemoire (dictionnaire) ; StockageDossier (identifiant = hachage SHA-256 du contenu ou compteur, fichiers dans un TemporaryDirectory) ; StockageCompresse(stockage) qui compresse avec zlib à l'écriture et décompresse à la lecture, tout en respectant le même contrat ; FichierInconnu(KeyError) pour les lectures invalides ; test de contrat paramétré. Les fuites documentées : la lecture disque peut être lente et lever des OSError, la taille maximale diffère, l'écriture n'est pas atomique sans fichier temporaire + renommage.
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Une interface décrit :
- A. comment c'est implémenté
- B. la couleur de l'interface graphique
- C. ce qu'on peut faire, avec un contrat
2. Une doublure « fake » est :
- A. une implémentation simplifiée mais fonctionnelle
- B. un mot de passe
- C. un type d'index
3. Un test de contrat sert à :
- A. mesurer la vitesse
- B. vérifier que toutes les implémentations respectent le même comportement
- C. supprimer des bugs automatiquement
4. 🔁 Révision mission 04 : Un bon nom de fonction est généralement :
- A. une lettre
- B. un nombre
- C. un verbe qui exprime l'intention
5. 🔁 Révision mission 04 : Les retours anticipés servent à :
- A. réduire l'imbrication
- B. accélérer le code
- C. supprimer les tests
✅ Réponses
- C.
- A.
- B.
- C.
- A.
🪞 Je réfléchis (10 XP)
- Quelle « prise » (interface) stable utilises-tu au quotidien sans te soucier de ce qu'il y a derrière ?
- Quand as-tu abstrait trop tôt et regretté ?
🎒 À retenir
- Le client dépend de l'interface, pas de l'implémentation.
- Concevoir l'interface à partir du besoin du client.
- Fakes pour des tests rapides ; tests de contrat communs.
- Règle de trois avant d'abstraire.
- Toute abstraction non triviale fuit : documenter ses limites.
flowchart LR
T(["Interfaces et abstractions"])
T --> R1["1. Le client dépend de l'interface, pas de l'implémentation."]
T --> R2["2. Concevoir l'interface à partir du besoin du client."]
T --> R3["3. Fakes pour des tests rapides ; tests de contrat communs."]
T --> R4["4. Règle de trois avant d'abstraire."]
T --> R5["5. Toute abstraction non triviale fuit : documenter ses limites."]
Description du schéma : la mission au centre, reliée aux cinq idées à retenir.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Concepteur de contrats
← Mission 04 — Clean Code : écrire pour être lu · Mission 06 — Les patrons de conception →
HEF-080 — Génie logiciel

