Lenguajes y Fundamentos de Programación · LNG-181

Rust avanzado: traits, concurrencia y sistemas

Traits genéricos, macros, unsafe controlado y concurrencia sin condiciones de carrera comprobada en compilación.

Bajo demanda Especialización 8 módulos · 40 clases

Formato asíncrono Desarrollo, Ingeniería / Industria Rust

DESARROLLO CIBERSEGURIDAD

Lo que aprenderás

Diseñar traits con tipos asociados y genéricos, y elegir entre despacho estático y dinámico.
Escribir macros declarativas con macro_rules y comprender qué resuelven las macros de procedimiento.
Compartir estado entre hilos con Arc, Mutex y canales respetando los rasgos Send y Sync.
Escribir código asíncrono con async/await sobre un runtime como Tokio y sus tareas.
Delimitar bloques unsafe justificando cada invariante que el compilador ya no comprueba.
Publicar un crate con documentación, pruebas de ejemplo y perfilado de su ruta crítica.

Contenido del curso

8 módulos · 40 clases en vídeo · práctica guiada en cada módulo

Módulo 1 · Presentación y método 4 clases

Qué se da por sabido en este curso
Proyecto base, clippy y formato
Cómo se mide el coste de una abstracción
Documentación y pruebas dentro del código

Módulo 2 · Traits y genéricos 6 clases

Traits con métodos por defecto
Tipos asociados frente a parámetros genéricos
Límites de trait y cláusulas where
Objetos de rasgo y despacho dinámico
Coherencia y la regla del huérfano
Implementaciones genéricas condicionales

Módulo 3 · Tipos avanzados y punteros inteligentes 5 clases

Box, Rc y RefCell
Mutabilidad interior y su coste
Deref y Drop en tipos propios
Patrón de tipo nuevo para reforzar invariantes
Estructuras autorreferenciales y Pin

Módulo 4 · Macros 5 clases

macro_rules y coincidencia de patrones sintácticos
Higiene de macros
Cuándo una macro sobra
Macros de procedimiento: panorama y casos de uso
Derivar rasgos propios

Módulo 5 · Concurrencia 5 clases

Send y Sync: qué garantizan
Hilos, Arc y Mutex
Canales del estándar y de crossbeam
Ausencia de carreras comprobada en compilación
Interbloqueos: lo que Rust no evita

Módulo 6 · Asincronía 5 clases

Futures y el modelo de sondeo
async/await sobre Tokio
Tareas, join y select
Cancelación y tiempos de espera
Compartir estado en código asíncrono

Módulo 7 · unsafe y FFI 5 clases

Qué permite exactamente un bloque unsafe
Invariantes que hay que documentar
Punteros crudos y uniones
Interfaz con bibliotecas de C
Comprobación con Miri y sanitizers

Módulo 8 · Caso práctico: crate concurrente publicable 5 clases

Diseño de la API pública y de sus traits
Implementación concurrente con estado compartido
Pruebas, ejemplos y documentación
Perfilado y ajuste de la ruta crítica
Entrega: crate versionado y documentado

Requisitos

Rust a nivel sólido: propiedad, préstamos, tiempos de vida, enums, traits básicos y Cargo.
Cadena de herramientas de Rust instalada con rustup, incluido clippy.
Experiencia previa con programación concurrente en cualquier lenguaje.

Descripción

Una vez superado el comprobador de préstamos, el siguiente escalón de Rust es distinto: se trata de diseñar abstracciones que otros usen, de compartir estado entre hilos sin renunciar a las garantías del lenguaje y de decidir cuándo hay que bajar a unsafe y cómo acotar esa decisión para que siga siendo defendible.

El curso trabaja esas tres áreas con código de tamaño realista. Se diseñan traits con tipos asociados y objetos de rasgo comparando su coste, se escriben macros que eliminan repetición, se construye un servicio concurrente con Tokio y se implementa una estructura que requiere unsafe, documentando cada invariante y comprobándola con Miri y con el detector de errores de memoria.

Al terminar se puede mantener una biblioteca Rust usada por terceros y participar en proyectos del ecosistema con criterio propio. Es el nivel que se pide en desarrollo de infraestructura, motores de datos, sistemas embebidos exigentes y cualquier proyecto donde se elija Rust precisamente por sus garantías en tiempo de compilación.

¿Para quién es este curso?

Desarrolladores Rust que mantienen bibliotecas usadas por otros equipos.
Ingeniería de sistemas que construye servicios de alto rendimiento con garantías de seguridad de memoria.
Programadores de firmware o de drivers que necesitan interoperar con código C existente.