Comenzando con Rust (II)

Etiquetas

Entrada Anterior Comenzando con Rust(I)

En esta entrada vamos a comenzar con Rust para darnos de bruces con algunas de las cosas que más curiosas me parecieron a mí, programador que llevaba tiempo con Python, al comenzar.

Accede a este enlace de Playground de Rust. Puedes ejecutar el programa pulsando en RUN. Siéntete libre de modificar lo que quieras, es tu código.

Si vienes de programar en Python ves las cosas algo raras pero no demasiado raras. No creo que tengas problema si te digo que modifiques el programa para que muestre «Estoy empezando con Rust».

Sencillo, cambio «Hola Mundo» por «Estoy empezando con Rust». Lo ejecuto y ya.

Como, a diferencia de Python, Rust no es un lenguaje interpretado verás que en la salida que se muestra en el trozo de pantalla de salida aparece:

Compiling playground v0.0.1 (/playground)
    Finished dev [unoptimized + debuginfo] target(s) in 2.82s
     Running `target/debug/playground`

Todos los programas escritos en Rust deben pasar un paso previo antes de poder ser ejecutados: la compilación. En el caso de Rust este programa es rustc que veremos con más detalle en otra entrada. La ventaja que tiene la compilación es que, una vez generado el programa ejecutable ya no necesitarías más a Rust. Bastaría con copiar el fichero ejecutable creado, copiarlo en otra máquina (eso sí, con el mismo sistema operativo que en la que has generado el código. Para virguerías de compilaciones para otros sistemas operativos y procesadores diferentes a los de tu máquina siga, siga, siga…) y ya.

El compilador de Rust es muy tiquismiquis, pero da mucha información de por qué no deja seguir. Prueba ahora a ejecutar esto

  Compiling playground v0.0.1 (/playground)
error: expected `;`, found `println`
 --> src/main.rs:2:18
  |
2 |     let i:u32 = 7
  |                  ^ help: add `;` here
3 |     println!("Estoy empezando con Rust");
  |     ------- unexpected token

Observa como te da la ayuda: en la línea 2 añade un ;

Ha sido fácil. Pero no te lleves la impresión de que todas las líneas en un programa Rust deben terminar con ;, de hecho, las líneas más interesantes son las que no lo tienen, pero sigamos con calma que nos liamos.

En este segundo programa hemos añadido una cosa que igual te sorprende. Bueno, una no, dos. La primera es let, palabra reservada del lenguaje que indica que se va a crear una variable. Fácil.

La segunda es el :u32, ¡uf! si no has visto nada antes de tipos te vas a encontrar perdido. Te recomiendo que pares y estudies el capítulo 3, apartado 2 del libro de Rust. Ya advertí que no iba a ser sencillo.

En Python puedes hacer cosas como esta:

i = 7
i = 34
print(i)

Si intentas algo similar en Rust, algo como esto, el compilador se para y muestra un mensaje:

 |
2 |     let i = 7;
  |         -
  |         |
  |         first assignment to `i`
  |         help: consider making this binding mutable: `mut i`
3 |     i = 12;
  |     ^^^^^^ cannot assign twice to immutable variable

En la ayuda nos dice que consideremos hacer «mutable» a i. Y ¿Cómo se hace eso? el código anterior debes modificarlo para que sea igual a este

Con mut le estamos diciendo al compilador que esa variable podrá ser modificada después de ser creada. De hecho, si hacemos que una variable sea mut y no cambiamos su valor a lo largo del programa el compilador nos avisa (aviso de variable mut sin cambios) aunque ejecuta, la cosa no es tan grave. ¿ O sí?. Tú decides.

|
2 |     let mut i = 7;
  |         ----^
  |         |
  |         help: remove this `mut`
  |
  = note: `#[warn(unused_mut)]` on by default

En algunos programas de Rust puedes encontrarte cosas como las que mostramos aquí Esto nos va a permitir la variable i como i32 y, después de volverle a asignar un valor con let, como cadena de caracteres. El término utilizado para definir este fenómeno es shadowing. Vamos, lo mismo que haces en Python con:

i = 7
print(i)
i="hola"
print(i)

Pero dejas claro que sabes que eso es así, no que utilizas a lo tonto un nombre de variable que, curiosamente, ya habías utilizado antes con un tipo diferente. ¿No te ha pasado nunca?

De momento no escribo más. Te dejo algunos ejercicios para que asientes conocimientos:

Ejercicio 1: ¿Por qué este programa no compila? Ejercicio 1

Ejercicio 2: ¿Y por qué este sí? Ejercicio 2

Ejercicio 3: ¿Por qué este programa muestra en pantalla 255 en vez de 256?¿Qué ocurre si eliminas el saturating_add(1)? Busca información sobre saturating_add y similares Ejercicio 3

Un saludo

Comenzando con Rust ( I )

Etiquetas

Comienzo con este el primero de una serie, espero que larga, de artículos sobre el lenguaje de programación Rust.

No soy un experto en este lenguaje y el planteamiento de estas entradas en el blog son más bien una reflexión en voz alta que verdades absolutas y contrastadas.

