Contenido

Introducción ........................................................................................................................... 3
¿Qué es RUST? .......................................................................................................................... 4
Historia .................................................................................................................................... 4
Características ..................................................................................................................... 5
PROS: ....................................................................................................................................... 5
CONTRAS: ............................................................................................................................... 6
¿A qué paradigmas pertenece? ..................................................................................... 6
Tipos de escalares ............................................................................................................... 6
Compilación/interpretación/Máquina Virtual ......................................................... 8
Frameworks .......................................................................................................................... 8
¿Qué es python? ...................................................................................................................... 9
Historia ................................................................................................................................... 9
Características ................................................................................................................... 10
• Un lenguaje interpretado .................................................................................. 10
• Un lenguaje fácil de utilizar .............................................................................. 10
• Un lenguaje tipeado dinámicamente ............................................................ 11
• Un lenguaje de alto nivel ................................................................................... 11
• Un lenguaje orientado a los objetos .............................................................. 11
Framework ...................................................................................................................... 11
Beneficios de python ....................................................................................................... 11
Contras: ................................................................................................................................ 12
Tipos de datos .................................................................................................................... 13
RANKING STACKOVERFLOW 2022 .......................................................................................... 15
Bibliografia ............................................................................................................................... 16
Introducción

El presente trabajo comprende la historia, características y

distintos aspectos importantes a tener en cuenta para realizar
una comparación entre Rust y Python, dos lenguajes de
programación destacados para los desarrolladores.

Estos dos lenguajes de programación tienen un nivel de

popularidad muy diferente, pero, el tema a tratar es el ¿Por qué
RUST podría ser considerado mejor que PYTHON?

La presentación del contenido de esta monografía será en

clase a través de un video realizado por el grupo “Ryzen” con el
objetivo de lograr compartir la información obtenida.
 ¿Qué es RUST?

Rust es un lenguaje multipropósito, lo que

quiere decir que además del desarrollo interno
de un navegador puede usarse como una
herramienta para crear APIś, clientes HTTP o
conexión de base de datos, diseñado para ayudar
a los desarrolladores a crear aplicaciones rápidas y seguras que
aprovechen al máximo las potentes funciones de los modernos
procesadores multi-core.

Historia
RUST surgió en 2010 en Mozilla como un proyecto personal
de Graydon Hoare en busca de un lenguaje que permitiera
escribir un código extremadamente rápido al mismo nivel que C
o C++, pero sin los problemas de gestión de memoria que había
llevado históricamente a ser extremadamente meticuloso para
no cometer graves bugs en el acceso de memoria y condiciones
de carrera en tiempo de ejecución.

Rust 1.0 se lanzó en mayo de 2015. El mismo año, el idioma

quedó en tercer lugar en la encuesta de Stack Overflow sobre
las herramientas de desarrollador favoritas. A partir de 2016 y
hasta el 2020, Rust encabezó estas clasificaciones. En la
actualidad Rust se encuentra en su versión 1.32.

El 8 de febrero en 2021, sus cinco empresas fundadoras (AWS,

Huawei, Google, Microsoft y Mozilla) anunciaron la formación de
la fundación Rust y el 6 de abril de 2021, Google anuncio la
compatibilidad con Rust dentro del proyecto de código abierto
de Android como alternativa a C/C++.
Características
• 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"
• 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.
• Rust tiene cuatro tipos escalares principales: enteros,
números de punto flotante, booleanos y caracteres.
• Es un lenguaje de tipado estático y el compilador puede
inferir el tipo de la variable en tiempo de compilación.
• Usa la máquina virtual de bajo nivel (LLVM) para generar
código.
• Posee sus propios frameworks para el desarrollo web.

PROS:
• Rust es ideal para aplicaciones de rendimiento crítico
porque Rust es eficiente en memoria sin recolección de
basura ni tiempo de ejecución.
• Rust es seguro para la memoria y los hilos gracias a su
modelo de propiedad y a su sistema de tipos.
• Rust es un lenguaje estático y fuertemente tipado, lo que
garantiza que no se produzcan errores de código
relacionados con variables declaradas incorrectamente.
• La baja sobrecarga de Rust lo hace ideal para desarrollar
programas embebidos
• Rust tiene una amplia documentación.
• Proporciona varias herramientas para mejorar tu
productividad. Por ejemplo, incluye un gestor de paquetes
integrado y una herramienta de compilación, un editor con
funciones útiles y un compilador con mensajes de error
útiles.
 • Puedes encontrar herramientas de línea de comandos que
simplifican tu trabajo con el ecosistema crates.io.
• Rust permite el desarrollo de software con soporte
multiplataforma.

CONTRAS:
• El tiempo de compilación de Rust es más lento que el de
otros lenguajes. Se compila todo el paquete o crate en
tiempo de compilación. Por tanto, el tiempo de
compilación puede ser mayor.
• Lleva más tiempo aprenderlo en comparación con otros
lenguajes como Python. Debes conocer al menos un
lenguaje para utilizarlo eficazmente. Esto hace que Rust no
sea adecuado para las personas que aprenden a codificar
por primera vez.
• Puede crear archivos binarios más grandes.

