Cerrábamos la lección anterior con una constatación: la historia no nos ha dejado un lenguaje de programación, sino cientos, cada uno con las obsesiones de la época y el ámbito en que nació. Para alguien que empieza, esa abundancia es más un problema que una ventaja. ¿Por dónde se entra? ¿Da igual cuál se elija primero? ¿Hay alguno «mejor»?

Esta lección pone orden. Vas a aprender los cuatro ejes con los que se clasifica cualquier lenguaje —nivel de abstracción, forma de ejecución, sistema de tipos y paradigma—, verás una comparativa práctica de los lenguajes más usados hoy y saldrás con criterios reales para elegir uno ante un proyecto concreto. Terminaremos justificando por qué este curso usa Python, que no es una elección obvia ni la única posible.

Una advertencia útil desde el principio: no existe el mejor lenguaje, existe el lenguaje adecuado para un contexto. Quien afirme lo contrario está vendiendo algo, normalmente su propia experiencia disfrazada de ley universal.

1. Niveles de abstracción: máquina, ensamblador y alto nivel
2. Formas de ejecución: compilado, interpretado y bytecode
3. Sistemas de tipos: estático vs dinámico, fuerte vs débil
4. Paradigmas de programación
5. Comparativa de lenguajes actuales
6. Cómo elegir un lenguaje: criterios prácticos
7. Por qué este curso usa Python
8. Errores comunes y consejos
9. Ejercicios
10. Conclusión

El primer eje mide cuánta máquina hay que tener en la cabeza para escribir una línea de código.

Comparemos la misma operación —sumar dos números y mostrar el resultado— en los dos extremos. En ensamblador (x86, simplificado):

En Python:

Las diferencias que importan:

• Registros y memoria. En ensamblador decides tú en qué registro va cada valor. En Python ni siquiera sabes que existen los registros.
• Volumen de código. Lo que en alto nivel son dos líneas, en ensamblador son veinte.
• Portabilidad. El código Python funciona en el Windows de Luis y en el macOS de Nuria sin tocar nada. El ensamblador de arriba no funciona ni en un móvil.

Hay un matiz que conviene tener claro: el bajo nivel no es «peor». El ensamblador y C se siguen usando donde hay que exprimir cada ciclo o controlar el hardware directamente: núcleos de sistemas operativos, controladores de dispositivo, microcontroladores, videojuegos exigentes. Solo es una herramienta cara: se paga en tiempo de desarrollo y en probabilidad de error.

Dentro del «alto nivel» hay grados. C es de alto nivel comparado con el ensamblador, pero muy próximo a la máquina comparado con Python. Es más útil pensar en un gradiente que en cajones:

En la primera lección vimos la diferencia entre compilar e interpretar. Ahora completamos el cuadro con el caso intermedio, que es el que usan Java, C# y —parcialmente— el propio Python.

Compilación anticipada. El compilador traduce todo el código fuente a código máquina del sistema de destino y produce un ejecutable. Es lo que hacen C, C++, Rust y Go.

Interpretación. Un intérprete lee el código fuente y lo ejecuta sobre la marcha. No hay ejecutable: para lanzar el programa hace falta el intérprete instalado.

Bytecode y máquina virtual. Un paso intermedio: el código se compila a un formato compacto llamado bytecode, que no es código máquina de ningún procesador real sino de una máquina virtual. Esa máquina virtual, que sí existe para cada sistema, ejecuta el bytecode. Así se consigue lo de Java: se compila una vez y el resultado funciona en cualquier sistema que tenga la máquina virtual.

Un detalle sobre Python que suele confundir: Python también compila a bytecode, de forma automática y transparente (son esos ficheros .pyc que aparecen en una carpeta __pycache__). La diferencia con Java es que en Python ocurre en el momento de ejecutar, sin un paso explícito, y por eso a efectos prácticos se comporta como un lenguaje interpretado. Las fronteras son más borrosas de lo que sugieren las etiquetas.

El tipo de un dato es la clase de valor que es: un número entero, un texto, un valor de verdad. Los lenguajes se diferencian en cuándo comprueban los tipos y en cuánto se toman en serio esa comprobación. Son dos ejes independientes que se confunden constantemente.

En un lenguaje de tipado estático, cada variable tiene un tipo declarado o deducido en el momento de compilar, y no cambia. Los errores de tipo se detectan antes de ejecutar.

