¿Qué es la abstracción en programación?

Cuando escribes print("hi"), no piensas en cómo llegan esas letras a la pantalla. Debajo de esa línea, Python convierte el texto en bytes y le pide al sistema operativo que los escriba, el sistema operativo se los pasa a tu terminal, y el terminal dibuja cada letra en píxeles con una fuente. Cada capa le ofrece a la de arriba una promesa sencilla y oculta cómo la cumple. Esa ocultación es la abstracción, y todo programa se apoya en muchas capas así.

Niveles de abstracción

Cada nivel está construido sobre el de abajo y se puede entender sin él. Puedes escribir Python que funciona sin saber qué es un bloque de disco, y el sistema operativo puede guardar un archivo sin saber que contiene código Python.

Cómo funciona la abstracción en el código

Los programadores construyen sus propias capas de dos formas principales.

La abstracción procedimental es una función. Su nombre, sus parámetros y su valor de retorno son la interfaz; el cuerpo es el detalle oculto. Una vez que existe average(scores), el resto del programa la usa sin leer cómo suma y divide.

La abstracción de datos define un tipo por lo que puedes hacer con él, no por cómo guarda las cosas. Una cola es "añadir al final, sacar del principio". Cómo se colocan los elementos en memoria es una decisión privada:

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

El código de abajo no sabe nada de deque. Si lo sustituyes por una lista normal y pop(0), la salida es idéntica, solo que más lenta con colas largas, porque quitar el primer elemento de una lista desplaza todos los demás. La interfaz se mantuvo igual, así que no hubo que cambiar nada fuera de la clase.

Clases abstractas e interfaces

En la programación orientada a objetos, la abstracción suele significar establecer qué debe hacer una familia de clases y dejar el cómo a cada clase. En Python, el módulo abc marca un método como abstracto; una clase con un método abstracto sin implementar no se puede instanciar:

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() solo depende de la abstracción: cualquier cosa con un método send. Añadir notificaciones push significa escribir una clase nueva, y remind() no se toca. Ese último paso, una sola llamada que ejecuta código distinto para clases distintas, es el polimorfismo: la abstracción define la interfaz común y el polimorfismo la hace funcionar.

Java tiene las mismas herramientas como palabras clave:

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

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

Escribir new Notifier() es un error de compilación, porque una interfaz no tiene ninguna implementación que ejecutar. La documentación explica en detalle las clases abstractas y las interfaces en Java.

Abstracción y encapsulamiento

Las dos ideas aparecen juntas tan a menudo que es fácil confundirlas.

La abstracción decide qué operaciones mostrar; el encapsulamiento se asegura de que el resto quede oculto. La Queue de arriba hace las dos cosas: add y next son la abstracción, y el guion bajo de _items es el encapsulamiento.

Abstracciones con fugas y otros errores

Joel Spolsky formuló en 2002 la ley de las abstracciones con fugas (leaky abstractions): toda abstracción no trivial deja pasar parte del detalle oculto. Los números de coma flotante son la fuga clásica. Parecen decimales normales, hasta que se asoma el almacenamiento binario que hay debajo:

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

0.30000000000000004
False

Ni 0,1 ni 0,2 se pueden guardar exactamente en bits binarios, así que la suma sale un poco desviada. Puedes usar floats durante años sin pensar en esto, pero no para siempre, y por eso ayuda conocer una capa por debajo de aquella en la que trabajas.

Hay dos errores más que son frecuentes:

• Abstraer demasiado pronto. Una jerarquía de clases pensada para casos que nunca llegan es código de más que leer y cambiar. Sandi Metz lo resumió así: "la duplicación es mucho más barata que la abstracción equivocada".
• Confundir la abstracción con la palabra clave abstract. Las clases abstractas son una herramienta. Toda función con un buen nombre también es una abstracción.

Qué leer después

Lee encapsulamiento y polimorfismo para completar el panorama de la orientación a objetos. La página del sistema operativo muestra la mayor abstracción de la que dependen tus programas. Para practicar, el curso de Python construye clases y funciones desde el principio, y el curso de Java cubre las clases abstractas y las interfaces.