¿A qué paradigmas pertenece?

• El lenguaje de programación Rust es multiparadigma,
imperativo, orientado a objetos, procedural, concurrente,
funcional, compilado y de propósito general.

Tipos de escalares
Un tipo escalar representa un valor único. Rust tiene
cuatro tipos escalares principales: enteros, números de punto
flotante, booleanos y caracteres.

Tipos enteros: Un número entero es un número sin un

componente fraccionario. En Rust es importante indicar el
tamaño que este entero ocupará y si lleva signo o no.

Tipos de puntos flotantes: Rust también tiene dos tipos

primitivos para números de coma flotante. Los tipos de coma
flotante de Rust son f32 y f64, que tienen un tamaño de 32 bits y
64 bits, respectivamente. Todos los números de tipo punto
flotante tienen signo.

Recordar Rust permite realizar operaciones matemáticas básicas

tales como Suma +, Resta -, Multiplicación *, División /, Módulo
%

El tipo booleano: Los booleanos tienen un tamaño de un byte.

El tipo booleano en Rust se especifica mediante bool

Tipos Compuestos

Los tipos compuestos pueden agrupar varios valores en un solo

tipo. Rust tiene dos tipos de compuestos primitivos: tuplas y
matrices.

El tipo de tupla: una tupla es una forma general de agrupar

una cantidad de valores con una variedad de tipos en un tipo
compuesto. Las tuplas tienen una longitud fija: una vez
declaradas, no pueden crecer ni reducir su tamaño.
El tipo arreglo: otra forma de tener una colección de valores
múltiples es con una matriz. A diferencia de una tupla, todos los
elementos de una matriz deben tener el mismo tipo. A
diferencia de los arreglos en otros lenguajes, los arreglos en
Rust tienen una longitud fija.

Compilación/interpretación/Máquina Virtual
• Rust es un lenguaje de tipado estático y el compilador
puede inferir el tipo de la variable en tiempo de
compilación.
• Rust usa la máquina virtual de bajo nivel (LLVM) para
generar código

Frameworks
Rust posee sus propios frameworks para el desarrollo web.
Estos son: Actix y Rocket.

Actix Rocket
¿Qué es python?
Python es un lenguaje de programación
ampliamente utilizado en las aplicaciones
web, el desarrollo de software, la ciencia
de datos y el machine learning (ML). Los
desarrolladores utilizan Python porque
es eficiente y fácil de aprender, además
de que se puede ejecutar en muchas
plataformas diferentes. El software Python se
puede descargar gratis, se integra bien a
todos los tipos de sistemas y aumenta la velocidad del
desarrollo.

Historia
Cuando: Python comenzó su creación en el año 1989, en el
Centrum Wiskunde & Informatica, fue concebido en un principio
como un proyecto para mantenerse ocupado durante las
vacaciones de navidad. En febrero del año 1991 se lanza
públicamente la primera versión de python dicha versión fue la
0.9.0 Esta primera versión ya incluía clases con herencias,
manejo de excepciones, funciones y una de
las características principales de Python: funcionamiento
modular. Esto permitía que fuese un lenguaje mucho más
limpio y accesible para la gente con pocos conocimientos de
programación. Una característica que se mantiene hasta el
día de hoy.

Versiones:

• Guido Van Rossum publicó la primera versión del código

Python (versión 0.9.0) en 1991. Dicha versión ya incluía
 buenas características, como algunos tipos de datos y
funciones para la gestión de errores.
• Python 1.0 se lanzó en 1994 con nuevas funciones para
procesar fácilmente una lista de datos, como la asignación,
el filtrado y la reducción.
• Python 2.0 se lanzó el 16 de octubre de 2000, con nuevas
características útiles para los programadores, como la
compatibilidad con los caracteres Unicode y una forma
más corta de recorrer una lista.
• El 3 de diciembre de 2008, se lanzó Python 3.0. Incluía
características como la función de impresión y más
soporte para la división de números y la gestión de
errores.
• Versión actual 3.11.2

Características

Las características siguientes del lenguaje de programación

Python lo hacen único:

• Un lenguaje interpretado

Python es un lenguaje interpretado, lo que significa que ejecuta

directamente el código línea por línea. Si existen errores en el
código del programa, su ejecución se detiene. Así, los
programadores pueden encontrar errores en el código con
rapidez.

• Un lenguaje fácil de utilizar

Python utiliza palabras similares a las del inglés. A diferencia de

otros lenguajes de programación, Python no utiliza llaves. En su
lugar, utiliza sangría.
 • Un lenguaje tipeado dinámicamente

Los programadores no tienen que anunciar tipos de variables

cuando escriben código porque Python los determina en el
tiempo de ejecución. Debido a esto, es posible escribir
programas de Python con mayor rapidez.

• Un lenguaje de alto nivel

Python es más cercano a los idiomas humanos que otros

lenguajes de programación. Por lo tanto, los programadores no
deben preocuparse sobre sus funcionalidades subyacentes,
como la arquitectura y la administración de la memoria.

