Lenguajes y paradigmas de programación

Una línea como x = a + b expresa un cálculo sin mencionar ningún registro del procesador. La abstracción lo hace posible: un lenguaje oculta los detalles de niveles inferiores para que quien programa pueda centrarse en el trabajo que debe realizar el programa.

Qué ejecuta el procesador

El código máquina consiste en instrucciones codificadas como números binarios. La arquitectura del conjunto de instrucciones (ISA) de un procesador define sus instrucciones y sus codificaciones. x86-64 es habitual en computadoras personales y servidores; ARM es habitual en teléfonos, tabletas y muchos portátiles. El código construido para una ISA necesita traducción o emulación para funcionar en otra.

El sistema hexadecimal permite mostrar los bytes de las instrucciones de forma más breve. En x86-64, B8 01 00 00 00 coloca 1 en el registro EAX. Los bytes 01 D8 suman el valor de EBX a EAX. Los registros son pequeñas posiciones de almacenamiento dentro del procesador. Cada instrucción realiza una acción pequeña, como mover datos, sumar, comparar o saltar. El ciclo de búsqueda, decodificación y ejecución ejecuta estas instrucciones.

Nombres para las mismas acciones pequeñas

El lenguaje ensamblador sustituye los bytes de las instrucciones por nombres legibles llamados mnemónicos. Esas dos instrucciones de x86-64 pueden escribirse así:

mov eax, 1
add eax, ebx

Un ensamblador convierte el lenguaje ensamblador en código máquina. Una línea de instrucción habitual suele producir una instrucción máquina. Los nombres de los registros y las instrucciones siguen perteneciendo a una ISA concreta, por lo que usar palabras en lugar de bytes no hace portable al lenguaje ensamblador.

Describe un problema en menos líneas

Un lenguaje de alto nivel proporciona variables, expresiones, condiciones, bucles y funciones. Python, C, Java y JavaScript permiten describir operaciones sin seleccionar registros. Una sentencia suele requerir varias instrucciones máquina. Una traducción simplificada de x = a + b haría lo siguiente:

1. Cargar el valor de a en un registro.
2. Cargar el valor de b en otro registro.
3. Sumar los valores de los registros.
4. Guardar el resultado para x.

Un compilador real puede combinar o reordenar esos pasos manteniendo el comportamiento requerido.

El código fuente de alto nivel es más fácil de leer, modificar y comprobar. Un código fuente portable en C puede compilarse para un sistema x86-64 y también para un sistema ARM. Cada compilación sigue necesitando el soporte y las bibliotecas adecuados del sistema operativo. La portabilidad del código fuente no convierte un ejecutable nativo en universal.

Por qué siguen importando los niveles inferiores

El lenguaje ensamblador sigue siendo útil en el código de arranque, algunas rutinas de sistemas operativos y controladores, sistemas embebidos pequeños y el análisis de seguridad de programas cuyo código fuente no está disponible. Para el código de aplicaciones habitual, los compiladores modernos suelen producir código máquina con un rendimiento comparable al del ensamblador escrito a mano.

El avance hacia niveles superiores fue gradual. El lenguaje ensamblador se extendió a finales de la década de 1940 y principios de la de 1950. El sistema A-0 de Grace Hopper, de 1952, ayudó a impulsar la traducción automática. IBM publicó FORTRAN en 1957; COBOL apareció en 1959 y Lisp surgió hacia 1958–1960. «Alto nivel» indica la distancia respecto a los detalles del hardware, no la dificultad de aprender el lenguaje.

Un compilador traduce código fuente a código destino. El destino puede ser código máquina nativo o una forma intermedia, como el código de bytes. La compilación anticipada (AOT) se realiza antes de ejecutar el programa; la compilación en tiempo de ejecución se realiza mientras este se ejecuta.

Del texto a las instrucciones

En una construcción anticipada, varias etapas transforman un archivo fuente en instrucciones:

1. El análisis léxico divide el texto en componentes léxicos: piezas con significado, como nombres, operadores y números.
2. El análisis sintáctico comprueba la gramática y construye una estructura que muestra cómo encajan las piezas.
3. El análisis semántico comprueba las reglas de significado, incluidas las declaraciones y las combinaciones de tipos permitidas.
4. La optimización busca una forma más eficiente de realizar el trabajo requerido.
5. La generación de código produce las instrucciones de destino.

Considera la sentencia de C total = price * 3;. Sus seis componentes léxicos son total, =, price, *, 3 y ;. Los nombres son identificadores, 3 es un literal entero y el punto y coma termina la sentencia. El análisis sintáctico registra que la multiplicación está dentro de la asignación: calcula price * 3 y después almacena su valor en total.

Estas etapas tienen tareas distintas. Una secuencia de componentes léxicos correctamente escritos puede incumplir la gramática. Una sentencia gramaticalmente correcta puede usar mal un tipo. Identificar los componentes léxicos no basta para establecer que un programa es válido.

Reduce el coste del mismo trabajo

Supón que el código fuente contiene seconds_per_day = 60 * 60 * 24. Los factores son constantes, por lo que el compilador puede multiplicar 60 por 60 para obtener 3600 y después multiplicar por 24 para obtener 86 400 durante la construcción. Puede colocar el valor final en la salida en lugar de repetir la multiplicación durante la ejecución. Esto es el plegado de constantes.

Una optimización debe conservar el comportamiento que exige el lenguaje. No puede sustituir un cálculo por otro más rápido que dé resultados distintos de los requeridos. El objetivo es reducir el trabajo, el tiempo o la memoria manteniendo el significado del programa.

Une las piezas

Los programas grandes suelen construirse a partir de muchos archivos. Un compilador puede producir un archivo objeto por cada archivo fuente. Un archivo objeto contiene código traducido que aún puede necesitar conexiones con otro código. Un enlazador une las piezas y resuelve las llamadas a rutinas de bibliotecas, como funciones para mostrar texto o realizar cálculos matemáticos.

