Cos'è l'astrazione in programmazione?

Quando scrivi print("hi"), non pensi a come quelle lettere arrivano sullo schermo. Sotto quella riga, Python trasforma il testo in byte e chiede al sistema operativo di scriverli, il sistema operativo li passa al tuo terminale, e il terminale disegna ogni lettera in pixel usando un font. Ogni livello offre a quello sopra una promessa semplice e nasconde come la mantiene. Questo nascondere è l'astrazione, e ogni programma poggia su molti livelli di questo tipo.

Livelli di astrazione

Ogni livello è costruito su quello sottostante e si può capire senza di esso. Puoi scrivere Python funzionante senza sapere cos'è un blocco del disco, e il sistema operativo può salvare un file senza sapere che contiene codice Python.

Come funziona l'astrazione nel codice

Chi programma costruisce i propri livelli in due modi principali.

L'astrazione procedurale è una funzione. Il nome, i parametri e il valore restituito sono l'interfaccia; il corpo è il dettaglio nascosto. Una volta che average(scores) esiste, il resto del programma la usa senza leggere come somma e divide.

L'astrazione dei dati definisce un tipo in base a cosa puoi farci, non a come memorizza le cose. Una coda è "aggiungi in fondo, prendi dall'inizio". Come gli elementi stanno in memoria è una decisione privata:

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

Il codice in fondo non sa nulla di deque. Se lo sostituisci con una lista normale e pop(0), l'output è identico, solo più lento con code lunghe, perché togliere il primo elemento di una lista sposta tutti gli altri. L'interfaccia è rimasta la stessa, quindi niente fuori dalla classe ha dovuto cambiare.

Classi astratte e interfacce

Nella programmazione a oggetti, astrazione di solito significa stabilire cosa deve fare una famiglia di classi e lasciare il come a ciascuna classe. In Python, il modulo abc marca un metodo come astratto; una classe con un metodo astratto non implementato non può essere istanziata:

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() dipende solo dall'astrazione: qualsiasi cosa abbia un metodo send. Aggiungere le notifiche push significa scrivere una sola classe nuova, e remind() resta intatta. Quest'ultimo passo, una sola chiamata che esegue codice diverso per classi diverse, è il polimorfismo: l'astrazione definisce l'interfaccia comune, il polimorfismo la fa funzionare.

Java ha gli stessi strumenti sotto forma di parole chiave:

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

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

Scrivere new Notifier() è un errore di compilazione, perché un'interfaccia non ha un'implementazione da eseguire. La documentazione spiega nel dettaglio le classi astratte e le interfacce in Java.

Astrazione e incapsulamento

Le due idee compaiono insieme così spesso che è facile confonderle.

L'astrazione decide quali operazioni mostrare; l'incapsulamento si assicura che il resto resti nascosto. La Queue qui sopra fa entrambe le cose: add e next sono l'astrazione, e il trattino basso in _items è l'incapsulamento.

Astrazioni che perdono e altri errori

Joel Spolsky ha formulato nel 2002 la legge delle astrazioni che perdono (leaky abstractions): ogni astrazione non banale lascia trapelare parte del dettaglio nascosto. I numeri in virgola mobile sono la perdita classica. Sembrano normali decimali, finché non si intravede la memorizzazione binaria sottostante:

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

0.30000000000000004
False

Né 0,1 né 0,2 si possono memorizzare esattamente in bit binari, quindi la somma è leggermente sbagliata. Puoi usare i float per anni senza pensarci, ma non per sempre, ed è per questo che conviene conoscere un livello sotto quello in cui lavori.

Altri due errori sono comuni:

• Astrarre troppo presto. Una gerarchia di classi costruita per casi che non arrivano mai è codice in più da leggere e modificare. Sandi Metz l'ha detto così: "la duplicazione costa molto meno dell'astrazione sbagliata".
• Confondere l'astrazione con la parola chiave abstract. Le classi astratte sono uno strumento. Anche ogni funzione con un buon nome è un'astrazione.

Cosa leggere dopo

Leggi incapsulamento e polimorfismo per completare il quadro della programmazione a oggetti. La pagina sul sistema operativo mostra la più grande astrazione su cui si appoggiano i tuoi programmi. Per esercitarti, il corso Python costruisce classi e funzioni fin dall'inizio, e il corso Java tratta classi astratte e interfacce.