Rust (Programación)

Rust (programación) Parte de la familia Lenguaje de Programación. Desarrollador Graydon Hoare Fecha de Creación 2010 Última versión estable 1.76.0 (8 de febrero de 2024 (10 días)) Sistemas Operativos compatibles Linux, macOS, Windows, FreeBSD, OpenBSD, Redox, Android, iOS Licencia Apache 2.0, Licencia MIT Sitio web https://www.rust-lang.org/

Rust es un lenguaje de programación compilado, de propósito general y multiparadigma (aunque no soporta las características de los mismos en su totalidad) que está siendo desarrollado por Fundación Rust. Es un lenguaje de programación multiparadigmático que soporta programación funcional pura, por procedimientos, imperativa y orientada a objetos.

Según la política de Mozilla, 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, 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.

Historia

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, quien afirmó que el proyecto posiblemente recibió su nombre de la familia de hongos de la roya. Mozilla comenzó a patrocinar el proyecto en 2009 y lo anunció en 2010. El mismo año, el trabajo pasó del compilador inicial (escrito en OCaml) al compilador autohospedado escrito en Rust. Denominado rustc, se compiló con éxito en 2011. rustc usa LLVM como su back end. La primera versión pre-alfa numerada del compilador de Rust se produjo en enero de 2012. Rust 1.0, la primera versión estable, se publicó el 15 de mayo de 2015. 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. 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. 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. 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. Rust fue el tercer lenguaje de programación más querido en la encuesta anual de Stack Overflow de 2015 y ocupó el primer lugar en 2016-2020. El lenguaje se menciona en El libro de Mozilla como "metal oxidado". Creación de Fundación Rust En agosto de 2020, Mozilla despidió a 250 de sus 1000 empleados en todo el mundo como parte de una reestructuración corporativa provocada por el impacto a largo plazo de la pandemia de COVID-19. El equipo detrás de Servo, un motor de navegador escrito en Rust, se disolvió por completo. El evento generó preocupaciones sobre el futuro de Rust, ya que algunos miembros del equipo eran colaboradores activos de Rust. A la semana siguiente, el equipo central de Rust reconoció el grave impacto de los despidos y anunció que los planes para una fundación de Rust estaban en marcha. El primer objetivo de la fundación sería tomar posesión de todas las marcas comerciales y nombres de dominio, y asumir la responsabilidad financiera por sus costos. El 8 de febrero de 2021, sus cinco empresas fundadoras (AWS, Huawei, Google, Microsoft y Mozilla) anunciaron la formación de la Fundación Rust. El 6 de abril de 2021, Google anunció la compatibilidad con Rust dentro del Proyecto de código abierto de Android como alternativa a C/C++.

Descripción

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.

Acerca de

Rust es un lenguaje de programación desarrollado por los ingenieros de mozila. Podríamos catalogarlo como un lenguaje muy nuevo; Estamos hablando que la versión 1.0 estuvo disponible a principios del 2015; Actualmente estamos en la versión 1.32. Al igual que C , Java o C++, Rust es un lenguaje compilado. Rust está diseñado para desarrollar software de sistemas, donde la interacción con el usuario es practicamente nula; Excelente para aplicaciones con el modelo cliente-servidor o para cosas más internas en nuestra empresa. Uno que otro demonio por allí. Algo interesante de Rust es que actualmente se están desarrollando dos sistemas operativos con dicho lenguaje.

¿Qué lenguaje de programación usa Rust?

Rust es un lenguaje de programación desarrollado por los ingenieros de mozila. Podríamos catalogarlo como un lenguaje muy nuevo; Estamos hablando que la versión 1.0 estuvo disponible a principios del 2015; Actualmente estamos en la versión 1.32. Al igual que C, Java o C++, Rust es un lenguaje compilado.

¿Quién usa Rust?

Dentro de las empresas más reconocidas que usan Rust en sus desarrollos se cuentan Amazon Web Services, Microsoft, Meta, y Google (puntualmente en Android y en Google Cloud).

¿Para qué sirve exactamente este lenguaje?

Rust se creó para poder alcanzar la velocidad de C++]], pero dejando al lado los problemas de memoria y reduciendo los errores o «bugs» en el código, convirtiéndolo, para muchos en su sucesor. Construido de forma colectiva y financiado gracias a donaciones de distintas empresas, hoy en día Rust es el lenguaje sobre el que se soporta gran parte de Servo, el navegador de Firefox. Maneja una sintaxis moderna, lo que a su vez lo hace ideal para la ejecución de aplicaciones web a una velocidad muy cercana a las apps nativas.

Características

El lenguaje que empodera a todos para construir software fiable y eficiente. Tiene características muy importantes, a continuación, te mencionamos algunas de ellas, de este novedoso lenguaje de programación:

• Ejecución dinámica de seguridad (errores y registros).
• Orientado a Objetos.
• Interfaz simple.
• Gestión automática de guardado.
• Inmutable.
• Compilación nativa y estática.
• Multiplataforma.
• Control de la memoria explícita.
• Permite cadenas UTF8.
• Multiparadigmático.
• Concurrente.

Más características