• Un lenguaje orientado a los objetos

Python considera todo como un objeto, pero también admite

otros tipos de programación, como la programación
estructurada y la funcional.

Framework
Framework Django: se lo utiliza en webs con pocos códigos y
garantiza estándares de ciberseguridad.

Framework Flask: Permite desarrollar una web dinámica en

menos pasos

Beneficios de python
• Los beneficios de Python incluyen los siguientes:
• Los desarrolladores pueden leer y comprender fácilmente
los programas de Python debido a su sintaxis básica
similar a la del inglés.
• Python permite que los desarrolladores sean más
productivos, ya que pueden escribir un programa de
Python con menos líneas de código en comparación con
muchos otros lenguajes.
• Python cuenta con una gran biblioteca estándar que
contiene códigos reutilizables para casi cualquier tarea. De
 esta manera, los desarrolladores no tienen que escribir el
código desde cero.
• Los desarrolladores pueden utilizar Python fácilmente con
otros lenguajes de programación conocidos, como Java, C
y C++.
• Python se puede trasladar a través de diferentes sistemas
operativos de computadora, como Windows, macOS, Linux
y Unix.

Contras:
• Python no es adecuado para aplicaciones que requieren
alta velocidad porque Python es un lenguaje más lento
que otros lenguajes debido a su ejecución línea a línea y a
su tipado dinámico.
• Python consume una gran cantidad de memoria debido a
sus características como los tipos de datos flexibles. Por
tanto, no es adecuado para aplicaciones que consumen
mucha memoria.
• La tipificación dinámica también puede provocar eros en
tiempo de ejecución que no se detectan en tiempo de
compilación.
• No es adecuado para aplicaciones móviles por su lentitud y
su elevado uso de memoria.
• El acceso a bases de datos utilizando Python puede
resultar difícil porque no está muy desarrollado como en
muchos otros lenguajes.
 Tipos de datos
En Python podemos encontrar distintos tipos de datos con
diferente características y clasificaciones como los: Booleanos,
los numéricos y las cadenas de caracteres.

Tipos numéricos

• Números enteros es int, comprende el conjunto de todos

los números enteros, dicho conjunto es infinito, pero
Python solo se encuentra limitado por la capacidad de
memoria disponible.

>>> a = -1 # a es de tipo int y su valor es -1

>>> b = a + 2 # b es de tipo int y su valor es 1
>>> print(b)
1

• Números de punto flotante float representan a el

conjunto de números reales

>>> real = 1.1 + 2.2 # real es un float

>>> print(real)
3.3000000000000003 # Representación aproximada de 3.3
>>> print(f'{real:.2f}')
3.30 # real mostrando únicamente 2 cifras decimales

• Números complejos: complex, los números complejos

tienen una parte real y otra imaginaria y cada una de ellas
se representa como un float.

Para crear un numero complejo se sigue la siguiente

estructura <parte_real>+<parte_imaginaria>j
Se puede acceder a la parte real e imaginaria a través de
los atributos real o img.
>>> complejo = 1+2j
>>> complejo.real
1.0
>>> complejo.imag
2.0

• Tipo booleano
Esta clase que representa los valores booleanos es bool.
Solo puede validar con 2 valores u objetos: true para
representar verdadero y false para representar falso.

Otro tipo de dato básico de Python son las secuencias o

cadenas de caracteres. Conocido como string (str).

Para crear un string, simplemente tienes que encerrar entre

comillas simples '' o dobles "" una secuencia de caracteres.
>>> hola = 'Hola "programador"'
>>> hola_2 = 'Hola \'programador\''
>>> hola_3 = "Hola 'programador'"
>>> print(hola)
Hola "programador"
>>> print(hola_2)
Hola 'programador'
>>> print(hola_3)
Hola 'programador'
RANKING STACKOVERFLOW 2022
Bibliografia
https://recluit.com/descubre-la-historia-de-rust/

https://openexpoeurope.com/es/session/rust-es-un-moderno-
lenguaje-de-programacion-con-una-nueva-perspectiva/

https://goyox86.gitbooks.io/el-libro-de-rust/content/syntax-
and-semantics.html

https://ferestrepoca.github.io/paradigmas-de-
programacion/progconcurrente/tutoriales/Libro_Rust_2022_1/tu
torial/generalidades/tipos_datos.html#:~:text=Rust%20tiene%20
cuatro%20tipos%20escalares,punto%20flotante%2C%20boolean
os%20y%20caracteres

https://www.google.com/search?q=funcionalidadeas+del+rust&
oq=funcionalidadeas+del+rust&aqs=chrome.69i57.10945j0j1&so
urceid=chrome&ie=UTF-8

https://codigofacilito.com/articulos/rust

https://www.youtube.com/watch?v=wCJtFd_V7a8

https://aws.amazon.com/es/what-is/python/

https://www.tokioschool.com/noticias/historia-python/

https://survey.stackoverflow.co/2022/

https://j2logo.com/python/tutorial/tipos-de-datos-basicos-de-
python/