Rust (lenguaje de programación)

De Wikipedia, la enciclopedia libre
Ir a la navegación Ir a la búsqueda
Rust
Rust programming language black logo.svg
Desarrollador(es)
Desarrolladores del proyecto Rust
https://www.rust-lang.org/, https://www.rust-lang.org/zh-CN/, https://www.rust-lang.org/zh-TW/, https://www.rust-lang.org/ja/, https://www.rust-lang.org/es/, https://www.rust-lang.org/it/, https://www.rust-lang.org/pt-BR/, https://www.rust-lang.org/ru/ y https://www.rust-lang.org/tr/
Información general
Extensiones comunes .rs
Paradigma multiparadigma, imperativo, orientado a objetos, procedural, concurrente, funcional, compilado, propósito general
Apareció en 2010
Diseñado por Graydon Hoare
Última versión estable 1.49.0[1](31 de diciembre de 2020 (1 mes y 27 días))
Sistema de tipos estático, fuerte, inferenciado, estructural
Influido por Alef, C#, C++, Camlp4, Common Lisp, Cyclone, Erlang, Haskell, Hermes, Limbo, Napier, Napier88, Newsqueak, NIL, Ruby, Sather, Standard ML, Ocaml, Racket, Swift
Ha influido a C#, Elm, Idris, Swift
Sistema operativo Linux, macOS, Windows, FreeBSD, OpenBSD[2]​, Redox, Android, iOS[3]
Licencia Licencia Apache 2.0 o Licencia MIT[4]

Rust es un lenguaje de programación compilado, de propósito general y multiparadigma que está siendo desarrollado por Mozilla.[5]​ Ha sido diseñado para ser "un lenguaje seguro, concurrente y práctico".[6][7]​ Es un lenguaje de programación multiparadigma que soporta programación funcional pura, por procedimientos, imperativa y orientada a objetos.

Según la política de Mozilla,[8]​ Rust es desarrollado de forma totalmente abierta y busca la opinión y contribución de la comunidad. El diseño del lenguaje se ha ido perfeccionando a través de las experiencias en el desarrollo del motor de navegador Servo,[9]​ y el propio compilador de Rust. Aunque es desarrollado y patrocinado por Mozilla y Samsung, es un proyecto comunitario. Una gran parte de las contribuciones proceden de los miembros de la comunidad.[10]

Para el 2020 es uno de los lenguajes de programación más usados a la hora de trabajar con criptomonedas y crear nodos para minar criptoactivos.[11]

Descripción[editar]

El objetivo de Rust es ser un buen lenguaje para la creación de grandes programas del lado del cliente y del servidor que se ejecuten en Internet. Esto ha llevado a un conjunto de características con un énfasis en la seguridad, el control de distribución de la memoria y la concurrencia. Se espera que el rendimiento de código seguro sea más lento que C++, si el rendimiento es la única consideración, pero si lo comparamos con el código C++ hecho para que tome precauciones comparables a las que toma Rust, este último puede ser incluso más rápido.[12]

La sintaxis de Rust es similar a la de C y C++, con bloques de código delimitados por llaves y estructuras de control de flujo tales como if, else, do, while y for. No todas las estructuras de C y C++ están presentes, además, otras (como la palabra clave match para ramificación multidireccional) serán menos familiares para programadores que vienen de estos lenguajes.

El sistema está diseñado para tener un acceso seguro a la memoria, y no permite punteros nulos o punteros colgantes.[13][14]​ Los valores de los datos sólo se pueden inicializar a través de un conjunto fijo de formas, las cuales requieren que sus entradas hayan sido ya inicializadas.[15]

El sistema de tipos soporta un mecanismo similar a las clases de tipos, llamado "traits", inspirados directamente por el lenguaje Haskell. Esta es una facilidad para el polimorfismo que soporta distintos tipos de argumentos (polimorfismo ad-hoc), lograda mediante la adición de restricciones para escribir declaraciones de variables. Otras características de Haskell, como el polimorfismo de diferente tipo (higher-kinded), no están soportadas.