En un lenguaje de tipado dinámico, el tipo va asociado al valor, no a la variable, y se comprueba durante la ejecución.

En Python la segunda línea no da ningún error: la variable simplemente pasa a referirse a otra cosa. La comodidad tiene precio: un error de tipos no se descubre hasta que la línea afectada se ejecuta, que puede ser en producción, un martes, con un cliente delante.

Este eje mide si el lenguaje convierte tipos por su cuenta cuando la operación no encaja.

Python se niega: sumar un texto y un número no significa nada, así que da error y te obliga a decidir. La forma correcta sería print("Tareas: " + str(5)).

JavaScript siempre encuentra la manera de que la operación signifique algo. Es cómodo hasta que produce resultados absurdos que nadie detecta.

Y el resumen de ventajas e inconvenientes, que es lo que de verdad se usa al elegir:

Un apunte para el futuro: Python permite desde hace años anotar tipos de forma opcional (cantidad: int = 5). No los comprueba al ejecutar, pero ayudan al editor y a herramientas de análisis. Es un ejemplo de cómo los lenguajes se copian las buenas ideas entre sí; no lo usaremos en este curso, pero conviene saber que existe.

Un paradigma es una forma de organizar el pensamiento sobre el programa: qué se considera la pieza básica y cómo se combinan las piezas. Veamos los cuatro principales con un fragmento mínimo de cada uno. Todos resuelven la misma tarea: obtener las tareas de prioridad alta de Estudio Alba.

Se describe paso a paso cómo llegar al resultado, con secuencias, condiciones y bucles. Es el paradigma con el que se empieza siempre y el que domina los módulos 2 a 5 de este curso.

La pieza básica es el objeto: un paquete que contiene datos y las operaciones que actúan sobre ellos. Se modela el mundo como entidades que colaboran.

Lo estudiaremos a fondo en el módulo 7. Por ahora basta con quedarse con la idea: los datos y su comportamiento viajan juntos.

La pieza básica es la función, entendida en sentido matemático: recibe datos y devuelve un resultado, sin modificar nada externo. Se evita cambiar el estado y se favorece componer funciones.

No hay bucle ni lista que se va llenando: se declara qué se quiere («las que cumplen esta condición») y la maquinaria del lenguaje se encarga del cómo. Lo veremos en Funciones como valores.

Se describe qué se quiere obtener, sin decir en absoluto cómo obtenerlo. El caso más conocido es SQL, el lenguaje de las bases de datos.

En ninguna parte se dice cómo recorrer los datos ni en qué orden: eso lo decide el gestor de la base de datos. Es la abstracción llevada a su extremo, y funciona muy bien en dominios acotados.

Fíjate en que Python aparece en tres filas. La mayoría de lenguajes modernos son multiparadigma: no te obligan a elegir, y en un mismo programa conviven un bucle imperativo, una clase y una función lambda. Esa es otra razón por la que Python funciona bien como primer lenguaje: permite recorrer los tres estilos sin cambiar de herramienta.

Algunas lecturas que conviene hacer sobre esta tabla:

• La curva de aprendizaje no mide la potencia. Rust es dificilísimo porque te obliga a demostrar al compilador que tu gestión de memoria es correcta. Eso no lo hace mejor para escribir un gestor de tareas de tres personas.
• Los lenguajes se solapan. Python, Java, C# y Go pueden todos escribir el backend de una aplicación web. La elección depende más del contexto que de las capacidades.
• SQL no compite con los demás. Es un lenguaje especializado que se usa desde los otros: un programa Python que consulta una base de datos contiene SQL dentro. Sabrás Python y sabrás SQL, no uno u otro.

Cuando alguien pregunta «¿qué lenguaje uso?» sin decir para qué, la pregunta no tiene respuesta. Estos son los cuatro criterios que sí la dan.

1. El dominio del problema. Es, con diferencia, el criterio más determinante. Hay ámbitos donde la decisión está prácticamente tomada de antemano:

2. El ecosistema. Un lenguaje sin bibliotecas es un lenguaje sin utilidad práctica. Antes de elegir, pregúntate si hay bibliotecas maduras para lo que necesitas, documentación abundante, respuestas a los problemas típicos y gente que lo mantiene. Un lenguaje elegante con ecosistema pobre te obligará a reescribir cosas que en otro sitio son una línea.