El ejecutable resultante se construye para una plataforma de destino, incluidas una ISA y las convenciones del sistema operativo. El usuario no necesita el compilador anticipado para ejecutarlo. Aun así, pueden requerirse bibliotecas compartidas o componentes del entorno de ejecución.

Entiende qué demuestra una construcción correcta

En Java, int count = "five"; no supera una comprobación de tipos antes de la ejecución. Un texto no puede inicializar esa variable entera. El programa debe superar las comprobaciones de compilación requeridas antes de disponer de una versión ejecutable.

Otros fallos sobreviven a la compilación. Dividir por un cero introducido por el usuario depende de los datos de ejecución. Un programa pensado para restar que, en cambio, suma puede ejecutarse y devolver un valor incorrecto. La compilación comprueba las reglas del lenguaje; las pruebas también deben comprobar que el resultado corresponde a la tarea prevista.

Un programa no tiene que convertirse en un ejecutable nativo antes de que un usuario lo inicie. Un intérprete ejecuta el programa mediante otro programa en ejecución. Muchas implementaciones combinan interpretación y compilación, por lo que la pregunta útil es cómo ejecuta el código ese sistema concreto.

Ejecuta mediante un intérprete

Un intérprete debe estar disponible cada vez que ejecuta el programa. Un REPL interactivo repite cuatro acciones: leer una entrada, evaluarla, mostrar un resultado y volver a empezar para la siguiente entrada. Ofrece una respuesta rápida al probar expresiones pequeñas.

Interpretar no significa necesariamente leer el código fuente directamente, línea por línea. CPython, la implementación estándar de Python, primero compila un archivo a código de bytes. Después, una máquina virtual de software ejecuta esas instrucciones internas. El código de bytes pertenece a ese entorno de ejecución; no es el conjunto de instrucciones nativo del procesador.

Por qué algunos errores aparecen antes

Compara dos archivos de Python. Este tiene una sintaxis válida:

print("start")
x = 10
print(x + "5")

Muestra «start», vincula x a 10 y después genera TypeError. La suma de ese entero y una cadena solo falla cuando se ejecuta la expresión. Una operación similar en una rama que no se visita puede pasar inadvertida hasta que se ejecute esa rama.

Ahora elimina el paréntesis de cierre de la última línea. CPython no puede compilar el archivo porque su sintaxis está incompleta. Informa de un error de sintaxis antes de que se ejecute cualquier sentencia de ese archivo, por lo que no se muestra «start». La comprobación de sintaxis del archivo completo y la comprobación durante la ejecución de una operación ocurren en momentos distintos.

Comparte código de bytes y especialízalo durante la ejecución

Java muestra una vía híbrida habitual. javac Hello.java produce Hello.class, que contiene código de bytes. java Hello inicia una máquina virtual de Java (JVM) compatible. Distintas implementaciones de la JVM permiten ejecutar ese código de bytes en distintas familias de procesadores. El código de bytes es portable entre entornos de ejecución compatibles; cada entorno debe funcionar en su propia plataforma anfitriona. De forma similar, C# se traduce a un lenguaje intermedio utilizado por .NET.

Un compilador en tiempo de ejecución (JIT) genera código máquina mientras se ejecuta el programa. El entorno de ejecución HotSpot de Java suele comenzar con interpretación y compila los métodos más utilizados. Los motores de JavaScript de los navegadores también combinan técnicas de ejecución, incluida la compilación JIT. Compilar las partes más utilizadas puede mejorar la velocidad sostenida, pero consume tiempo y memoria durante la ejecución.

Un bucle que suma mil millones de valores suele ejecutarse mucho más rápido en C compilado que en CPython: CPython realiza trabajo de interpretación y comprobaciones de tipos en torno a muchas operaciones. Para un programa breve que cambia el nombre de 20 archivos, el esfuerzo de desarrollo puede importar mucho más que esa diferencia. Mide la carga de trabajo antes de usar la etiqueta de un lenguaje como predicción de velocidad.

Compilado e interpretado describen decisiones de implementación. CPython utiliza interpretación de código de bytes; PyPy utiliza técnicas JIT. Un lenguaje puede tener más de una implementación y una implementación puede usar varios métodos de ejecución.

La sintaxis establece las reglas para que el texto de un programa sea válido. La semántica da significado a ese texto. Un programa puede seguir todas las reglas gramaticales y aun así calcular un resultado incorrecto, por lo que comprobar su apariencia es solo la primera parte de su lectura.

Reconoce las piezas y la gramática

Los componentes léxicos incluyen palabras clave como if, identificadores como total, literales como 3 o "hello", operadores como + y == y signos de puntuación. Una gramática describe cómo pueden formar expresiones y sentencias estas piezas.

Python requiere dos puntos después de if x > 3: y utiliza la sangría para marcar las sentencias controladas por esa condición. C, Java y JavaScript utilizan llaves para los bloques; C y Java también requieren punto y coma después de muchas sentencias. En esos lenguajes, la sangría ayuda a quien lee, pero no selecciona el bloque.

Una sintaxis distinta puede expresar una acción similar. Estas sentencias muestran un saludo:

print("hello")

printf("hello\n");

System.out.println("hello");

La secuencia de escape de C \n añade un salto de línea. Conocer la idea de mostrar texto ayuda al aprender cómo la expresa cada lenguaje.

Los mismos símbolos pueden significar cosas distintas

La apariencia familiar de un símbolo no determina su significado en distintos lenguajes.

El orden de evaluación también importa. La precedencia hace que la multiplicación y la división se realicen antes que la suma. Con a = 4 y b = 6, average = a + b / 2 divide primero 6 entre 2 y después suma 4, lo que produce 7,0. Los paréntesis de average = (a + b) / 2 hacen que la suma se realice primero y dan 5,0.

Distingue los errores

Un error de sintaxis incumple la gramática, como la falta de dos puntos en Python. Un error de ejecución ocurre durante una operación ejecutada, como la división por cero en Python. Un error lógico permite la ejecución, pero da una respuesta no deseada, como en el promedio incorrecto.

