Los lenguajes más rápidos para este 2025

Como todo programador que busca siempre la eficiencia de los programas que construye, siempre me ha interesado conocer la velocidad de los programas creados por los distintos lenguajes de programación existentes.

Así que, para iniciar el año, qué mejor que una prueba de referencia, o como dirían los anglosajones un «benchmark» entre lenguajes de programación.

Para esta prueba he elegido un algoritmo sencillo, para calcular la cantidad de números primos que existen en un intervalo fijo. El código de cada lenguaje, será lo más fiel posible a los demás, para hacer más justa la prueba. Y, adelantándome a los reclamos «No he elegido el mejor algoritmo para este problema, solo uso uno representativo y que sea exigente en cuanto a iteraciones y cálculos dentro de bucles».

Los lenguajes elegidos para esta prueba serán:

• C
• C++
• Java
• PHP
• Javascript (Node.js)
• Python3
• Object Pascal
• Rust
• Go

Para no tener que instalar todos estos lenguajes, y sus herramientas de desarrollo, en mi PC (Y para que no digan que los configuro a mi gusto) voy a usar los compiladores que nos ofrece https://www.onlinegdb.com:

Hasta donde tengo entendido, todos los compiladores e intérpretes que ofrece este sitio, corren en un servidor Linux – Ubuntu y en modo consola. Las versiones exactas de los compiladores (al menos de algunos de ellos) se ofrecen en el mismo sitio:

Language	Compiler	Debugger
c	gcc 11.4.0 -std=gnu99	gdb 12.1
c++	g++ 11.4.0 -std=c++11	gdb 12.1
c++14	g++ 11.4.0 -std=c++14	gdb 12.1
c++17	g++ 13.1.0 -std=c++17	gdb 12.1
c++20	g++ 13.1.0 -std=c++20	gdb 12.1
c++23	g++ 13.1.0 -std=c++2b	gdb 12.1
Python 3	python3 3.8.10	pdb 3.8.10
Rust	rustc 1.61.0	–
Fortran	gfortran 11.3.0	–

Para Node.js, se está usando la versión v20.16. Para PHP se está usando PHP 7.2.34, así que no se está aprovechando las mejoras de rendimiento que ofrece PHP 8. Para Pascal, se usa el compilador Free Pascal 3.2.2, de acuerdo a los mensajes de consola, así que no está tan desactualizado. En el caso de Java, leyendo la propiedad System.getProperty(«java.version»), se obtiene 11.0.4, así que no es una versión muy antigua.

Y ahora sí, vamos con el código. Empecemos con la versión en C:

#include <stdio.h>
#include <time.h>
#include <math.h>

// Función para verificar si un número es primo
int es_primo(long long int num) {
    if (num <= 1) return 0;
    for (long long int i = 2; i <= sqrt(num); i++) {
        if (num % i == 0) return 0;  // Si es divisible por i, no es primo
    }
    return 1;  // Es primo
}

// Función que simula una tarea compleja de cálculo
void tarea_larga() {
    long long int count = 0;
    for (long long int i = 2; i < 1000000; i++) {
        if (es_primo(i)) {
            count++;  // Contar los números primos encontrados
        }
    }
    printf("Cantidad de números primos encontrados: %lld\n", count);
}

int main() {
    // Variables para almacenar el tiempo de inicio y fin
    clock_t start, end;
    double tiempo;

    // Capturar el tiempo de inicio
    start = clock();

    // Ejecutar la tarea larga
    tarea_larga();

    // Capturar el tiempo de finalización
    end = clock();

    // Calcular el tiempo transcurrido en segundos
    tiempo = ((double)(end - start)) / CLOCKS_PER_SEC;

    // Mostrar el tiempo de ejecución de la tarea
    printf("El tiempo de ejecución de tarea_larga() es: %.6f segundos\n", tiempo);

    return 0;
}

Con un poco de ayuda de la IA, podemos replicar el mismo código en los diferentes lenguajes a usar y así obtenemos las siguientes versiones:

Las pruebas se hicieron también en línea, con tres ejecuciones por código, y tomando el tiempo promedio para calcular el tiempo final.

Y, finalmente, los resultados para ver el tiempo de ejecución son:

¡Vaya sorpresa! Honestamente, no esperaba tal resultado, especialmente por JavaScript. El buen Node.js tiene un compilador JIT (Parece que ya nadie usa intérpretes en estos días) bastante inteligente y, al menos para este tipo de tareas, de tipo iterativo, funciona bastante bien. Sospecho que es el único compilador que codificó en INLINE a las subrutinas usadas.

De Object Pascal, no puedo decir mucho, puesto que Free Pascal es un compilador que genera código nativo desde hace mucho tiempo, y se notan las mejoras introducidas en las versiones recientes. Además, personalmente siempre lo he visto al nivel de C y C++.

De «Go» siempre he oído que es un buen compilador, y parece que, para este tipo de tareas, lo ha demostrado. Un lenguaje moderno que está a la altura del C y C++, y que ha corregido varias de las aberraciones que arrastraba C++ en su sintaxis.

«C» es un lenguaje compilado por excelencia, y al menos en esta prueba, no ofrece gran rendimiento. A estas alturas ya C, debería ponerse en forma porque los rivales son muchos y muy inteligentes.

De Java no quiero decir nada. Los que me conocen saben cuanto aborrezco «aprecio» a este horrible lenguaje. Pero si hay algo que reconocerle es que el compilador de su JRE hace un buen trabajo para optimizar los bucles. Aunque en este caso, es algo mediocre.

C++ sorprende, para mal. Tuve que ponerme a revisar el código usado para la prueba para convencerme de lo mal que le ha ido en esta prueba. Pero la verdad es que no me hago muchas esperanzas con C++ y evito usarlo en lo posible. Con todas las características y herramientas que se le han agregado al lenguaje, tenemos un cohete Saturno V, tratando de competir con autos de carrera.

De PHP, esperaba más pero no sorprende porque no se está usando la versión 8 que incluye considerables mejoras en el rendimiento de las aplicaciones, así que, hasta cierto punto, su resultado no es tan justo en esta prueba.

Python es la tortuga de este grupo. Y no es la primera vez que se le ve arrastrándose en pruebas de este tipo. Este lenguaje no se hizo para competir con los grandes en cuanto a velocidad, sino más bien para ser un lenguaje de alto nivel con el que sea agradable programar al estilo moderno. Al menos esa es mi opinión, pero, con mucho respeto, este lenguaje es una pérdida de tiempo, literalmente, para aplicaciones de alto rendimiento.

CONCLUSIÓN Y DESCARGO

Hay que reconocer el rendimiento actual de los lenguajes clásicamente interpretados (menos Python) especialmente de JavaScript, y hay que tomar en serio a las alternativas a C/C++, como Object Pascal y Go.

Esta comparación no debe generalizarse, solo evalúan el desempeño de ciertos compiladores en la generación de código para un programa modelo, en una plataforma particular, pero es un buen indicio de que tan rápidos son los programas que producen.