• Rendimiento: Rust es increíblemente rápido y eficiente con la memoria: sin runtime ni recolector de basura, puede sustentar servicios de rendimiento crítico, ejecutarse en dispositivos integrados, y colaborar con otros lenguajes fácilmente.
• Fiabilidad: El rico sistema de tipos de Rust y su modelo de propiedad (ownership) garantizan seguridad de memoria y seguridad en hilos, y te permiten eliminar muchas clases de bugs, reportándose a la hora de compilar.
• Productividad: Rust tiene una documentación muy completa, un compilador accesible con mensajes de error útiles, y herramientas de primera: gestor de paquetes y de proyecto integrados, soporte avanzado multi-editor con autocompletado e inspecciones de tipos, auto-formateador, etc.
• Redes: Rendimiento predecible, bajo consumo de recursos y fiabilidad sólida. Rust es perfecto para servicios de red.
• WebAssembly: Usa Rust para potenciar tu JavaScript, módulo a módulo. Publica en npm, compacta con webpack y listo.
• Línea de comandos: Crea una herramienta de CLI rápidamente con el robusto ecosistema de Rust. Rust te ayuda a mantener y desarrollar tu aplicación con confianza y a distribuirla fácilmente.

Ventajas de RUST

A nivel global, Rust permite desarrollar grandes programas del lado del cliente y del servidor mejorando la calidad del software, sin necesidad de requerir más poder del hardware que lo ejecuta considerando esta como una de las principales ventajas que ofrece. Adicionalmente, gracias al compilador de este, se cumplen convenientemente las garantías de seguridad del resto de las validaciones que conllevan que este lenguaje sea eficiente y seguro.

Sintaxis de Rust

La sintaxis de Rust es muy parecida a la del lenguaje C++, esta cuenta con bloques de código que se encuentran delimitados por llaves, finalizadas las líneas de código por punto y coma (;) y las estructuras de control de flujo cotidianas como lo son: for, if, else, while, do, elseif. A continuación te listamos algunos puntos de interés en cuanto a la sintaxis de RUST:

• El código fuente siempre deberá ir dentro del main (función principal) con la variante de que esta función se define con la palabra reservada “fn”.
• Para imprimir se mantiene el “println”, es importante mencionar que en Rust las funciones consideradas parte del lenguaje denominan macros y van acompañadas del signo de admiración (!) luego del nombre de dicha función. Como se muestra a continuación: println!(“Bienvenidos a OpenWebinars”);
• Las variables se encuentran antecedidas por la palabra reservada “let” (let + nombre variable + valor asignado), de la siguiente manera: let mivariable = valordemivariable;
• Por su parte las constantes las antecede la palabra “const”.

Evolución del lenguaje

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. 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. 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)

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 admisión de múltiples plataformas. 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. Algunos proyectos populares son los siguientes:

= Componentes del ecosistema

Componentes del ecosistema o el conjunto de herramientas de desarrollo de Rust. Se presentan algunas herramientas y términos de Rust. Aquí se plasman las descripciones.

• Un crate es una unidad de compilación y vinculación de Rust. Un crate puede existir en forma de código fuente y, desde allí, se puede procesar en un crate en forma de ejecutable binario (binario, para abreviar) o de biblioteca binaria (biblioteca, para abreviar).
• Un proyecto de Rust se conoce como package. Un package contiene uno o más crates, junto con un archivo Cargo.toml que describe cómo compilar esos crates.
• rustup es el instalador y el actualizador de la cadena de herramientas de Rust.
• Cargo es el nombre de la herramienta de administración de paquetes de Rust.
• rustc es el compilador de Rust. La mayoría de las veces, no se invocará a rustc directamente; lo invocará indirectamente a través de cargo.
• crates.io (https://crates.io/) es el registro de crates de la comunidad de Rust.

Versiones publicadas

•0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 0.10, 0.11.0, 0.12.0, 1.0.0, 1.1.0, 1.2.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.0, 1.22.1, 1.23.0, 1.24.0, 1.24.1, 1.25.0, 1.26.0, 1.26.1, 1.26.2, 1.27.0, 1.27.1, 1.27.2, 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, 1.47.0, 1.48.0, 1.49.0, 1.50.0, 1.51.0, 1.52.0, 1.52.1, 1.53.0, 1.54.0, 1.55.0, 1.56.0, 1.56.1, 1.57.0, 1.58.0, 1.58.1, 1.59.0, 1.60.0, 1.61.0, 1.62.0, 1.62.1, 1.63.0, 1.64.0, 1.65.0, 1.66.0, 1.66.1, 1.67.0, 1.67.1, 1.68.0, 1.68.1, 1.68.2, 1.69.0, 1.70.0, 1.71.0, 1.71.1, 1.72.0, 1.72.1, 1.73.0, 1.74.0, 1.74.1, 1.75.0 y 1.76.0

Véase también

• Servo
• Clojure
• Erlang

Fuente

• https://learn.microsoft.com/es-es/windows/dev-environment/rust/overview
• https://www.rust-lang.org/es
• https://codigofacilito.com/articulos/rust
• https://www.rust-lang.org/tools/install
• https://www.enter.co/especiales/dev/para-que-sirve-rust-el-lenguaje-de-programacion-que-no-deja-de-sumar-adeptos/
• https://www.rust-lang.org/es