Algunas expresiones válidas omiten deliberadamente una operación. En Python, x != 0 and 10 / x > 2 utiliza evaluación en cortocircuito. Cuando x es cero, la primera condición es falsa, por lo que el lado derecho no se evalúa y no se realiza ninguna división. Invertir estas condiciones eliminaría esa protección. Python escribe and, or y not; C, Java y JavaScript utilizan &&, || y !.

La asignación y la comparación son otra distinción importante. = almacena un valor; == comprueba la igualdad. C permite if (x = 5): asigna 5 y trata ese valor distinto de cero como verdadero. Python rechaza if x = 5: por ser sintaxis no válida. Por tanto, el mismo error puede detectarse en una etapa distinta según el lenguaje.

Un programa breve es más fácil de entender si sigues las sentencias ejecutadas una a una. Mantén visibles los valores actuales en lugar de saltar de la primera línea a un resultado supuesto.

Expresiones y asignaciones

Una expresión produce un valor: price * 3, x > 10 y len(name) son ejemplos. Una sentencia realiza una acción, como asignar un valor o controlar un bloque. En total = price * 3, la expresión de la derecha se evalúa antes de asignar su resultado a total.

Una variable es un nombre que hace referencia a un valor. La asignación da al nombre su valor actual; no es una afirmación matemática de que ambos lados siempre hayan sido iguales. Si count contiene 4, count = count + 1 primero lee 4, suma 1 y vincula count a 5.

Sigue la siguiente sentencia que se ejecuta

Tres estructuras organizan el flujo de control:

• La secuencia ejecuta las sentencias en orden.
• La selección utiliza una condición para elegir un camino, como if y else.
• La iteración repite un bloque mediante un bucle for o while.

El teorema del programa estructurado, asociado a Böhm y Jacopini en 1966, muestra que estas estructuras pueden expresar cualquier algoritmo. Un bucle for suele recorrer los elementos de una colección. Un bucle while se repite mientras su condición siga siendo verdadera.

Considera este bucle de Python:

total = 0
for n in [3, 8, 5]:
    total = total + n

La asignación con sangría se ejecuta una vez por cada elemento. Una tabla de seguimiento registra el estado después de cada actualización:

Cada total nuevo utiliza el anterior. Reiniciar total dentro del bucle produciría un cálculo distinto porque se perderían las sumas anteriores.

Entra en una función y sal de ella

Una función agrupa una tarea bajo un nombre. Un parámetro es un nombre de la definición; un argumento es un valor proporcionado por una llamada:

def area(width, height):
    return width * height

result = area(3, 4)

La llamada vincula width a 3 y height a 4. La multiplicación produce 12 y return lo envía al código que realizó la llamada. La ejecución continúa en la asignación, por lo que result recibe 12. Los nombres describen una tarea que puede reutilizarse con otros argumentos.

Un nombre tiene un ámbito

El ámbito determina dónde puede usarse un nombre. Los nombres creados dentro de una función suelen ser locales a esa llamada. Un nombre del nivel superior es global en su módulo. Las llamadas distintas tienen vinculaciones locales independientes aunque utilicen nombres idénticos.

count = 7

def reset():
    count = 0

reset()
print(count)

Esto muestra 7. La asignación dentro de reset crea un count local; no sustituye la vinculación global. En su lugar, una función puede devolver un resultado y dejar que el código que la llama lo asigne.

El ámbito y el tiempo de vida responden a preguntas distintas. Un nombre local no está disponible para el código externo solo porque el objeto al que hacía referencia siga existiendo. Los objetos devueltos pueden seguir vivos, y una función anidada devuelta puede conservar el acceso a las variables de la llamada que la contiene; ese entorno conservado forma parte de una clausura.

Un tipo de dato especifica los valores posibles y las operaciones que admiten. Un entero admite operaciones aritméticas con números enteros; un valor booleano representa verdadero o falso. Las cadenas, listas, registros y objetos combinan u organizan otros valores. Los tipos también orientan cómo se representan los valores en memoria, aunque el tamaño de un valor puede depender del propio valor y de la implementación.

¿Cuándo se comprueban los tipos?

En Python, count = 5 seguido de count = "five" es válido. El nombre ahora hace referencia a una cadena. Evaluar después count + 1 genera TypeError. El tipado dinámico da tipos definidos a los valores; no elimina los tipos.

El tipado estático no exige una etiqueta de tipo visible en cada variable. La inferencia de tipos permite al compilador deducir un tipo a partir del código que lo rodea. Kotlin infiere un entero para val n = 5, y Rust puede inferir un entero para let n = 5;. Las anotaciones de tipo opcionales de Python son distintas: herramientas independientes como mypy pueden comprobarlas, pero la ejecución habitual de Python no las hace cumplir.

¿Cuándo se convierten los valores?

El momento de comprobación y la rigidez de las conversiones son cuestiones distintas. Python rechaza "3" + 4; la conversión explícita en int("3") + 4 da 7. JavaScript aplica distintas reglas de conversión automática según el operador:

• "3" + 4 da la cadena "34".
• "3" * 4 da el número 12.
• "3" - 4 da el número -1.

La conversión automática se llama coerción. Las etiquetas de tipado «fuerte» y «débil» son formas informales de hablar de la rigidez de las conversiones, no otros nombres para el tipado estático y dinámico. Python es dinámico y estricto con la suma de tipos distintos del ejemplo anterior; C es estático y aun así permite muchas conversiones numéricas implícitas.

La función input() de Python devuelve una cadena. Si una persona escribe «30», el resultado sigue teniendo el tipo str. age + 1 falla, mientras que int(age) + 1 da 31 cuando age contiene ese texto. Lo que aparece en pantalla no basta para determinar el tipo.

Los números tienen límites de representación

