Se presenta cargo como herramienta para la gestión de proyectos y se realiza un primer ejercicio siguiendo ‘Rust Book’.
Conceptos básicos como diferenciar String de str, entre otros. Alocación en memoria.
Se estudian funciones, uso de tipos de biblioteca estándar, estructuras de control y test básico.
Esta sesión presenta el uso de los tipos básicos, composión de datos con diferentes tipos, iteradores, algunas estructuras de control, introduce conceptos naturales de Rust como ownership y borrowing, resuelve un problema de ejemplo usando estos elementos.
Ejemplo 1d: piratas.
Esta sesión consiste en una revisión de uno de los elementos más comunes en funciones (enum Result), sus usos recomendados. Además, se estudia el objeto Path para la administración de directorios y archivos, se estudia la creación de argumentos para comendos con ‘env’, y se termina la sesión con la lectura de archivos usando ‘fs’, acceso I/O archivos
En esta sesión hacemos una revisión de un ejercicio propuesto de implementar ‘ls’ (listar archivos y directorios). También se refuerza el modulo io, para lectura y escritura de archivosy y finalmente se estudia el crate ‘csv’.
Lectura y escritura de archivos CSV Serialización y deserialización Ejercicio de uso de Path y PathBuf Paralelo String/PathBuf Presentación del concepto ‘trait’
Consiste en una introducción al enum Option, el uso de match con enums. La declaración de structs, una introducción a traits de la biblioteca estándar y el uso de derive y el crate derivation.
Se estudia además std::collections HashMap, los diccionarios de Rust. Finalmente con esta introducción se muestra la implementación del ejercicio propuesto de hacer una versión reducida de AWK.
Expresiones regulares en Rust, ejercicio para encontrar de manera libre y estricta cadenas de números enteros.
Generics: forma de escribir código de manera general que afecte a diferentes tipos que implementan traits en común
Ejemplo Generics y traits, parte I: competencia de seres vivos. Ejemplo de biomas
Solución del ejemplo 6 Estructuración de un proyectos Uso de generics y traits Presentación de ‘Smart Pointers’ ->
- Box
- Rc
- Weak
Caĺculos de tiempo, ¿Cuánto tiempo hemos vivido? Uso de timezone. Introducción a threading
Creación de funciones anónimas o closures Traits que implementan FnOnce, Fn, FnMut Multithreading y uso de Mutex para uso compartido Canales para mensajear objetos
Introducción a asincronimo/concurrencia Uso de bib estandar async/await -> trait Future Presentación de crate “async_std” y “futures” Conceptos como ‘event loop’
Conceptos para comunicación interprocesos Creación de ‘socket-unix’ y “socket-tcp” Comunicación de datos a través de socket Serialización y binarización de estructuras
Conversión de datos tipos básicos a bytes y viceversa. Transmisión de mensajes más complejos que un string Reestructuración de un proyecto.
Operadores ‘bitwise’ Conversión de tipos int y float Uso de socket para comunicar bytes. Socket con async
Ejercicios de programación funcional Programación con dos lenguajes:
- Haskell
- Rust
Solución de las primeras páginas del libro de ejercicios ‘Piensa en Haskell’ Problemas matemáticos y geométricos
Ejercicios de programación funcional Programación con dos lenguajes:
- Haskell
- Rust
Solución de las siguientespáginas del libro de ejercicios ‘Piensa en Haskell’ Problemas matemáticos y geométricos
Introducción a bases de datos con Rust Principios de SQL Comparativa de bases de datos Selección de base de datos Esquema general de una db, diferencia motor de datos Introducción de crate tokio seguimiento de tutorial
Taller de Óxido, en castellano mencionando la polémica de la ‘fundación’ para limitar el uso del nombre de rust.
- Continuación del tutorial de Tokio
- Uso y definición de variables de ambiente
- Inicialización de uso de SQL con Rust: crate SQLx
Presentación de ejemplo: Temperatura-Ciudad
Se crean tablas con SQL Se crea esquema
println!("Hola mundo")Se implementa la creación de tablas con restricciones Se agregan datos a las tablas Se crean funciones para consultar tablas usando Rust +SQLx
Se modifica la estructura de la db con SQl Se implementan funciones para crear tablas, modificarlas. Se implementan funciones para agregar datos en tablas
Se enseña el concepto de ‘migración’ Se implementa migración que construye la db y las tablas en el ejercicio.
Se crean inserts como funciones en Rust Se leen csv y cargan datos a la base de datos creando comandos en Rust Se crean test básicos
Se modifica el nombre del proyecto de ‘test-db’ a ‘ejemplo-db’ Se implementa logging con tracing del ecosistema tokio Se implemetnacion funciones de ‘delete’ (update propuesto) Se crean test adicionales
Se presenta el concepto de ‘macros’, cómo es el procedimiento que integra una macro al compilar y como se crean. Se caracterizan los tipos de macros Se implementa ‘macro-derive’
Se continua con el aprendizaje de macros. En esta sesión se profundiza en el uso de macro_rules para crear diferentes implementaciones de código dependiendo de los argumentos posibles que permite este tipo de macros.
Ejemplos revisados:
- macro void
- macro que crea funciones en base a templates
- macro que usa estructuras
- macro que imprime en colores
Continuamos el aprendizaje de macros. Vemos como usar una macro a través de diferentes crates aplicando ‘macro_export’, además revisamos en un ejemplo la lectura de csv transformado a diferentes estructura que tengan aplicado trait serde::Deserialization. Con esto medimos las diferencias de tiempo en realizar la operación y creamos macro que se pueda aplicar para medir este tiempo. Además se implementa macro que transforma dos secuencias o series de valores en un hashmap.
Esta sesión 25, consiste en aprender a implementar un protocolo de comunicación TCP/IP utilizando el estándar gRPC en que se declaran los elementos principales que lo componen, facilitando la creación de sistema de comunicación altamente optimizados. Se revisan conceptos, ejemplos y comparativas con otras técnicas de comunicación de mensajes. Con rust se usa el ecosistema tokio y el crate tonic, además de otros que facilitan la conversión protobuffer a rust.
En esta sesión (26) continuamos el estudio de la implementación de un protocolo de comunicación mediante el sistema de protobuffers por gRPC. Esta sesión consiste en trabajar con la definición de funciones que permitan enviar/recibir streams, es decir trozos de datos en un flujo continuo, de manera tal que la comunicación de dataset o información que en su tamaño total sea grande, sea eficiente en todo su proceso. Realizamos un ejemplo de generar números primos y enviarlos desde el servidor al cliente en un stream.
En esta sesión se continúa trabajando con el ejercicio de la sesión 26. Se observa que es posible mejorar el rendimiento de la operación que genera números primos. Por lo que se crea una función asíncrona que entregue los valores en un canal de transmisión que provee tokio. Luego se implementa en el protobuffer y en el crate del servicio rust la API para habilitar la llamada asíncrona de números primos. Por último se evalúa el tiempo de operación de cada acción y se compara. Se finaliza con una revisión del próximo ejercicio que consiste en revisar el estatus de memoria de un dispositivo.
Esta sesión consiste en habilitar un servicio gRPC que permita obtener información de sistema desde un servicio y activar determinadas acciones desde el cliente.
En primer lugar se define el concepto de que nuestro servicio está conectado a otro software que genera o contiene información, desacoplando modularmente respecto al ejemplo de números primos.
También considera la composición de mensajes de distintos tipos, así como su análogo con estructuras y algunas técnicas para transformación de tipos de manera directa usando el trait ‘From’.
Se comienza a crear el servicio que dispone de acciones CRUD (create, read, update, delete) y se pone a prueba el concepto exitosamente, distinguiendo aquel software que es parte de ‘lib’ y quel software que es parte de ‘bin’, en que la forma de hacer importaciones cambia de manera distintiva.
#emacs #rust #grpc #crud #status #device
Esta sesión se continua la implementación un CRUD en gRPC. Se arregla la transformación DateTime a Timestamp. Se crea una interfaz interactiva en la terminal en lado cliente con el crate “inquire”. Se crean las acciones UPDATE, CREATE, DELETE y se corrigen o mejoran algunas implementaciones. Quedan como ejercicios propuestos: UPDATE, DELETE y LIST.
#rust #grpc #client #server #inquire #ui #tui
En esta sesión se activa la configuración del servicio gRPC en un host público (vps #digitalocean) debian. Se evalua su operación y se reescribe parte del código de los binarios para hacer más flexible sus parámetros de configuración. Además se realiza la configuración para operar con SSL, creando las llaves y agregando la capa de encriptación.
En esta sesión 31 del taller de Rust comenzamos a estudiar el framework para hacer interfaces gráficas (apps de escritorio y web) Iced, basado en la arquitectura de Elm. Revisamos conceptos generales de interfaces gráficas y estudiamos la filosofía de la arquitectura State,Messages,View,Update para pasar a estudiar algunos ejemplos prácticos existentes.
En esta sesión se continúa el estudio de creación de interfaces gráficas con Iced, se hace una revisión conceptual del diseño del ejemplo tour y se estudia la creación de widgets y overlays. Además de estudiar la modularización entre frontend y backend de una app GUI en download_progress.
Esta sesión trata de estudiar el ejemplo base de juego de la vida de Conway, en una implementación especial para visualizar en iced.
John Conway definió una serie de reglas en un plano discretizado en una malla, en que cada celda puede estar viva o muerta según el estado de sus vecinos. Es la base fundamental para una importante área de la computación y a partir de esta se han desarrollado interesantes proyectos para simulación de vida, tanto de manera simple como con añadidos de características genéticas e inteligencia artifical.
-[X] Herramientas de desarrollo en Rust
-[X] Estructuras, enums, flujos de control
-[X] Vectores, parseo, traits
-[X] matching
-[X] Logging y tracing
-[X] Creación de comandos
-[X] Creación de módulos y testing
-[X] Async I/O, tokio
-[X] Serializacion/Derserializacion
-[X] Threading, futures, paralelización
-[X] macros
-[X] gRPC, protobuffers -> API Rest // multilenguaje
-[P] Interfaces gráficas -> recomienden!!
-[P] Borrow, lifetimes, derives
-[P] Algoritmos interesantes
-[O] errores
-[O] Web assembly -> INTERFACES GRAFICAS
-[O] Conector a Python
-[O] Bots
- zero 2 production
- refactoring to rust
Entre otros
Los siguientes software se han utilizado para el desarrollo del taller.
Stack de trabajo:
- Linux mint debbie
- Emacs / OrgMode -> Loica
- OpenBoard
- Terminal
- Rust analizer
- Jitsi
- OBS Studio
- Grupo Telegram ‘Aprender Rust’ ::https://t.me/aprenderrust
- Repositorio de sesiones
- https://gitlab.com/rust-espanol/aprender-rust-en-espanol.git
- Playlist Youtube
- https://www.youtube.com/watch?v=dDX-MMFD8YI&list=PLP3JrIiWQArVUYA2Mt8S_jVvRq_SElVWB
- Página Linkedin
- https://www.linkedin.com/company/93656122/admin/