Apéndice D: Glosario
Los términos están listados alfabéticamente. Las referencias apuntan al capítulo donde el concepto se introduce por primera vez.
ADT (Tipo de Dato Algebraico) — Un enum cuyos variantes pueden llevar datos. enum Shape { Circle(int), Rect(int, int) } es un ADT. Cada variante es una "forma" diferente de datos. (Capítulo 14)
Array — Una colección ordenada de valores, con tamaño dinámico. Se crea con [1, 2, 3] o Array.new(). Los arrays en Nyx pueden contener valores de tipos mixtos. (Capítulo 6)
AST (Árbol de Sintaxis Abstracta) — Una representación en árbol de tu código fuente, producida por el parser. Cada nodo representa una construcción (función, variable, expresión). El compilador usa este árbol para generar código. (Capítulo 20)
Async — Un modelo de programación donde las operaciones pueden iniciarse sin esperar a que se completen. En Nyx, async/await es azúcar sintáctico — el paralelismo real viene de spawn y thread_spawn. (Capítulo 23)
ACK (Acknowledgment) — Un mensaje enviado por un consumidor para confirmar que un mensaje ha sido procesado exitosamente. En nyx-queue, ACK queue msg_id elimina el mensaje de la lista de entrega. (Capítulo 29)
Binario — El archivo ejecutable producido por el compilador. Un binario contiene código de máquina que la CPU puede ejecutar directamente, sin necesidad de intérprete. (Capítulo 1)
Boehm GC — El recolector de basura usado por Nyx. Es un recolector conservativo de tipo mark-and-sweep que libera automáticamente memoria que ya no es alcanzable. Nombrado por Hans-Juergen Boehm. (Capítulo 20)
Bootstrap — El proceso de compilar un compilador consigo mismo. El compilador de Nyx está escrito en Nyx. Los archivos semilla (compiler/.ll) se usan para construir el primer compilador, que luego se compila a sí mismo. (Capítulo 20)*
Borrow (Préstamo) — Tomar una referencia a un valor sin tomar ownership. En Nyx, &x crea una referencia. Nota: Nyx no tiene borrow checker — las referencias son alias de punteros. (Capítulo 22)
Channel — Una cola thread-safe para enviar valores entre threads o goroutines. Se crea con channel_new(capacity). La forma principal de comunicarse entre tareas concurrentes. (Capítulo 18)
Closure — Una función que captura variables de su scope envolvente. Cuando escribes fn(x: int) -> int { return x + offset } dentro de otra función, y offset viene de la función exterior, eso es un closure. (Capítulo 13)
Compilación cruzada — Compilar un programa en una arquitectura (ej: x86) para ejecutar en una arquitectura diferente (ej: ARM). make cross TARGET=aarch64-linux-gnu. (Capítulo 24)
Compilador — Un programa que traduce código fuente a otra forma. El compilador de Nyx traduce archivos .nx a LLVM IR, que LLVM luego compila a código de máquina. (Capítulo 1)
Concurrencia — Ejecutar múltiples tareas que progresan durante períodos de tiempo superpuestos. No requiere múltiples CPUs — incluso una CPU puede alternar entre tareas. (Capítulo 18)
Pub/Sub (Publish/Subscribe) — Un patrón de mensajería donde los publicadores envían mensajes a canales nombrados y todos los suscriptores los reciben. Fire-and-forget — si nadie está escuchando, el mensaje se pierde. nyx-kv implementa los comandos SUBSCRIBE, PUBLISH y UNSUBSCRIBE. (Capítulo 28)
Condición de carrera (Race condition) — Un bug donde el comportamiento del programa depende del timing de ejecución de los threads. Ocurre cuando los threads acceden a datos compartidos sin sincronización. (Capítulo 18)
Deadlock — Un estado donde dos o más threads están esperando que el otro libere un recurso, así que ninguno puede progresar. Un bug de concurrencia común. (Capítulo 18)
Derive — Una macro que genera automáticamente implementaciones de traits. #[derive(Clone, Debug, Display)] genera métodos clone(), debug(), y to_string(). (Capítulo 15)
Dispatch dinámico — Llamar a un método de trait a través de una referencia dyn Trait, donde la función real a llamar se determina en runtime via una vtable. Más lento que dispatch estático pero más flexible. (Capítulo 15)
Dispatch estático — Llamar a un método de trait donde el tipo concreto se conoce en tiempo de compilación. El compilador inline la llamada. Más rápido que dispatch dinámico. (Capítulo 15)
Enum — Un tipo que puede ser una de varias variantes. Enums simples: enum Color { Red, Green, Blue }. Enums con datos: enum Option. (Capítulo 14)
epoll — Una llamada al sistema de Linux para monitorear múltiples file descriptors. Nyx usa epoll internamente para su event loop, habilitando multiplexación eficiente de I/O. (Capítulo 23)
Event loop — Un patrón de programación que espera eventos (datos de red, timers) y los despacha a manejadores. El event loop de Nyx está basado en epoll y potencia el I/O asíncrono. (Capítulo 23)
Expresión — Código que produce un valor: 2 + 3, f(x), if a > b { a } else { b }. Contrasta con sentencia. (Capítulo 2)
FFI (Interfaz de Función Foránea) — Un mecanismo para llamar funciones escritas en otro lenguaje. extern "C" fn puts(s: String) -> int declara una función C llamable desde Nyx. (Capítulo 21)
Fixed point — Cuando compilar el compilador dos veces produce salida idéntica. Esto demuestra que el compilador es auto-consistente. (Capítulo 20)
Float — Un número de punto flotante de 64 bits (IEEE 754 doble precisión). Se escribe como 3.14, -0.5. (Capítulo 3)
Frame — La unidad básica de comunicación en HTTP/2. Cada frame tiene un header de 9 bytes (longitud, tipo, flags, stream ID) seguido de un payload. Los tipos de frame incluyen DATA, HEADERS, SETTINGS, PING y GOAWAY. (Capítulo 30)
Función — Un bloque de código nombrado y reutilizable. fn add(a: int, b: int) -> int { return a + b }. (Capítulo 5)
Función naked — Una función con atributo #[naked] que no tiene prólogo ni epílogo generado por el compilador. Se usa para manejadores de interrupción y código de bajo nivel. (Capítulo 24)
Genérico — Una función o tipo parametrizado por una o más variables de tipo. fn first funciona con cualquier tipo. Nyx implementa genéricos via monomorfización. (Capítulo 16)
Goroutine — Una tarea concurrente ligera creada con spawn { }. Muchas goroutines se mapean sobre menos threads del SO via el scheduler M:N. Inspirado en Go. (Capítulo 23)
HPACK — El algoritmo de compresión de headers usado por HTTP/2. Usa una tabla estática de 61 pares nombre-valor de headers comunes y codificación Huffman para reducir el overhead de headers. Por ejemplo, :status: 200 se codifica como un solo byte 0x88. (Capítulo 30)
Heap — Una región de memoria para datos allocados dinámicamente. Los objetos en el heap viven hasta que son liberados (manual o por GC). Contrasta con stack. (Capítulo 20)
Impl block — Un bloque que define métodos sobre un tipo. impl Point { fn new() -> Point { ... } }. También se usa para implementar traits: impl Display for Point { ... }. (Capítulo 9)
Import — Traer definiciones de otro módulo al scope actual. import "std/json" o import { parse } from "std/json". (Capítulo 11)
Inferencia de tipos — El compilador deduciendo el tipo de una variable desde su valor. let x = 42 infiere x: int. (Capítulo 2)
Inline assembly — Escribir instrucciones de CPU directamente en código Nyx: unsafe { asm("nop") }. Usa sintaxis AT&T. (Capítulo 24)
Inmutable — No puede cambiar después de la creación. Variables declaradas con let son inmutables. (Capítulo 2)
Int — Un entero con signo de 64 bits. El tipo numérico por defecto en Nyx. Se escribe como 42, -7, 0xFF. (Capítulo 2)
IR (Representación Intermedia) — Código en un formato entre fuente y código de máquina. Nyx genera LLVM IR, que LLVM luego optimiza y compila a código nativo. (Capítulo 20)
Iterador — Un objeto que produce una secuencia de valores uno a la vez. Se crea con .iter(). Soporta encadenamiento: arr.iter().filter(f).map(g).collect(). (Capítulo 7)
Lambda — Una función anónima. En Nyx: fn(x: int) -> int { return x 2 }. También se llama closure cuando captura variables. (Capítulo 13)*
LLVM — Low Level Virtual Machine. Una infraestructura de compilador que Nyx usa como backend. LLVM toma IR y produce código de máquina optimizado para muchas arquitecturas. (Capítulo 20)
Lock-free — Un enfoque de concurrencia que usa operaciones atómicas en lugar de mutexes. Ningún thread puede bloquear a otro. (Capítulo 24)
M:N scheduler — Un scheduler que mapea N tareas de nivel usuario (goroutines) sobre M threads del SO. Usa work-stealing para balanceo de carga. (Capítulo 23)
Message queue (Cola de mensajes) — Un buffer que retiene mensajes hasta que un consumidor esté listo para procesarlos. A diferencia de Pub/Sub, cada mensaje va a exactamente un consumidor (round-robin) y los mensajes persisten hasta ser confirmados. nyx-queue implementa este patrón. (Capítulo 29)
Middleware — Una función que se ejecuta antes de los manejadores de ruta en un framework web, procesando o transformando requests. En nyx-serve, el middleware se registra con app_use() y puede cortocircuitar la cadena retornando un status distinto de cero. (Capítulo 27)
Map — Una tabla hash que mapea claves a valores. Se crea con Map.new(). Los Maps de Nyx usan Robin Hood hashing con direccionamiento abierto. (Capítulo 8)
Match — Pattern matching sobre valores. match x { 0 => ..., 1 | 2 => ..., _ => ... }. La verificación exhaustiva asegura que todos los casos estén cubiertos. (Capítulo 14)
Método — Una función definida dentro de un impl block que toma self como primer parámetro. Se llama con sintaxis de punto: point.distance(). (Capítulo 9)
Multiplexación — Enviar múltiples flujos independientes de datos sobre una sola conexión. HTTP/2 multiplexa requests usando stream IDs, permitiendo muchos pares request/response concurrentes sin abrir múltiples conexiones TCP. (Capítulo 30)
Módulo — Un archivo que contiene código Nyx que puede ser importado por otros archivos. Los símbolos se hacen disponibles con export. (Capítulo 11)
Monomorfización — El proceso de generar versiones especializadas de código genérico para cada tipo concreto usado. fn first llamada con int genera fn first_int. (Capítulo 16)
Mutable — Puede cambiar después de la creación. Variables declaradas con var son mutables. (Capítulo 2)
NACK (Negative Acknowledgment) — Un mensaje enviado por un consumidor para indicar que el procesamiento falló y el mensaje debe retornarse a la cola para re-entrega. En nyx-queue, NACK queue msg_id. (Capítulo 29)
Namespace (Espacio de nombres) — Un scope aislado para claves o recursos, previniendo colisiones de nombres entre diferentes usuarios o servicios. En nyx-kv, AUTH crea namespaces por usuario anteponiendo transparentemente user_id:: a todas las claves. (Capítulo 25)
Mutex (Exclusión Mutua) — Un candado que asegura que solo un thread puede acceder a un recurso a la vez. mutex_new(), mutex_lock(m), mutex_unlock(m). (Capítulo 18)
Newtype — Un struct con un solo campo, usado para crear un tipo distinto. struct Meters(int). Proporciona seguridad de tipos sin overhead en runtime. (Capítulo 9)
Null — La ausencia de un valor. En Nyx, prefiere Option (Some(value) o None) sobre null para hacer la ausencia explícita. (Capítulo 14)
Operación atómica — Una instrucción de CPU que se completa en un paso, sin posibilidad de interrupción por otro thread. atomic_load y atomic_store son atómicas. Se usan para programación lock-free. (Capítulo 24)
Operador pipe — |> pasa el resultado de la expresión izquierda como primer argumento a la función derecha. data |> transform |> print. (Capítulo 7)
Paralelismo — Ejecutar múltiples tareas simultáneamente en múltiples CPUs. Requiere múltiples threads o procesos. Distinto de concurrencia. (Capítulo 18)
Pattern matching — Desestructurar valores por su forma. match opt { Some(x) => use(x), None => default() }. Soporta literales, enums, structs, guards y comodines. (Capítulo 14)
Puntero — Una dirección de memoria. En Nyx, int es un puntero a int. Los punteros raw requieren bloques unsafe. (Capítulo 22)*
Recolector de basura (GC) — Un sistema que libera automáticamente memoria que ya no está en uso. Nyx usa el Boehm GC por defecto. El modo sin GC está disponible para programación de sistemas. (Capítulo 20)
RESP (Protocolo de Serialización de Redis) — El protocolo basado en texto usado por Redis. nyx-kv implementa RESP para compatibilidad con clientes Redis. (Capítulo 25)
Robin Hood hashing — La estrategia de tabla hash usada por los Maps de Nyx. Las entradas que están lejos de su posición ideal "roban" de entradas que están más cerca, reduciendo el tiempo de búsqueda en el peor caso. (Capítulo 25)
Runtime — El código que soporta un programa Nyx en ejecución: recolector de basura, operaciones de strings, networking, threading. Escrito en C (21 archivos). (Capítulo 20)
Scope — La región de código donde una variable es visible. Variables declaradas dentro de { } solo son visibles dentro de esas llaves. (Capítulo 5)
Self-hosting — Un compilador que puede compilar su propio código fuente. El compilador de Nyx está escrito en Nyx. (Capítulo 20)
Sentencia — Código que realiza una acción pero no produce un valor: let x: int = 5, print("hola"), return 0. Contrasta con expresión. (Capítulo 2)
Sombra de variable (Variable shadowing) — Declarar una nueva variable con el mismo nombre que una existente. La nueva variable oculta a la anterior en su scope. (Capítulo 2)
Stack — Una región de memoria para variables locales y marcos de llamadas a funciones. Rápido de allocar/deallocar. Limitado en tamaño (~8KB por thread). Contrasta con heap. (Capítulo 20)
String — Una secuencia de caracteres UTF-8. Se crea con comillas dobles: "hola". Inmutable en Nyx — la concatenación crea nuevos strings. Usa StringBuilder para construcción eficiente. (Capítulo 3)
Stream — En HTTP/2, un par lógico de request/response dentro de una sola conexión TCP. Los streams tienen IDs numéricos — impares para los iniciados por el cliente, pares para server push, 0 para frames a nivel de conexión. Múltiples streams pueden estar activos simultáneamente. (Capítulo 30)
StringBuilder — Una forma eficiente de construir strings incrementalmente. sb_new(), sb_append(sb, str), sb_to_string(sb). O(n) en lugar de O(n²) para concatenación. (Capítulo 20)
Struct — Un tipo compuesto con campos nombrados. struct Point { x: int, y: int }. Los structs son tipos por valor en Nyx. (Capítulo 9)
Thread — Una unidad de ejecución a nivel del SO. Se crea con thread_spawn(fn). Cada thread tiene su propio stack pero comparte memoria del heap. (Capítulo 18)
Tipo con tamaño (Sized type) — Un tipo con un ancho de bits específico: i8, i16, i32, u8, u16, u32, f32. Se usan para interacción con hardware y protocolos binarios. (Capítulo 24)
Trait — Una interfaz que define comportamiento. trait Display { fn to_string(self) -> String }. Los tipos implementan traits con impl Trait for Type { ... }. (Capítulo 15)
Trait bound — Una restricción que requiere que un parámetro de tipo implemente un trait. fn print_it. (Capítulo 16)
Tuple struct — Un struct con campos sin nombre, accedidos por índice. struct Color(int, int, int). (Capítulo 9)
Unsafe — Código que bypasea las garantías de seguridad de Nyx. Requerido para punteros raw, memoria manual, acceso volatile e inline assembly. unsafe { ... }. (Capítulo 22)
Volatile — Un acceso a memoria que el compilador no puede optimizar ni reordenar. Se usa para acceso a registros de hardware. volatile_read(ptr), volatile_write(ptr, val). (Capítulo 24)
Vtable — Una tabla de punteros a funciones usada para dispatch dinámico. Cuando usas dyn Trait, la vtable mapea nombres de métodos a sus implementaciones para el tipo concreto. (Capítulo 15)
WebAssembly (WASM) — Un formato binario para ejecutar código en navegadores web. Nyx puede compilar a WASM con make wasm. (Capítulo 24)
Work-stealing — Una estrategia de scheduling donde threads ociosos toman tareas de las colas de threads ocupados. Usada por el scheduler M:N de Nyx. (Capítulo 23)
Worker pool — Un conjunto fijo de threads pre-creados que procesan tareas de una cola compartida. nyx-kv usa 128 workers. http_serve_mt usa un worker pool internamente. (Capítulo 18)