Un entero con signo de 32 bits representa valores desde −2 147 483 648 hasta 2 147 483 647. El tipo int de Java pasa cíclicamente del máximo al mínimo al sumar 1. El desbordamiento con signo en C tiene un comportamiento indefinido, por lo que no debe suponerse ese mismo retorno cíclico en C. Los enteros de Python crecen según lo permita la memoria: 2 ** 100 es exactamente 1 267 650 600 228 229 401 496 703 205 376.

Los números en coma flotante representan la mayoría de las fracciones decimales de forma aproximada en binario. En Python y JavaScript, 0.1 + 0.2 produce 0.30000000000000004. Comparar ese resultado directamente con 0.3 da falso.

Cuando un cálculo admite un pequeño error, compara los valores con una tolerancia elegida para la tarea, por ejemplo, abs(a - b) < 1e-9. Una tolerancia absoluta tan pequeña solo es adecuada para algunas escalas. Para una contabilidad decimal exacta, utiliza números enteros de la unidad mínima o un tipo decimal adecuado. Cambiar la comparación no puede convertir una representación aproximada en exacta.

La memoria principal almacena los datos de un programa en ejecución. Cada byte tiene una dirección. Los lenguajes proporcionan nombres para trabajar con valores sin escribir direcciones directamente en cada operación.

Las llamadas usan marcos; los objetos tienen tiempos de vida

En C, un int suele ocupar 4 bytes, y &x obtiene la dirección de x. Los lenguajes de nivel superior suelen ocultar las direcciones mediante referencias. La distinción importante es entre una vinculación que da nombre a un objeto y el propio objeto.

La pila de llamadas lleva el seguimiento de las llamadas activas a funciones. Cada llamada tiene un marco de pila con información como los parámetros, las vinculaciones locales y el punto donde debe continuar la ejecución tras el retorno. Si main llama a area(3, 4), se añade un marco de area sobre el marco del código que llama. La función calcula 12, retorna y se retira su marco. En las llamadas anidadas habituales, la llamada más reciente retorna primero.

La recursión añade una llamada por cada nivel pendiente. Si las llamadas siguen acumulándose, puede agotarse el espacio disponible en la pila. Python normalmente genera RecursionError después de unas 1000 llamadas anidadas, con un límite que depende de su configuración. Para que termine un cálculo recursivo finito, debe alcanzarse una condición de parada.

El montículo de memoria contiene objetos cuya memoria se reserva dinámicamente, como una lista que crece o un objeto que sobrevive a la función que lo creó. La reserva de memoria aparta espacio de almacenamiento. Una lista devuelta puede permanecer en el montículo después de que termine la llamada que la creó.

Copiar una referencia comparte un objeto

Una referencia identifica un objeto. Un puntero en C o C++ representa explícitamente una dirección utilizada para acceder a datos. Copiar una referencia copia el acceso al objeto, no todos sus datos.

a = [1, 2]
b = a
b.append(3)

Después de la primera línea hay una lista. La segunda línea vincula otro nombre a ella. La última línea modifica esa lista, por lo que tanto a como b muestran [1, 2, 3]. Esta forma de compartir es el uso de alias. Usar b = a.copy() crearía una lista externa independiente; en esta lista de enteros, añadir un elemento a la nueva lista dejaría a sin cambios.

Compara la asignación con la mutación:

x = 5
y = x
y = y + 1

El entero 5 es inmutable. La suma produce 6 y solo se vuelve a vincular y. x sigue haciendo referencia a 5. Los números, cadenas y tuplas de Python son inmutables; las listas y los diccionarios son mutables. El contenido fijo de una tupla puede incluir una referencia a una lista mutable, por lo que la inmutabilidad del contenedor externo no inmoviliza todos los objetos anidados.

Aplica las mismas reglas a los argumentos

Cuando Python pasa una lista a una función, el parámetro hace referencia al mismo objeto. Llamar a items.append(4) dentro de la función cambia esa lista. Asignar items = [] vincula solo el nombre del parámetro local a una lista nueva. El nombre del código que llama sigue vinculado al objeto original.

C pasa los valores de los argumentos por valor. Para permitir que una función actualice una variable del código que llama mediante su dirección, pasa un puntero a ella. En cada lenguaje, hazte dos preguntas distintas durante el seguimiento: «¿A qué objeto hace referencia este nombre?» y «¿Esta operación cambia ese objeto o vincula un nombre a otra cosa?».

La memoria reservada debe poder reutilizarse en algún momento. El reto consiste en liberar los datos después de su último uso y conservar todos los objetos que el programa aún necesita. Los lenguajes asignan esta responsabilidad a quien programa, a un sistema de ejecución o a reglas de propiedad de los datos comprobadas por el compilador.

La gestión manual y sus fallos

En C, malloc(n) solicita n bytes y devuelve un puntero al bloque si tiene éxito. free(p) libera un bloque obtenido mediante una reserva. Quien programa debe utilizarlo en el momento adecuado y exactamente una vez. C++ también admite la gestión manual, aunque sus herramientas estándar pueden automatizar la liberación mediante los tiempos de vida de los objetos.

Varios errores tienen causas distintas:

Un puntero que sigue haciendo referencia a almacenamiento liberado es un puntero colgante. Ese almacenamiento podría reutilizarse para otra cosa, por lo que acceder a él puede corromper datos o hacer que el programa deje de funcionar.

En un arreglo de C int scores[10], las posiciones válidas son de 0 a 9. Escribir en scores[10] supera los límites del arreglo, y C no proporciona una comprobación automática de límites. Python genera IndexError cuando se utiliza el índice 10 en una lista de diez elementos, lo que impide que ese acceso sobrescriba memoria adyacente.

Rastrea la accesibilidad o cuenta las referencias

Un recolector de basura por rastreo parte de raíces vivas, como referencias activas, sigue los enlaces entre objetos y puede recuperar la memoria de los objetos inaccesibles. Java, C#, Go y JavaScript utilizan enfoques de rastreo. La recolección requiere trabajo durante la ejecución y memoria; según el recolector, puede introducir pausas.