3. El equipo. El mejor lenguaje para un proyecto suele ser el que ya sabe la gente que va a mantenerlo. Introducir un lenguaje nuevo cuesta meses de productividad y crea una dependencia peligrosa: si la única persona que lo domina se marcha, el proyecto queda huérfano. Este criterio, poco glamuroso, decide muchísimos proyectos reales.

4. El rendimiento y las restricciones técnicas. Importa menos de lo que la gente cree, pero cuando importa es innegociable. Si tienes que procesar millones de operaciones por segundo, o ejecutar en un microcontrolador con 16 KB de memoria, o garantizar un tiempo de respuesta máximo, la lista de candidatos se reduce sola.

Un consejo que ahorra discusiones: el segundo lenguaje cuesta mucho menos que el primero. Los conceptos de este curso —variables, condicionales, bucles, funciones, estructuras de datos, objetos— son los mismos en casi todos. Cambia la sintaxis, que es lo barato. Aprender bien uno vale más que picotear en cinco.

Con todo lo anterior sobre la mesa, la elección de Python para aprender a programar deja de ser una moda y pasa a ser una decisión defendible:

• Sintaxis mínima. print("Hola") es un programa completo: no hay que declarar una clase, ni un método principal, ni importar nada. Comparado con las seis líneas que exige Java para lo mismo, el alumno gasta su atención en el concepto y no en la ceremonia.
• Ciclo escribir-probar muy corto. Al ser interpretado, entre escribir una línea y ver su resultado hay dos segundos. Aprender es probar muchas veces, y cada segundo de espera desincentiva probar.
• Legibilidad por diseño. La indentación obligatoria fuerza un código ordenado desde el primer día. Un programa Python bien escrito se lee casi como pseudocódigo, lo que ayuda mucho cuando aún estás traduciendo entre idea y código.
• Multiparadigma. Permite recorrer el imperativo (módulos 2-3), el funcional (módulo 4) y la orientación a objetos (módulo 7) sin cambiar de lenguaje ni de herramientas.
• Utilidad real inmediata. No es un lenguaje «de juguete» para clase. Es una de las herramientas más demandadas del mercado en automatización, datos e IA. Lo que aprendas aquí sirve fuera.
• Ecosistema y comunidad enormes. Casi cualquier duda que tengas ya la ha tenido alguien y está respondida por escrito.

También es honesto decir qué no es lo mejor de Python: no es el lenguaje más rápido en ejecución, su tipado dinámico deja pasar a producción errores que un lenguaje estático detectaría antes, y gestionar dependencias entre proyectos exige disciplina (por eso existen los entornos virtuales que veremos en la próxima lección). Para TareaFácil —un programa pequeño, para tres personas, que debe estar en marcha pronto— ninguna de esas pegas es relevante. Ese razonamiento, y no la lista de virtudes, es la forma correcta de elegir un lenguaje.

Buscar «el mejor lenguaje». No existe. Existe el mejor lenguaje para este problema, este equipo y este plazo. Las discusiones sobre superioridad absoluta consumen mucho tiempo y no producen nada.

Confundir tipado dinámico con «sin tipos». Python tiene tipos, y muy estrictos: por eso "Tareas: " + 5 falla. Lo dinámico es cuándo se comprueban, no que no existan.

Creer que interpretado significa lento y ya está. Para el 95 % de los programas, la velocidad del lenguaje es irrelevante frente al tiempo de red, de disco o del propio usuario. Optimizar el lenguaje antes de saber dónde está el cuello de botella es tiempo perdido; lo veremos en Eficiencia y notación Big-O.

Saltar de lenguaje cada pocas semanas. Es el error más caro de quien empieza: se acumulan cinco introducciones y ningún programa terminado. Termina este curso con Python; el segundo lenguaje te costará una fracción del esfuerzo.

Pensar que aprender Python es aprender a programar. Lo que estás aprendiendo son conceptos —descomponer problemas, controlar el flujo, estructurar datos— que sobreviven al lenguaje. Python es el vehículo, no el destino.

Consejo: cuando leas código de un lenguaje que no conoces, no intentes entender cada símbolo. Busca primero las tres estructuras de la programación estructurada —secuencia, condición, repetición— y las funciones. Con eso reconocerás la lógica de casi cualquier código, aunque la sintaxis te resulte ajena.

Para cada lenguaje, indica: (a) si su tipado es estático o dinámico, (b) si es fuerte o débil, (c) su forma de ejecución habitual, y (d) un uso típico.

