Qu'est-ce que l'abstraction en programmation ?

Quand tu écris print("hi"), tu ne penses pas à la façon dont ces lettres arrivent à l'écran. Sous cette seule ligne, Python transforme le texte en octets et demande au système d'exploitation de les écrire, le système d'exploitation les transmet à ton terminal, et le terminal dessine chaque lettre en pixels à l'aide d'une police. Chaque couche fait une promesse simple à la couche du dessus et cache comment elle tient cette promesse. Ce masquage, c'est l'abstraction, et chaque programme repose sur de nombreuses couches de ce genre.

Les niveaux d'abstraction

Chaque niveau est construit à partir de celui du dessous et peut se comprendre sans lui. Tu peux écrire du Python qui marche sans savoir ce qu'est un bloc de disque, et le système d'exploitation peut stocker un fichier sans savoir qu'il contient du code Python.

Comment fonctionne l'abstraction dans le code

Les programmeurs construisent leurs propres couches de deux façons principales.

L'abstraction procédurale, c'est une fonction. Son nom, ses paramètres et sa valeur de retour forment l'interface ; le corps est le détail caché. Une fois que average(scores) existe, le reste du programme l'utilise sans lire comment elle additionne et divise.

L'abstraction des données définit un type par ce qu'on peut en faire, pas par la façon dont il stocke les choses. Une file, c'est « ajouter à l'arrière, prendre à l'avant ». La façon dont les éléments sont rangés en mémoire est une décision privée :

from collections import deque

class Queue:
    """First in, first out. Callers only see add() and next()."""
    def __init__(self):
        self._items = deque()     # swap this for a list and callers never notice
    def add(self, item):
        self._items.append(item)
    def next(self):
        return self._items.popleft()
    def __len__(self):
        return len(self._items)

orders = Queue()
for dish in ["soup", "pasta", "cake"]:
    orders.add(dish)
while len(orders):
    print("serving", orders.next())

serving soup
serving pasta
serving cake

Le code du bas ne sait rien de deque. Si tu le remplaces par une simple liste et pop(0), la sortie est identique, seulement plus lente pour les longues files, car retirer le premier élément d'une liste déplace tous les autres. L'interface est restée la même, donc rien à l'extérieur de la classe n'a eu à changer.

Classes abstraites et interfaces

En programmation orientée objet, l'abstraction consiste généralement à énoncer ce que doit faire une famille de classes en laissant le comment à chaque classe. En Python, le module abc marque une méthode comme abstraite ; une classe qui a une méthode abstraite non implémentée ne peut pas être instanciée :

from abc import ABC, abstractmethod

class Notifier(ABC):
    @abstractmethod
    def send(self, to, text):
        """Every notifier must say how it sends a message."""

class Email(Notifier):
    def send(self, to, text):
        print(f"email to {to}: {text}")

class SMS(Notifier):
    def send(self, to, text):
        print(f"sms to {to}: {text}")

def remind(notifier, user):
    notifier.send(user, "Your package arrives today")

remind(Email(), "ana@example.com")
remind(SMS(), "+15550100")
try:
    Notifier()
except TypeError:
    print("Notifier is abstract: create an Email or an SMS instead")

email to ana@example.com: Your package arrives today
sms to +15550100: Your package arrives today
Notifier is abstract: create an Email or an SMS instead

remind() ne dépend que de l'abstraction : n'importe quoi qui a une méthode send. Ajouter les notifications push revient à écrire une nouvelle classe, et remind() reste intact. Cette dernière étape, un seul appel qui exécute un code différent selon la classe, c'est le polymorphisme : l'abstraction définit l'interface commune, le polymorphisme la fait fonctionner.

Java propose les mêmes outils sous forme de mots-clés :

interface Notifier {
    void send(String to, String text);
}

class Email implements Notifier {
    public void send(String to, String text) { /* talk to the mail server */ }
}

Écrire new Notifier() provoque une erreur de compilation, car une interface n'a aucune implémentation à exécuter. La documentation explique en détail les classes abstraites et les interfaces en Java.

Abstraction et encapsulation

Les deux idées apparaissent si souvent ensemble qu'on les confond facilement.

L'abstraction décide quelles opérations montrer ; l'encapsulation garantit que le reste reste caché. La Queue ci-dessus fait les deux : add et next sont l'abstraction, et l'underscore de _items est l'encapsulation.

Abstractions qui fuient et autres erreurs

Joel Spolsky a formulé la loi des abstractions qui fuient (law of leaky abstractions) en 2002 : toute abstraction non triviale laisse passer une partie des détails cachés. Les nombres à virgule flottante sont la fuite classique. Ils ressemblent à des décimaux ordinaires, jusqu'à ce que le stockage binaire en dessous apparaisse :

print(0.1 + 0.2)
print(0.1 + 0.2 == 0.3)

0.30000000000000004
False

Ni 0,1 ni 0,2 ne peuvent être stockés exactement en bits, donc la somme est légèrement fausse. Tu peux utiliser des floats pendant des années sans y penser, mais pas indéfiniment, et c'est pour cela qu'il est utile de connaître la couche située juste en dessous de celle où tu travailles.

Deux autres erreurs sont courantes :

• Abstraire trop tôt. Une hiérarchie de classes construite pour des cas qui n'arrivent jamais, c'est du code en plus à lire et à modifier. Sandi Metz l'a résumé ainsi : « la duplication coûte bien moins cher que la mauvaise abstraction ».
• Confondre l'abstraction avec le mot-clé abstract. Les classes abstraites sont un outil parmi d'autres. Chaque fonction bien nommée est aussi une abstraction.

Pour aller plus loin

Lis les pages sur l'encapsulation et le polymorphisme pour compléter le tableau de la programmation orientée objet. La page sur le système d'exploitation montre la plus grande abstraction sur laquelle reposent tes programmes. Pour t'entraîner, le cours Python construit des classes et des fonctions dès le début, et le cours Java couvre les classes abstraites et les interfaces.