El conteo de referencias lleva la cuenta de las referencias a un objeto. Para una lista nueva de Python, la secuencia simplificada es: a = [1, 2] proporciona una referencia; b = a proporciona una segunda; del a elimina una; b = None elimina la otra. CPython normalmente recupera la memoria de esta lista habitual cuando su cuenta llega a cero.

Un grupo de objetos puede mantener las cuentas de los demás por encima de cero aunque ninguna parte viva del programa pueda acceder al grupo. Esto es un ciclo de referencias. CPython complementa el conteo de referencias con la recolección de ciclos. Tanto el conteo de referencias como el rastreo son técnicas de gestión automática de memoria.

Comprueba la propiedad antes de la ejecución

Rust da un propietario a cada valor y comprueba las reglas del préstamo de referencias. Cuando termina la propiedad, el código de limpieza generado libera el valor. Rust seguro rechaza los usos de referencias que podrían sobrevivir al objeto válido al que apuntan, sin necesitar un recolector de basura por rastreo. Swift utiliza conteo automático de referencias insertado por el compilador.

La seguridad de memoria importa más allá de los fallos del programa. Microsoft informó en 2019 de que aproximadamente el 70 % de las vulnerabilidades a las que asignaba CVE cada año afectaban a la seguridad de memoria; Chromium informó de una proporción similar de errores graves en 2020. En diciembre de 2023, las agencias estadounidenses CISA, NSA y FBI y socios internacionales instaron a los fabricantes de software a planificar la transición hacia lenguajes con seguridad de memoria.

La recuperación automática sigue conservando los objetos accesibles. Una lista global que no deja de crecer puede mantener vivos todos los registros antiguos incluso después de que la aplicación haya terminado de utilizarlos. Un recolector no puede decidir que estos registros accesibles ya no son necesarios para la tarea; el programa debe dejar de retenerlos.

Un paradigma de programación es una forma de organizar el código y de pensar en la computación. En la programación imperativa, un programa da órdenes que cambian su estado: los valores que contienen actualmente las variables y los objetos.

Haz visibles los cambios de estado

Un total acumulado es un cálculo imperativo sencillo:

total = 0
for n in [3, 8, 5]:
    total = total + n

El estado inicial es total = 0. Sumar 3 lo cambia a 3. Sumar 8 lo cambia a 11. Sumar 5 lo cambia a 16. Cada asignación utiliza el estado que dejó el paso anterior, por lo que el orden forma parte del método.

Este estilo se ajusta a los cambios paso a paso que realiza el procesador en los registros y la memoria. También encaja con algoritmos que actualizan deliberadamente una colección en su propia ubicación, como una rutina de ordenación que intercambia elementos.

Da nombres a las tareas

La programación procedimental organiza el código imperativo en funciones o procedimientos. Un programa de informes podría llamar a read_scores(), average(scores) y print_report(avg). Los nombres permiten ver la tarea general sin seguir todas las líneas internas a la vez. Cada procedimiento puede entenderse y probarse por separado.

C, Pascal, Fortran y COBOL son lenguajes procedimentales clásicos. Python también admite este estilo: un programa breve puede utilizar funciones con nombre sin definir ninguna clase.

La programación estructurada organiza el flujo de control con secuencia, selección, bucles y llamadas a procedimientos. Evita los saltos arbitrarios que dificultan predecir la siguiente sentencia que se ejecutará. La carta de Edsger Dijkstra de 1968 «La instrucción Go To se considera perjudicial» ayudó a popularizar este enfoque. Las salidas controladas como break, continue y return siguen siendo útiles: permiten salir de una iteración concreta, de un bucle o de una función.

Los efectos pueden ir más allá de un valor de retorno

Un efecto lateral cambia algo fuera del resultado que devuelve una función. Mostrar información, guardar un archivo, enviar un mensaje por la red y cambiar datos compartidos son efectos laterales. Los programas necesitan estas acciones para interactuar con el mundo.

Los problemas surgen cuando fragmentos de código sin relación cambian silenciosamente el mismo estado. Supón que apply_discount() reduce una variable global price un 10 % y add_shipping() añade 5. Partiendo de 100, aplicar primero el descuento da 90 y después el envío da 95. Añadir primero el envío da 105 y después aplicar el descuento da 94,5. Ambos procedimientos realizan correctamente sus propios pasos, pero el resultado combinado depende de su orden.

Pasar valores y devolver resultados nuevos puede hacer visible ese orden:

price = add_shipping(apply_discount(100))

La llamada interna se ejecuta primero: descuento y después envío. Un anidamiento distinto expresa una regla distinta. Un flujo de datos claro ayuda a revelar si el propio envío debe recibir el descuento.

El código imperativo sigue siendo habitual dentro de los métodos de objetos y los manejadores de eventos modernos. Elegir un diseño general orientado a objetos o funcional no impide que una pequeña parte utilice órdenes directas cuando esos pasos aclaran el algoritmo.

La programación orientada a objetos (POO) modela un programa como objetos que colaboran. Cada objeto combina datos con operaciones sobre esos datos. Una cuenta puede contener su titular y su saldo y ofrecer operaciones de depósito y retirada.

Separa la plantilla de sus instancias

Una clase define los atributos y métodos que proporcionan sus objetos. Un objeto, o instancia, es un miembro concreto de esa clase. BankAccount es la plantilla; la cuenta de Ana con 150 y la de Ben con 40 son instancias distintas. Sus saldos pueden cambiar de forma independiente.

Un atributo almacena datos asociados a un objeto. Un método es una operación que se llama a través de un objeto, como acct.deposit(50). En un método de instancia de Python, self hace referencia al objeto que recibe la llamada.

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self._balance = balance

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("amount must be positive")
        self._balance = self._balance + amount

Llamar a BankAccount("Ana", 100) construye una instancia nueva. Su método __init__ inicializa los datos de la instancia. Un constructor es el proceso de preparación de un objeto nuevo; Python separa la creación de esta etapa de inicialización. Llamar a acct.deposit(50) sobre esa cuenta cambia su saldo de 100 a 150.