Rust cuenta con inferencia de tipos, para las variables declaradas con la palabra clave let. Tales variables no requieren ser inicializadas con un valor asignado con el fin de determinar su tipo. A tiempo de compilación produce un error si cualquier rama de código falla al asignar un valor a la variable.[16]​ Las funciones pueden recibir parámetros genéricos pero deben ser delimitados expresamente por los traits, no hay manera de dejar fuera de declaraciones de tipo sin dejar de hacer uso de los métodos y operadores de los parámetros.

La concurrencia es soportada a través de tareas simples, similares a los encontrados en Erlang y otros lenguajes basado en actores. En dichos sistemas, las tareas se comunican a través del paso de mensajes, en lugar de compartir los datos directamente. Por motivos de rendimiento, es posible enviar datos sin copiar, usar cajas únicas. Las cajas únicas son la garantía de tener un solo propietario, y puede ser liberada por la tarea de enviar para su uso por el receptor.

El sistema de objetos de Rust se basa en implementaciones, traits y tipos estructurados. Las implementaciones cumplen una función similar a la de las clases en otros lenguajes, y se definen con la palabra clave impl. Herencia y polimorfismo son proporcionados por los traits, permiten que los métodos se definan y se mezclen en las implementaciones. Los tipos estructurados se utilizan para definir los campos. Implementaciones y rasgos no pueden definir los campos propios, y sólo los traits proporcionar herencia, con el fin de evitar el problema del diamante de C++.

Historia[editar]

Los usuarios de Rust se refieren a sí mismos como rustáceos y usan a Ferris como su mascota

El lenguaje surgió a partir de un proyecto personal iniciado en 2006 por el empleado de Mozilla, Graydon Hoare,[17]​ quien afirmó que el proyecto posiblemente recibió su nombre de la familia de hongos de la roya.[18]​ Mozilla comenzó a patrocinar el proyecto en 2009 [17]​ y lo anunció en 2010.[19][20]​ El mismo año, el trabajo pasó del compilador inicial (escrito en OCaml) al compilador autohospedado escrito en Rust.[21]​ Denominado rustc, se compiló con éxito en 2011.[22]​ rustc usa LLVM como su back end.

La primera versión pre-alfa numerada del compilador de Rust se produjo en enero de 2012.[23]​ Rust 1.0, la primera versión estable, se publicó el 15 de mayo de 2015.[24][25]​ Después de 1.0, las versiones de puntos estables se entregan cada seis semanas, mientras que las funciones se desarrollan en Rust todas las noches y luego se prueban con versiones alfa y beta que duran seis semanas.[26]

Junto con la escritura estática convencional, antes de la versión 0.4, Rust también admitía typestates. El sistema typestate modeló aserciones antes y después de las sentencias del programa, mediante el uso de una checksentencia especial. Las discrepancias se pueden descubrir en el momento de la compilación, en lugar de cuando se ejecuta un programa, como podría ser el caso de las aserciones en código C o C ++. El concepto typestate no era exclusivo de Rust, ya que se introdujo por primera vez en el lenguaje NIL.[27]​ Los typestates se eliminaron porque en la práctica se usaban poco, aunque la misma función aún se puede lograr con un patrón de marca.[28]

El estilo del sistema de objetos cambió considerablemente en las versiones 0.2, 0.3 y 0.4 de Rust. La versión 0.2 introdujo clases por primera vez, y la versión 0.3 agregó varias características, incluidos destructores y polimorfismo mediante el uso de interfaces. En Rust 0.4, se agregaron rasgos como un medio para proporcionar herencia; las interfaces se unificaron con rasgos y se eliminaron como una característica separada. Las clases también se eliminaron, reemplazadas por una combinación de implementaciones y tipos estructurados.

Comenzando en Rust 0.9 y terminando en Rust 0.11, Rust tenía dos tipos de punteros incorporados: ~y @, simplificando el modelo de memoria central. Reimplementó esos tipos de puntero en la biblioteca estándar como Boxy (ahora eliminado) Gc.

En enero de 2014, antes de la primera versión estable, Rust 1.0, el editor en jefe de Dr. Dobb's, Andrew Binstock, comentó sobre las posibilidades de Rust de convertirse en un competidor de C ++ y de los otros lenguajes próximos D, Go y Nim (entonces Nimrod). Según Binstock, mientras que Rust era "ampliamente visto como un lenguaje notablemente elegante", la adopción se ralentizó porque cambió repetidamente entre versiones.[29]

