De entrada, hay claras diferencias entre Go y Rust. Go tiene un enfoque más fuerte en la construcción de APIs web y pequeños servicios que pueden escalar infinitamente, especialmente con el poder de las goroutines. Esto último también es posible con Rust, pero las cosas son mucho más difíciles desde el punto de vista de la experiencia de los desarrolladores.
Rust funciona bien para el procesamiento de grandes cantidades de datos y otras operaciones intensivas de la CPU, como la ejecución de algoritmos. Esta es la mayor ventaja de Rust sobre Go. Los proyectos que exigen un alto rendimiento son generalmente más adecuados para Rust.
En este tutorial, compararemos y contrastaremos Go y Rust, evaluando cada lenguaje de programación para el rendimiento, la concurrencia, la gestión de la memoria, y la experiencia general del desarrollador. También presentaremos una visión general de estos elementos para ayudarte a elegir el lenguaje adecuado para tu proyecto de un vistazo.
Si estás empezando con Rust, podría ser una buena idea repasar esta guía para principiantes antes de seguir leyendo.
Si ya te has puesto al día, ¡entremos en materia!
Desarrollo
Originalmente diseñado por los ingenieros de Google, Go fue presentado al público en 2009. Se creó para ofrecer una alternativa a C++ que fuera más fácil de aprender y codificar y que estuviera optimizada para ejecutarse en CPUs multinúcleo.
Desde entonces, Go ha sido genial para los desarrolladores que quieren aprovechar la concurrencia que ofrece el lenguaje. El lenguaje proporciona goroutines que le permiten ejecutar funciones como subprocesos.
Una gran ventaja de Go es la facilidad con la que puede utilizar goroutines. Simplemente añadiendo la sintaxis go a una función hace que se ejecute como un subproceso. El modelo de concurrencia de Go le permite desplegar cargas de trabajo a través de múltiples núcleos de CPU, lo que lo convierte en un lenguaje muy eficiente.
package mainimport ( "fmt" "time")func f(from string) { for i := 0; i < 3; i++ { fmt.Println(from, ":", i) }}func main() { f("direct") go f("goroutine") time.Sleep(time.Second) fmt.Println("done")}
A pesar del soporte de CPU multinúcleo, Rust todavía se las arregla para superar a Go. Rust es más eficiente en la ejecución de algoritmos y operaciones que consumen muchos recursos. El Juego de Benchmarks compara Rust y Go para varios algoritmos, como los árboles binarios. Para todos los algoritmos probados, Rust fue al menos un 30 por ciento más rápido; en el caso de los cálculos de árboles binarios, fue hasta un 1.000 por ciento. Un estudio de Bitbucket muestra resultados similares en los que Rust rinde a la par que C++.
(Fuente: Benchmarks Game)
Concurrencia
Como se mencionó anteriormente, Go soporta concurrencia. Por ejemplo, digamos que está ejecutando un servidor web que maneja las solicitudes de la API. Puedes usar las goroutines de Go para ejecutar cada petición como un subproceso, maximizando la eficiencia al descargar las tareas a todos los núcleos de la CPU disponibles.
Las goroutines son parte de las funciones incorporadas de Go, mientras que Rust sólo ha recibido la sintaxis nativa async/await para soportar la concurrencia. Como tal, la ventaja de la experiencia del desarrollador va a Go cuando se trata de la concurrencia. Sin embargo, Rust es mucho mejor para garantizar la seguridad de la memoria.
Aquí hay un ejemplo de hilos simplificados para Rust:
use std::thread;use std::time::Duration;fn main() { // 1. create a new thread for i in 1..10 { thread::spawn(|| { println!("thread: number {}!", i); thread::sleep(Duration::from_millis(100)); }); } println!("hi from the main thread!");}
La concurrencia siempre ha sido un problema espinoso para los desarrolladores. No es una tarea fácil garantizar una concurrencia segura para la memoria sin comprometer la experiencia del desarrollador. Sin embargo, este enfoque de seguridad extrema llevó a la creación de la concurrencia probadamente correcta. Rust experimentó con el concepto de propiedad para evitar el acceso no solicitado a los recursos para prevenir los errores de seguridad de memoria.
Rust ofrece cuatro paradigmas de concurrencia diferentes para ayudarle a evitar los errores comunes de seguridad de memoria. Vamos a echar un vistazo más de cerca a dos paradigmas comunes: canal y bloqueo.
Canal
Un canal ayuda a transferir un mensaje de un hilo a otro. Aunque este concepto también existe para Go, Rust permite transferir un puntero de un hilo a otro para evitar condiciones de carrera por los recursos. A través de la transferencia de punteros, Rust puede reforzar el aislamiento de hilos para los canales. De nuevo, Rust muestra su obsesión por la seguridad de la memoria en lo que respecta a su modelo de concurrencia.
Lock
Los datos sólo son accesibles cuando se mantiene el bloqueo. Rust se basa en el principio de bloquear los datos en lugar del bacalao, que se encuentra a menudo en lenguajes de programación como Java.
Para más detalles sobre el concepto de propiedad y todos los paradigmas de concurrencia, echa un vistazo a «Fearless Concurrency with Rust.»
Seguridad de memoria
El concepto anterior de propiedad es uno de los principales puntos de venta de Rust. Rust lleva la seguridad de tipos, que también es importante para permitir una concurrencia segura en memoria, al siguiente nivel.
Según el blog de Bitbucket, «el compilador muy estricto y pedante de Rust comprueba cada variable que usas y cada dirección de memoria a la que haces referencia. Evita posibles condiciones de carrera de datos y te informa sobre el comportamiento indefinido»
Esto significa que no terminarás con un desbordamiento de búfer o una condición de carrera debido a la extrema obsesión de Rust con la seguridad de la memoria. Sin embargo, esto también tiene sus desventajas. Por ejemplo, tienes que ser muy consciente de los principios de asignación de memoria mientras escribes el código. No es fácil tener siempre la guardia de seguridad de memoria en alto.
Experiencia del desarrollador
En primer lugar, veamos la curva de aprendizaje asociada a cada lenguaje. Go fue diseñado con la simplicidad en mente. Los desarrolladores a menudo se refieren a él como un lenguaje «aburrido», lo que quiere decir que su limitado conjunto de características incorporadas hace que Go sea fácil de adoptar.
Además, Go ofrece una alternativa más sencilla a C++, ocultando aspectos como la seguridad y la asignación de memoria. Rust adopta otro enfoque, obligando a pensar en conceptos como la seguridad de la memoria. El concepto de propiedad y la capacidad de pasar punteros hace que Rust sea una opción menos atractiva de aprender. Cuando estás constantemente pensando en la seguridad de la memoria, eres menos productivo y tu código está destinado a ser más complejo.
La curva de aprendizaje para Rust es bastante empinada en comparación con Go. Vale la pena mencionar, sin embargo, que Go tiene una curva de aprendizaje más empinada que los lenguajes más dinámicos como Python y JavaScript.
Cuándo usar Go
Go funciona bien para una amplia variedad de casos de uso, por lo que es una gran alternativa a Node.js para crear APIs web. Como señala Loris Cro, «el modelo de concurrencia de Go es un buen ajuste para las aplicaciones del lado del servidor que deben manejar múltiples peticiones independientes». Esta es exactamente la razón por la que Go proporciona goroutines.
Además, Go tiene soporte incorporado para el protocolo web HTTP. Puedes diseñar rápidamente una pequeña API utilizando el soporte HTTP incorporado y ejecutarla como un microservicio. Por lo tanto, Go encaja bien con la arquitectura de microservicios y satisface las necesidades de los desarrolladores de APIs.
En resumen, Go es una buena opción si valoras la velocidad de desarrollo y prefieres la simplicidad de la sintaxis sobre el rendimiento. Además de eso, Go ofrece una mejor legibilidad del código, que es un criterio importante para los grandes equipos de desarrollo.
Elija Go cuando:
- Se preocupe por la simplicidad y la legibilidad
- Desee una sintaxis fácil para escribir código rápidamente
- Desee utilizar un lenguaje más flexible que soporte el desarrollo web
Cuándo utilizar Rust
Rust es una gran elección cuando el rendimiento es importante, como cuando se procesan grandes cantidades de datos. Además, Rust te da un control detallado sobre cómo se comportan los hilos y cómo se comparten los recursos entre ellos.
Por otro lado, Rust viene con una curva de aprendizaje empinada y ralentiza la velocidad de desarrollo debido a la complejidad extra de la seguridad de la memoria. Esto no es necesariamente una desventaja; Rust también garantiza que no se encontrarán errores de seguridad de memoria ya que el compilador comprueba todos y cada uno de los punteros de datos. Para los sistemas complejos, esta garantía puede ser útil.
Elija Rust cuando:
- Se preocupe por el rendimiento
- Desee un control de grano fino sobre los hilos
- Valore la seguridad de la memoria por encima de la simplicidad
Go vs. Rust: Mi opinión sincera
Empecemos por destacar las similitudes. Tanto Go como Rust son de código abierto y están diseñados para soportar la arquitectura de microservicios y los entornos de computación en paralelo. Ambos optimizan la utilización de los núcleos de CPU disponibles a través de la concurrencia.
Pero al final del día, ¿qué lenguaje es mejor?
Hay muchas maneras de abordar esta pregunta. Yo recomendaría pensar en el tipo de aplicación que quieres construir. Go sirve bien para crear aplicaciones web y APIs que aprovechan sus características de concurrencia incorporadas mientras soportan la arquitectura de microservicios.
También puedes usar Rust para desarrollar una API web, pero no fue diseñado con este caso de uso en mente. El enfoque de Rust en la seguridad de la memoria aumenta la complejidad y el tiempo de desarrollo, especialmente para una API web bastante simple. Sin embargo, la mayor cantidad de control que tienes sobre tu código te permite escribir un código más optimizado, eficiente en memoria y con mayor rendimiento.
Para decirlo de la manera más sencilla posible, el debate Go versus Rust es realmente una cuestión de simplicidad versus seguridad.
Para más perspectivas, echa un vistazo a «Elegir entre Go y Rust».
LogRocket: Visibilidad completa de las aplicaciones Rust en producción
Depurar las aplicaciones Rust puede ser difícil, especialmente cuando los usuarios experimentan problemas difíciles de reproducir. Si estás interesado en monitorizar y rastrear el rendimiento de tus aplicaciones Rust, aflorar automáticamente los errores y rastrear las peticiones de red lentas y el tiempo de carga, prueba LogRocket. 
LogRocket es como un DVR para aplicaciones web, grabando literalmente todo lo que ocurre en tu aplicación Rust. En lugar de adivinar por qué ocurren los problemas, puedes agregar y reportar en qué estado estaba tu aplicación cuando ocurrió un problema. LogRocket también monitorea el rendimiento de su aplicación, reportando métricas como la carga de la CPU del cliente, el uso de la memoria del cliente, y más.
Modernice la forma de depurar sus aplicaciones Rust – comience a monitorear de forma gratuita.