Coloca la regla en el punto de actualización

La encapsulación reúne los datos y las operaciones que mantienen sus reglas. Supón que una cuenta nunca debe tener un saldo negativo. El método de retirada comprueba el cambio propuesto antes de realizarlo:

def withdraw(self, amount):
    if amount <= 0:
        raise ValueError("amount must be positive")
    if amount > self._balance:
        raise ValueError("insufficient funds")
    self._balance = self._balance - amount

Este método pertenece al interior de BankAccount. Partiendo de un saldo de 150, withdraw(200) genera un error y deja 150. withdraw(30) tiene éxito y deja 120. La llamada fallida no resta primero y descubre después el problema; la comprobación ocurre antes de la actualización.

El resto del código debe utilizar esos métodos en lugar de asignar un saldo sin comprobarlo. Java y C# pueden restringir el acceso directo con private. El guion bajo inicial de _balance en Python señala por convención un detalle interno; no impone privacidad.

La ocultación de información va más allá: el código que llama depende de las operaciones que ofrece una clase sin necesitar conocer su representación interna. Más adelante, el saldo podría almacenarse de otra forma mientras las operaciones públicas de depósito y retirada conservan su significado.

Deja que el problema sugiera las responsabilidades

Un sistema de biblioteca tiene libros, miembros y préstamos. Esos sustantivos sugieren posibles clases o atributos; acciones como prestar y renovar sugieren métodos. Elige una responsabilidad clara para cada clase. Una clase de cuenta que además envía todos los correos electrónicos y da formato a todos los informes resulta más difícil de modificar porque mezcla tareas sin relación.

Las clases y los objetos aparecieron en Simula 67 en 1967; Smalltalk ayudó a difundir el enfoque en la década de 1970. Java, C#, C++ y Python admiten POO, pero utilizar uno de esos lenguajes no obliga a organizar todos los programas en clases. La pregunta útil de diseño es qué datos y reglas deben estar juntos.

Los objetos suelen necesitar compartir operaciones y diferir en los detalles. La herencia, el polimorfismo y la composición resuelven partes distintas de ese problema de diseño.

Especializa un tipo de objeto existente

La herencia define una subclase a partir de una superclase. En Python, class SavingsAccount(BankAccount): da a la clase especializada acceso al comportamiento heredado de la cuenta. Puede añadir add_interest(rate): un saldo de 1000 al que se añade un interés del 2 % pasa a ser 1020.

La relación prevista es es un. Una cuenta de ahorro sigue siendo una cuenta bancaria y debe respetar las reglas que se esperan de las cuentas bancarias. Reutilizar unas pocas líneas no es motivo suficiente para afirmar que un tipo de objeto es otro.

Una subclase puede redefinir un método con su propia implementación. Supón que una cuenta corriente cobra una comisión de 1 por cada retirada realizada con éxito. Con un saldo de 100, retirar 30 cuesta 31 y deja 69. Para conservar la regla de la cuenta, el método debe comprobar la retirada más la comisión antes de cambiar el saldo. Si ese coste combinado supera el saldo, rechaza toda la operación.

Haz que una llamada funcione con distintos objetos

El polimorfismo permite que la misma operación funcione con distintos tipos de objetos. Tanto un círculo como un rectángulo pueden proporcionar area():

for shape in shapes:
    print(shape.area())

El bucle no necesita un if para cada clase de figura. Cada objeto aporta su propia implementación. Seleccionar esa implementación durante la ejecución es el despacho dinámico.

Para Circle(2), el área es aproximadamente 12,57 unidades cuadradas. Para Rectangle(3, 4), es de 12 unidades cuadradas. Su área combinada es aproximadamente 24,57 unidades cuadradas. Un Triangle posterior puede incorporarse a la colección si proporciona una operación area() compatible; el propio bucle no necesita otra rama.

Una interfaz establece las operaciones que debe ofrecer un tipo. La declaración de Java interface Shape { double area(); } exige que las clases que la implementan proporcionen el método de área. Una clase abstracta puede aportar parte de la implementación compartida y dejar otros métodos para las subclases. Python suele utilizar el tipado de pato: un objeto puede funcionar en el bucle si proporciona la operación requerida, incluso sin una superclase compartida.

Contén una pieza en lugar de convertirte en ella

La composición almacena otros objetos como componentes. Un automóvil tiene un motor y ruedas. Puede llamar al método start() de su motor sin heredar de Engine.

Las cadenas profundas de herencia pueden propagar los efectos de un cambio en una superclase a muchas clases. Una subclase que debe desactivar comportamiento heredado puede indicar una relación «es un» inadecuada. La composición suele mantener estas dependencias más reducidas y claras.

Los cuatro pilares habituales de la POO encajan aquí: la encapsulación protege los datos mediante operaciones, la abstracción oculta los detalles de implementación, la herencia especializa un tipo y el polimorfismo permite que el código que llama utilice una operación compartida entre distintas implementaciones.

La programación funcional construye resultados combinando funciones. Su práctica central es producir valores nuevos a partir de las entradas y limitar la mutación compartida. Lisp introdujo ideas funcionales de uso extendido hacia 1958; Haskell, Erlang, Clojure, F# y OCaml desarrollan esas ideas de distintas formas.

Reconoce qué hace pura a una función

Una función pura da el mismo resultado para los mismos argumentos y no tiene efectos laterales. def with_tax(price): return price * 1.2 ilustra la idea: with_tax(50) da 60,0. Una función que además añade un elemento a una lista global o muestra un mensaje tiene un efecto más allá de su valor de retorno. Un resultado que depende de la hora actual también depende de algo más que de los argumentos.

Una llamada pura puede sustituirse por su valor de retorno sin cambiar el comportamiento del programa. Esta propiedad es la transparencia referencial. Facilita las pruebas aisladas y permite ejecutar llamadas independientes en paralelo sin competir por actualizar el estado compartido.