Rust fue el tercer lenguaje de programación más querido en la encuesta anual de Stack Overflow de 2015[30]​ y ocupó el primer lugar en 2016-2020. [31][32][33][34][35]

El lenguaje se menciona en El libro de Mozilla como "metal oxidado".[36]

Ejemplos[editar]

El siguiente código es válido para Rust 0.8. En versiones posteriores puede cambiar la sintaxis o las funciones.

Programa que muestra la frase "¡Hola, mundo!":

fn main() {
    println!("¡Hola, mundo!");
}

Dos versiones de la función factorial, en el estilo recursivo e iterativo:

/* Las ramas en esta función exhiben los valores de retorno implícito opcional
   de Rust, que pueden ser usados cuando se prefiera un estilo más "funcional".
   A diferencia de C++ y otros lenguajes similares, la estructura de control
   `if` es una expressión en vez de una declaración, y por tanto tiene un valor
   de retorno propio. */

fn recursive_factorial(n: i32) -> i32 {
    if n == 0 {
        1
    } else {
        n * recursive_factorial(n-1)
    }
}
 
fn iterative_factorial(n: i32) -> i32 {
    // Las variables son declaradas con `let`.
    // La palabra `mut` permite que las variables puedan ser mutadas.
    let mut i = 1;
    let mut result = 1;
    while i <= n {
        result *= i;
        i += 1;
    }
    return result; // Un retorno explítico, en contraste con la función previa.
}
 
fn main() {
    println!("Resultado recursivo: {:i}", recursive_factorial(10));
    println!("Resultado iterativo: {:i}", iterative_factorial(10));
}

Una simple demostración de las capacidades de concurrencia ligera de Rust:

/* Esta función crea diez "tareas" que se pueden ejecutar concurrentemente.
   Ejecútalo múltiples veces y observa la salida irregular que se obtiene al
   estar cada tarea llamando al stdout, ya que cada tarea puede producirse entre
   las sucesivas llamadas a `println` y dentro de la función `println` en sí. */

fn main() {
    // Esta cadena es inmutable, para que pueda ser accedida de forma segura
    // por múltiples tareas.
    let message = "¡Miradme, soy un proceso ligero!";
    // Los bucles `for` funcionan con cualquier tipo que implemente el trait
    // `Iterator`.
    for num in range(0, 10) {
        do spawn {
            println(message);
            // `println!` es una macro que verifica estáticamente un string de
            // formato. Las macros son estructurales (como en Scheme) en lugar
            // de ser textuales (como en C).
            println!("Este mensaje ha sido ofrecido por la tarea {:i}.", num);
        }
    }
}

Evolución del lenguaje[editar]

Además de los tipos estáticos convencionales, Rust también incluyó typestates hasta su versión 0.4. El sistema typestate modela afirmaciones antes y después de las declaraciones del programa, mediante el uso de una declaración de verificación especial. Las discrepancias pueden ser descubiertas durante la compilación, en lugar de una vez que el programa se ejecuta, como podría ser el caso de las aserciones en el código C o C++. El concepto typestate no es exclusivo de Rust, ya que se introdujo por primera vez en el lenguaje de programación NIL.[27]​ Fueron retirados los typestates porque en la práctica se encontraron poco usados, sin embargo la misma funcionalidad aún se puede lograr con los patrones del mismo lenguaje.[37]

El estilo del sistema de objetos ha cambiado considerablemente en las versiones 0.2, 0.3 y 0.4 de Rust. La versión 0.2 introdujo clases por primera vez, con la versión 0.3 añadiendo un número de características que incluyen destructores y polimorfismo mediante el uso de interfaces. En Rust 0.4, se añadieron traits como un medio para proporcionar herencia, las interfaces se unificaron con los traits y eliminándose como una característica independiente. También se eliminaron las clases, reemplazadas por una combinación de las implementaciones y tipos estructurados.

Interfaces gráficas (GUI)[editar]