Me planteo como retos los siguientes:

  • Utilizar única y exclusivamente la librería estándar de este lenguaje.
  • No utilizar Cargo hasta que queden asentados la mayor parte de los conceptos que me gustaría tratar.
  • Después de obtener un dominio medio-alto de la concurrencia con Rust, realizar un servidor de algún protocolo interesante como MQTT ( de aquí surge la idea: https://taller-1-fiuba-rust.github.io/proyecto_2C2021.html),un bot de Telegram (intentar crear la librería de conexión a la API desde cero…bufff pero un reto es un reto) o algún proyecto barebone ( sobre la raspberry Pi Zero o similar)

Temas como asincronía y webassembly me parecen interesantes pero los dejo para más adelante.

El camino va a ser largo y creo que duro. Para empezar veo muy necesario conocer los intríngulis de los sistemas informáticos y para ello nada mejor que realizar este curso de Juan Gozález sobre el ensamblador de RISC-V https://github.com/myTeachingURJC/2019-20-LAB-AO/wiki Los conceptos de Pila (stack) y montón (heap) Juan los explica que no deja dudas (excepcional también lo claro que queda recursividad. Es un grande) y son fundamentales para entender propiedad y préstamo, una de las características de Rust que más complican la vida pero que hace que el código generado no sufra de errores que son mucho más difíciles de detectar y corregir cuando el programa ya se está ejecutando.

Si es la primera vez que te enfrentas a Rust no te recomiendo que instales nada en tu máquina y sí que utilices https://play.rust-lang.org/

Si termina picándote el gusanillo obviamente tendrás que instalarlo y para eso: https://www.rust-lang.org/tools/install

Libros que recomiendo:

  • Otro libro que me ha gustado mucho es Programming Rust, Segunda Edición de Jim Blandy, Jason Orendorff, Leonora F. S. Tindall
  • Para entender los diferentes tipos de punteros (tranquilo, ya llegaremos a ellos) el libro de Tim McNamara Rust in Action

Si de concurrencia estás pez y quieres asentar o adquirir conocimientos, el libro de Ricardo Galli es excelente: https://github.com/gallir/principios_algoritmos_concurrencia/tree/master Tampoco habla de Rust pero va a dejarte bastante claros los principios en los que se basa este follón que es la concurrencia. Habla de canales en golang pero pueden servirte de mucha ayuda para comprenderlos en Rust (después de leer este libro, y estés haciendo cosicas concurrentes, pásate por el capítulo 19 de Programming Rust)

Tengo pendiente Rust For Rustaceans Idiomatic Programming for Experienced Developers by Jon Gjengset Rust For Rustaceans Idiomatic Programming for Experienced Developers by Jon Gjengse

Tanto Tim McNamara como Jon Gjengse tienen canal de youtube en el que dan masterclass sobre temas Rust.

Solo le he echado un vistazo pero parece divertido: https://sokoban.iolivia.me/ Realización de un videojuego 2D con Rust

En español he visto pocos recursos. Destacaría dos:

Como gestionar los comentarios suele ser bastante rollo, si queréis enviarme información sobre Rust, criticar de manera positiva las cosas que vaya publicando o indicarme en qué me he equivocado, podéis contactar conmigo a través de mi cuenta de twitter: @PeredaFP. Intentaré hacer una selección de las cosas más interesantes para que sean publicadas en siguientes entradas.

Un saludo

Estudiamos una hoja de cálculo

Descarga esta hoja de cálculo: CONTROLCARRERA

Y realiza la siguiente actividad:

1.- Describe brevemente para qué sirve esta hoja de cálculo

2.- ¿Cuántas hojas contiene? ¿para qué sirve cada una?

3.- En la celda Dorsales.B4 aparece una fórmula con los textos “ninguno” y “dorsales dulicados” crea una celda en la hoja de Configuración para cada uno de estos textos y modifica dicha fórmula

4.- ¿Cómo se obtiene el total de dorsales que aparece en la celda Dorsales.C4?

5.- ¿Qué ocurre si duplicas un dorsal? Describe el procedimiento realizado

6.- ¿Cómo se obtiene la edad del corredor?

7.- Observa que para obtener el sexo del corredor se muestran los valores M y F ¿Cómo podrías cambiar las letras que identifican a dicho sexo? ¿ocurre algo si las cambias? ¿por qué?

8.-Estudia cómo se obtiene la categoría del corredor.

9.- Modifica la hoja para que solo haya categoría SUB20 y SUB40 tanto para hombres como para mujeres.

10.- ¿Cómo se obtiene el puesto en la categoría?Pista: la columna A guarda algún secreto

11.- Describe cómo se obtienen el nombre, apellidos y categoría del corredor al añadir el dorsal en la hoja de Resultados

12.- En la hoja “Cuadro de Honor” aparecen, en alguna de las clasificaciones un #N/D. Soluciónalo

13.- ¿Cómo se obtiene el corredor más veterano?

14.- Estudia y modifica el cuadro de honor para que únicamente contenga las categorías que has creado en el punto 9

15.- Si se te ocurre alguna mejora…ADELANTE

Os recuerdo que la fecha de examen es el 16 de noviembre, la entrega del trabajo del control de notas es el día 15 de noviembre y debéis añadir este ejercicio a entregar en la misma fecha que el control de notas, o sea, el 15 de noviembre

Un saludo

Prácticas de Calc y texto sobre celdas, funciones, etc.

Libro de referencia: Primeros Pasos Con LibreOffice

Aquí están las prácticas de Calc.
PRACTICAS 0 Funciones sencillas
Práctica 1. Rellenar series
Práctica 2. Cuentas clientela
Práctica 3. Función SI
Práctica 4. Notas de examen-1
Práctica 5. Gestión de almacén
Práctica 6. Control de pedidos en almacén-1
Práctica 7. Pedido de vino
Práctica 8. Cálculo de la letra del DNI
DatosInmobiliaria

Texto en el que aparecen más ejercicios de referencias a celdas.
Fórmulas / Referencias.

Gracias a José Luis Ulizarna García y José Fco. Belda, autores del trabajo, por «subirlo» a la red.

Un saludo.