La inmutabilidad mantiene sin cambios un valor existente. [n + 1 for n in nums] crea una lista nueva y deja nums intacta. Un programa puede seguir representando información cambiante produciendo versiones nuevas; no necesita sobrescribir la versión anterior.

Pasa comportamiento como datos

Las funciones son de primera clase cuando pueden asignarse a nombres, pasarse como argumentos y devolverse como valores. Una función de orden superior recibe una función o devuelve una. Una expresión lambda es una expresión de función sin nombre, como lambda n: n * n.

Tres operaciones habituales de orden superior forman una cadena de procesamiento:

• filter conserva los elementos que cumplen una prueba.
• map transforma cada elemento restante.
• reduce combina los elementos en un resultado mediante un acumulador.

Para sumar los cuadrados de los números pares del 1 al 6, el filtrado deja 2, 4 y 6; elevarlos al cuadrado da 4, 16 y 36; sumarlos da 56.

sum(map(lambda n: n * n,
        filter(lambda n: n % 2 == 0, range(1, 7))))

Aquí % 2 == 0 comprueba si el número es par, y range(1, 7) proporciona del 1 al 6. Haskell expresa el mismo cálculo como sum (map (^2) (filter even [1..6])).

Con reduce importado de functools de Python, reduce(lambda acc, n: acc + n, [3, 8, 5], 0) combina 0 con 3 para obtener 3, después con 8 para obtener 11 y después con 5 para obtener 16. La cadena de procesamiento describe transformaciones sin un bucle externo que actualice un total compartido.

Conserva un entorno o llama a un problema más pequeño

def multiplier(k): return lambda x: k * x devuelve una función que conserva el acceso a k. Así, multiplier(3)(10) devuelve 30 incluso después de que termine la llamada externa. La función devuelta y el entorno conservado forman una clausura.

La recursión hace que una función se llame a sí misma con un problema más pequeño. El factorial devuelve 1 cuando n == 0; en caso contrario, devuelve n * factorial(n - 1). Para 5, los productos dan 120. Un cálculo finito necesita un caso base alcanzable. Las llamadas anidadas pendientes de Python acaban generando RecursionError; los lenguajes con soporte adecuado de llamadas de cola pueden reutilizar el espacio de la pila para las llamadas en posición final.

Usar funciones por sí solo no hace funcional al código: las funciones procedimentales pueden modificar el estado. Los programas funcionales reales también leen entradas y escriben salidas, y suelen mantener los efectos cerca de los límites del programa y los cálculos centrales puros.

La programación declarativa describe el resultado deseado y deja los pasos de ejecución al motor de un lenguaje. El código funcional suele agruparse bajo esta idea amplia, junto con los lenguajes de consulta y la programación lógica.

Lee una consulta como una solicitud

Una base de datos relacional almacena datos en tablas. Supón que students tiene las filas de nombres y calificaciones Ana 92, Ben 75, Chen 80 y Dara 64:

SELECT name
FROM students
WHERE grade >= 80
ORDER BY name;

FROM indica la tabla, WHERE da la condición, SELECT elige el campo que se devuelve y ORDER BY solicita el orden alfabético. Ana y Chen cumplen la condición, incluida la calificación de Chen de exactamente 80. El resultado son sus nombres en ese orden.

Un programa imperativo crearía una lista de resultados, recorrería las filas, comprobaría cada calificación, añadiría los nombres que cumplen la condición y ordenaría la lista. SQL da a la base de datos el resultado requerido sin escribir ese bucle.

Un optimizador de consultas elige un plan de ejecución. Podría recorrer la tabla o utilizar un índice disponible, una estructura de búsqueda que puede acelerar las búsquedas adecuadas. Muchos índices utilizan estructuras ordenadas; otros utilizan disposiciones distintas. Añadir un índice puede cambiar el plan sin cambiar la consulta. Más datos siguen suponiendo trabajo: declarar el resultado no garantiza que todas las consultas tengan poco coste.

Pregunta qué se deduce de los hechos y las reglas

La programación lógica describe hechos y relaciones y después busca valores que satisfagan una pregunta. En Prolog:

parent(tom, bob).
parent(bob, ann).
grandparent(X, Z) :- parent(X, Y), parent(Y, Z).

La regla significa que X es abuelo o abuela de Z cuando existe un Y para el que se cumplen ambas relaciones de progenitor. La consulta ?- grandparent(tom, Who). encuentra Who = ann: Tom es progenitor de Bob y Bob es progenitor de Ann. Los nombres con mayúscula inicial representan variables; los nombres en minúscula identifican a personas concretas.

Reconoce las herramientas declarativas a tu alrededor

Una fórmula de hoja de cálculo =SUM(B2:B5) establece una dependencia. La hoja de cálculo la recalcula cuando cambian las celdas pertinentes. La expresión regular [0-9]{3}-[0-9]{4} describe tres dígitos, un guion y cuatro dígitos, como en «555-0199». Un motor de coincidencia de texto realiza la búsqueda.

CSS establece la apariencia con una regla como h1 { color: navy; }; HTML marca la estructura de la página. Son notaciones declarativas, normalmente clasificadas como lenguajes de estilos y de marcado. Su función difiere de la de un lenguaje de propósito general capaz de expresar una amplia variedad de cálculos.

El código declarativo puede mantenerse próximo al enunciado de un problema y permitir que un motor mejore su método. También da a quien programa menos control directo sobre los pasos individuales, lo que puede dificultar el diagnóstico de un plan lento. Por debajo siguen ejecutándose instrucciones concretas: «declarativo» describe cómo expresa la tarea quien programa, no un procesador que funciona sin pasos.

Un paradigma cambia cómo se expresa una solución, no la respuesta numérica que debe producir una solución correcta. Considera pedidos con importes [120, 45, 300, 80]: calcula el total de los importes estrictamente mayores que 100.

Sigue los cambios de estado

La versión imperativa hace explícitos el bucle y el acumulador:

total = 0
for amount in amounts:
    if amount > 100:
        total = total + amount