Rust permite la creación de interfaces gráficas mediante las APIs nativas de la plataforma anfitriona, esto gracias a que tiene características de un lenguaje de bajo nivel. Sin embargo, esta ruta de desarrollo puede llegar a generar dificultades en proyectos que planten la admision de múltiples plataformas.[38]

Actualmente existen múltiples desarrollos para crear GUIs en Rust, algunos permiten la creación de la interfaz junto a Electron o haciendo uso de HTML, algunos otros, suministran bibliotecas nativas para el lenguaje, pero todavía se encuentran en un estado inmaduro de desarrollo. Finalmente están los proyectos que enlazan bibliotecas bastante conocidas y con una mayor madurez en su desarrollo, como GTK o Qt, lo cuales permiten desarrollos multiplataforma.[39]​ Algunos proyectos populares son los siguientes:

gtk-rs[editar]

Ejemplo de interfaz con GTK

Es una implementación de las bibliotecas de GTK 3 para el uso junto al lenguaje Rust. Para ello, crea funciones de Rust superpuestas a las funciones de las bibliotecas de GTK en C, haciendo uso de Foreign Function Interface que ofrece Rust.

conrod[editar]

Biblioteca de bajo nivel que hace uso de OpenGL o Vulkan.

Proyectos[editar]

Navegador web[editar]

Se están escribiendo en Rust un navegador web y varios componentes relacionados, que incluyen:

  • Firefox
    • Servo: motor de navegador web paralelo de Mozilla desarrollado en colaboración con Samsung
    • Quantum : un proyecto, compuesto por varios subproyectos, para mejorar el motor del navegador web Gecko de Firefox, desarrollado por Mozilla

Sistemas operativos[editar]

Muchos sistemas operativos (SO) y componentes relacionados se están escribiendo en Rust. A partir de enero de 2019, los sistemas operativos incluían: BlogOS, intermezzOS, QuiltOS, Redox, RustOS, Rux, Tefflin y Tock.

  • Redox: Un micronucleo
  • Stratis: Un sistema de archivos para Fedora y RHEL 8.

Otro[editar]

  • La magia de bolsillo - Dropbox 's del sistema de archivos que alimenta sus Diskotech petabyte máquinas de almacenamiento.
  • Firecracker: microVM seguras y rápidas para la informática sin servidor
  • exa - un reemplazo moderno para ls.
  • Microsoft Azure IoT Edge: una plataforma utilizada para ejecutar servicios de Azure e inteligencia artificial en dispositivos de IoT tiene componentes implementados en Rust
  • OpenDNS : utilizado en dos de sus componentes
  • Tor : una red de anonimato , escrita originalmente en C, está experimentando con la migración a Rust por sus características de seguridad
  • TiKV: una base de datos distribuida de valor clave desarrollada por primera vez por PingCAP , ahora un proyecto miembro de Cloud Native Computing Foundation
  • Wargroove : un videojuego desarrollado por Chucklefish que usa Rust para su software de servidor.
  • Xi: un editor de texto de Raph Levien, utilizado dentro del sistema operativo Fuchsia.
  • Deno : un tiempo de ejecución seguro para JavaScript y TypeScript creado con V8 , Rust y Tokio
  • Linkerd 2.x: una herramienta de "malla de servicios" para la supervisión de microservicios está escrita en gran parte en Rust.
  • TerminusDB - diseño y disposición de la estructura de datos
  • Discord : servicio de chat dirigido a jugadores que usa Rust para partes de su backend, así como codificación de video del lado del cliente.
  • rav1e: un codificador de formato de video AV1 experimental.
  • Ruffle: Un emulador que está siendo desarrollado para rescatar el contenido del Plugin Flash Player de Adobe, el cual finalizó su soporte oficial el 31 de diciembre del 2020.