1. Python
2. Java
3. JavaScript
4. C

Para cada escenario, propón un lenguaje y justifica la elección con al menos dos de los cuatro criterios del apartado 6 (dominio, ecosistema, equipo, rendimiento):

1. Estudio Alba quiere que la web que enseña a los clientes tenga un formulario que valide los datos sin recargar la página.
2. Una empresa necesita el firmware de un sensor con 32 KB de memoria que debe responder en menos de un milisegundo.
3. Marta quiere un informe mensual que lea un fichero de ventas y calcule medias y gráficos. En el estudio nadie programa, pero Nuria hizo un curso de Python.
4. Un banco debe mantener un sistema de 400.000 líneas escrito en Java hace quince años, con un equipo de doce personas que lo conocen.

Indica a qué paradigma corresponde cada fragmento y explica en qué te has fijado:

Solución 1.

El caso de C sorprende a mucha gente: es estático pero débil, porque permite conversiones implícitas entre tipos numéricos y punteros que pueden producir resultados sin sentido sin que el compilador se queje.

Solución 2.

1. JavaScript. Dominio: es el único lenguaje que ejecutan los navegadores, así que validar sin recargar la página lo impone. Ecosistema: hay bibliotecas maduras de validación de formularios listas para usar.
2. C, o Rust si el equipo lo domina. Rendimiento y restricciones: con 32 KB no cabe un intérprete de Python ni una máquina virtual, y el tiempo de respuesta garantizado exige control del hardware. Dominio: los sistemas embebidos son territorio histórico de C, con compiladores para prácticamente cualquier microcontrolador.
3. Python. Equipo: Nuria ya tiene una base, y en un estudio de tres personas eso pesa mucho más que cualquier ventaja técnica. Ecosistema: pandas y matplotlib resuelven lectura de datos, cálculos y gráficos casi sin código propio.
4. Java. Equipo: doce personas conocen el sistema; reescribirlo en otro lenguaje destruiría quince años de conocimiento acumulado y de casos límite ya resueltos. Ecosistema: el entorno alrededor de esas 400.000 líneas (bibliotecas, servidores, herramientas) ya está montado y probado. La respuesta «lo reescribimos en algo moderno» es casi siempre la equivocada.

Solución 3.

• A: imperativo/estructurado. Se describe el procedimiento paso a paso: una variable acumuladora, un bucle que recorre elementos y una condición. Se dice cómo contar.
• B: declarativo. Se describe el resultado deseado sin indicar ningún recorrido ni orden. El gestor de la base de datos decide cómo obtenerlo.
• C: funcional. Se aplica una transformación (filter) con una función anónima (lambda) y se compone el resultado, sin variables que se van modificando ni bucle explícito.
• D: orientado a objetos. El código vive dentro de una clase y opera sobre los datos del propio objeto (self.tareas); los datos y el comportamiento están empaquetados juntos. Fíjate en que dentro usa una construcción de estilo funcional: los paradigmas se mezclan con total naturalidad.

Los lenguajes de programación se clasifican por cuatro ejes que ahora sabes leer: su nivel de abstracción (de la máquina al problema), su forma de ejecución (compilado, bytecode sobre máquina virtual o interpretado), su sistema de tipos (estático o dinámico, fuerte o débil) y su paradigma (imperativo, orientado a objetos, funcional o declarativo). Ningún eje establece superioridad: establece compromisos. Y elegir es cuestión de cuatro criterios —dominio, ecosistema, equipo y rendimiento— aplicados a un contexto concreto, no de preferencias personales.

Con esos criterios hemos justificado Python para este curso y para TareaFácil: sintaxis mínima, ciclo de prueba corto, legibilidad forzada por diseño, multiparadigma y con una utilidad profesional real más allá del aula. Sus inconvenientes existen, pero ninguno afecta a un programa pequeño para un estudio de tres personas.

Ya sabemos qué es programar, de dónde viene el oficio y con qué lo vamos a hacer. Falta lo más terrenal: montar el puesto de trabajo. En la siguiente lección, Entornos de desarrollo, instalaremos Python en Windows, macOS o Linux, comprobaremos que funciona, aprenderemos la diferencia entre el intérprete interactivo y ejecutar un fichero, elegiremos editor, organizaremos las carpetas del proyecto y crearemos por fin tareafacil.py, el fichero que nos acompañará el resto del curso.