El primer importe cambia total a 120. El segundo lo deja sin cambios. El tercero lo cambia a 420 y el cuarto lo deja ahí. El programa hace visibles la prueba y el orden de actualización.

Transforma una colección

Una expresión compacta de Python con estilo funcional es sum(a for a in amounts if a > 100). Selecciona 120 y 300 y los combina en 420. Otra versión es sum(filter(lambda a: a > 100, amounts)). Aquí el predicado describe qué elementos se incluyen y sum combina los valores seleccionados.

Una expresión generadora o una llamada a filter utiliza las características multiparadigma de Python; su presencia no hace puras todas las partes de la aplicación que la rodean.

Coloca las reglas junto con los objetos

En un diseño orientado a objetos, un Order almacena un amount y ofrece is_large(), que devuelve self.amount > 100. Un OrderBook contiene objetos de pedido y ofrece large_total(). Ese método puede recorrer los pedidos, preguntar a cada uno si cumple la condición y sumar los importes que la cumplen.

El total sigue siendo 420. La diferencia está en dónde se sitúan las responsabilidades: la regla para un pedido grande pertenece a Order, y el trabajo sobre la colección pertenece a OrderBook. Otras funcionalidades pueden reutilizar la regla sin copiar la comprobación del umbral.

Pídeselo a la base de datos

Si los datos ya están en una base de datos relacional, SQL puede solicitar el total:

SELECT SUM(amount)
FROM orders
WHERE amount > 100;

La base de datos elige el plan de recuperación y agregación. La consulta no indica al código que llama que recorra todas las filas ni que mantenga un acumulador local.

Combina estilos donde ayuden

Python admite técnicas procedimentales, orientadas a objetos y funcionales. JavaScript proporciona objetos, funciones de primera clase y clausuras. C++, C#, Kotlin, Scala, Swift y Rust también mezclan estilos. Java está muy asociado a la POO, pero admite expresiones lambda desde Java 8 en 2014; Haskell es puramente funcional.

Una aplicación web puede utilizar clases para usuarios y pedidos, transformaciones funcionales para los datos de informes, actualizaciones imperativas dentro de métodos y SQL para consultas a la base de datos. Estas decisiones actúan en capas distintas.

La programación dirigida por eventos añade otra idea de organización: registrar un manejador que se ejecuta cuando llega un evento. En JavaScript, button.addEventListener("click", showMenu) pasa showMenu como valor de función. Un clic posterior la invoca. El propio manejador puede utilizar objetos, transformaciones puras o pasos imperativos. Su función dirigida por eventos indica cuándo se ejecuta, no el único estilo que puede utilizar su cuerpo.

Ningún lenguaje de programación es el más adecuado para todos los proyectos. Los lenguajes de propósito general suelen ser completos en el sentido de Turing: con tiempo y memoria ilimitados, pueden expresar la misma clase de cálculos. Las decisiones reales dependen de si una solución se adapta a la plataforma, los recursos, las herramientas y las personas disponibles.

Empieza por lo que debe funcionar

La plataforma suele ser una restricción ineludible. Los navegadores ejecutan JavaScript y pueden ejecutar módulos compilados mediante WebAssembly. TypeScript añade comprobaciones estáticas y se compila a JavaScript. Swift es una elección habitual para aplicaciones de las plataformas de Apple; Kotlin se recomienda para Android. SQL es el lenguaje habitual para las consultas relacionales.

Después considera el dominio y el ecosistema. Python tiene bibliotecas de datos y aprendizaje automático de uso extendido, como NumPy y pandas. R se centra en la estadística. C y C++ son habituales en sistemas operativos, motores de juegos y código para sistemas embebidos. Java y C# son habituales en grandes sistemas empresariales; Bash es útil para automatizar tareas del sistema operativo.

Son asociaciones prácticas, no territorios exclusivos. Una biblioteca adecuada puede ahorrar mucho más trabajo de desarrollo que una pequeña diferencia en la sintaxis del lenguaje.

Examina las necesidades de recursos y seguridad

Un microcontrolador con solo unos pocos kilobytes de RAM puede necesitar un control preciso de la memoria y de la sobrecarga durante la ejecución. C, C++ o Rust pueden ser adecuados cuando el sistema de destino los admite. Los componentes exigentes de juegos o bases de datos también suelen favorecer esos lenguajes, pero los motores y los recursos disponibles difieren: Unity utiliza C# y algunas bases de datos utilizan Java o Go.

Antes de elegir por velocidad, encuentra el cuello de botella: la parte que limita el rendimiento. Un programa que espera principalmente una respuesta de red no será mucho más rápido solo porque un pequeño bucle local se compile de forma más eficiente. Mide trabajo representativo en la plataforma de destino.

La seguridad de memoria reduce errores como el acceso no válido a memoria. Rust seguro comprueba las reglas de propiedad durante la compilación; los lenguajes con gestión automática, como Java, C#, Go y Python, proporcionan gestión de memoria durante la ejecución. El tipado estático detecta muchas operaciones incompatibles antes de la ejecución, lo que puede ayudar en una base de código grande. Ni la seguridad de memoria ni el tipado estático demuestran que la lógica del programa sea correcta.

Incluye el coste de mantener el resultado

Los conocimientos del equipo, el personal de desarrollo disponible, los depuradores, las herramientas de pruebas, las bibliotecas, las licencias y el código existente afectan a la decisión. Un lenguaje conocido y con buen soporte puede reducir los costes de entrega y mantenimiento. Reescribir un sistema que funciona genera trabajo de migración y riesgos aunque el nuevo lenguaje tenga características atractivas.

En una red meteorológica urbana, los distintos componentes tienen necesidades distintas:

Una justificación útil vincula cada elección con un requisito: «El equipo ya mantiene el servicio de Java y sus bibliotecas admiten la nueva funcionalidad». Una posición en una clasificación de popularidad no puede aportar por sí sola ese razonamiento. Las encuestas pueden indicar una comunidad grande o una amplia oferta de personal; no establecen el mejor lenguaje para una carga de trabajo concreta.