Historial de versiones publicadas[editar]

  • 1.2.0, 1.1.0, 1.0.0, 1.3.0, 1.4.0, 1.5.0, 1.6.0, 1.7.0, 1.8.0, 1.9.0, 1.10.0, 1.11.0, 1.12.0, 1.12.1, 1.13.0, 1.14.0, 1.15.0, 1.15.1, 1.16.0, 1.17.0, 1.18.0, 1.19.0, 1.20.0, 1.21.0, 1.22.1, 1.24.1, 1.26.1, 0.2, 0.4, 0.5, 0.3, 0.6, 1.26.2, 1.27.0, 1.27.1, 1.27.2, 0.7, 0.8, 0.9, 0.10, 1.22.0, 1.23.0, 1.24.0, 1.25.0, 1.26.0, 1.28.0, 1.29.0, 1.29.1, 1.29.2, 1.30.0, 1.30.1, 1.31.0, 1.31.1, 1.32.0, 1.33.0, 1.34.0, 1.34.1, 1.34.2, 1.35.0, 1.36.0, 1.37.0, 1.38.0, 1.39.0, 1.40.0, 1.41.0, 1.41.1, 1.42.0, 1.43.0, 1.43.1, 1.44.0, 1.44.1, 1.45.0, 1.45.1, 1.45.2, 1.46.0, 0.1, 0.11.0, 0.12.0, 1.47.0, 1.48.0, 1.49.0 y 1.50.0

Véase también[editar]

Referencias[editar]

  1. https://blog.rust-lang.org
  2. «OpenBSD ports». Consultado el 3 de abril de 2018. 
  3. «Building and Deploying a Rust library on iOS». 6 de septiembre de 2017. Consultado el 11 de enero de 2019. 
  4. «COPYRIGHT». Rust compiler source repository. Consultado el 17 de diciembre de 2012. 
  5. Noel (8 de julio de 2010). «The Rust Language». Lambda the Ultimate (en inglés). Consultado el 30 de octubre de 2010. 
  6. «The Rust Programming Language». Consultado el 21 de octubre de 2012. 
  7. «Doc language FAQ». Consultado el 21 de octubre de 2012. 
  8. «The Mozilla Manifesto». Consultado el 9 de abril de 2012. 
  9. Peter Bright (3 de abril de 2013). «Samsung teams up with Mozilla to build browser engine for multicore machines». Consultado el 4 de abril de 2013. 
  10. «Rust Contributors». 
  11. «Lenguajes de programacion para Bitcoins: Hablan los desarrolladores.». 
  12. Walton, Patrick (5 de diciembre de 2010). «C++ Design Goals in the Context of Rust». Consultado el 21 de enero de 2011. «… It’s impossible to be “as fast as C” in all cases while remaining safe… C++ allows all sorts of low-level tricks, mostly involving circumventing the type system, that offer practically unlimited avenues for optimization. In practice, though, C++ programmers restrict themselves to a few tools for the vast majority of the code they write, including stack-allocated variables owned by one function and passed by alias, uniquely owned objects (often used with auto_ptr or the C++0x unique_ptr), and reference counting via shared_ptr or COM. One of the goals of Rust’s type system is to support these patterns exactly as C++ does, but to enforce their safe usage. In this way, the goal is to be competitive with the vast majority of idiomatic C++ in performance, while remaining memory-safe…». 
  13. Rosenblatt, Seth (3 de abril de 2013). «Samsung joins Mozilla's quest for Rust». Consultado el 5 de abril de 2013. «[Brendan Eich] noted that every year browsers fall victim to hacking in the annual Pwn2Own contest at the CanSecWest conference. "There's no free memory reads" in Rust, he said, but there are in C++. Those problems "lead to a lot of browser vulnerabilities" and would be solved by Rust, which is a self-compiling language.» 
  14. Brown, Neil (17 de abril de 2013). «A taste of Rust». Consultado el 25 de abril de 2013. «… Other more complex data structures could clearly be implemented to allow greater levels of sharing, while making sure the interface is composed only of owned and managed references, and thus is safe from unplanned concurrent access and from dangling pointer errors.» 
  15. «Doc language FAQ». 14 de septiembre de 2010. Consultado el 11 de enero de 2012. 
  16. Walton, Patrick (1 de octubre de 2010). «Rust Features I: Type Inference». Consultado el 21 de enero de 2011. 
  17. a b Rust Team (9 de junio de 2016). «The Rust Project». rust-lang (en inglés). Archivado desde el original el 9 de junio de 2016. Consultado el 27 de junio de 2019. 
  18. kibwen (7 de junio de 2014). «Internet archaeology: the definitive, end-all source for why Rust is named "Rust"». reddit (en inglés). Consultado el 17 de septiembre de 2019. 
  19. Brendan Eich (29 de abril de 2011). «Future Tense». slideshare (en inglés). Consultado el 18 de septiembre de 2020. 
  20. Mozilla Team (29 de abril de 2011). «Project Servo» (PDF). venge (en inglés). Consultado el 7 de julio de 2010. 
  21. Graydon (2 de octubre de 2010). «Rust progress». Graydon's work on Mozilla (en inglés). Archivado desde el original el 15 de agosto de 2014. Consultado el 30 de octubre de 2010. 
  22. Hoare, Graydon (20 de abril de 2011), «rust-dev stage1 rustc builds» (en en), lista de correo rust-dev, https://mail.mozilla.org/pipermail/rust-dev/2011-April/000330.html, consultado el 18 de septiembre de 2020. 
  23. catamorphism (20 de enero de 2012). «Mozilla and the Rust community release Rust 0.1 (a strongly-typed systems programming language with a focus on memory safety and concurrency)». reddit (en inglés). Consultado el 18 de septiembre de 2020. 
  24. Rust Team (20 de enero de 2012). «rust/RELEASES.md». github (en inglés). Consultado el 18 de septiembre de 2020. 
  25. Rust Team (15 de mayo de 2015). «Announcing Rust 1.0». Rust Blog (en inglés). Consultado el 18 de septiembre de 2020. 
  26. Rust Team (12 de diciembre de 2014). «Rust 1.0: Scheduling the trains». Rust Blog (en inglés). Consultado el 18 de septiembre de 2020. 
  27. a b Strom, Robert E.; Yemini, Shaula (1986). Typestate: A Programming Language Concept for Enhancing Software Reliability. IEEE Transactions on Software Engineering. ISSN 0098-5589. Consultado el 14 de noviembre de 2010. 
  28. pcwalton (26 de diciembre de 2012). «Typestate Is Dead, Long Live Typestate!». pcwalton (en inglés). Consultado el 18 de septiembre de 2020. 
  29. Binstock, Andrew (7 de enero de 2014). «The Rise And Fall of Languages in 2013». Dr.Dobb's (en inglés). Consultado el 18 de septiembre de 2020. 
  30. stackoverflow Team (2015). «2015 Developer Survey». stackoverflow (en inglés). Consultado el 18 de septiembre de 2020. 
  31. stackoverflow Team (2016). «Most Loved, Dreaded, and Wanted». stackoverflow (en inglés). Consultado el 18 de septiembre de 2020. 
  32. stackoverflow Team (2017). «Most Loved, Dreaded, and Wanted». stackoverflow (en inglés). Consultado el 18 de septiembre de 2020. 
  33. stackoverflow Team (2018). «Developer Survey Results 2018». stackoverflow (en inglés). Consultado el 18 de septiembre de 2020. 
  34. stackoverflow Team (2019). «Most Loved, Dreaded, and Wanted». stackoverflow (en inglés). Consultado el 18 de septiembre de 2020. 
  35. stackoverflow Team (27 de mayo de 2020). «The 2020 Developer Survey results are here!». stackoverflow (en inglés). Consultado el 18 de septiembre de 2020. 
  36. Mozilla Team (2020). «The Book of Mozilla». mozilla (en inglés). Consultado el 18 de septiembre de 2020. «The Beast adopted new raiment and studied the ways of Time and Space and Light and the Flow of energy through the Universe. From its studies, the Beast fashioned new structures from oxidised metal and proclaimed their glories. And the Beast’s followers rejoiced, finding renewed purpose in these teachings.» 
  37. «Typestate Is Dead, Long Live Typestate!». 26 de diciembre de 2012. Archivado desde el original el 31 de diciembre de 2012. Consultado el 28 de diciembre de 2012. 
  38. areweguiyet (2020). «Are we GUI Yet?». areweguiyet (en inglés). Consultado el 19 de septiembre de 2020. 
  39. Amann, Marco (7 de febrero de 2020). «GUI programming with Rust». medium (en inglés). Consultado el 19 de septiembre de 2020. 

Enlaces externos[editar]