424 términos recopilados de las secciones Definiciones y características de las 119 clases que las definen. Cada término enlaza a la clase (o clases) donde se explica en contexto: el glosario da la definición corta; la clase da el porqué, la comparación entre lenguajes y el código.
⚙️ Este archivo se genera con python scripts/generar_glosario.py. No se edita a mano: para corregir una definición, edítala en la clase de origen y vuelve a generar.
A
ABI — Application Binary Interface: representación de datos y protocolo de llamada a nivel binario. · 157
Abstraer — es representar solo los aspectos relevantes de algo, descartando el resto. · 005
Acoplamiento — el grado de dependencia entre componentes. · 149
Acumulación — reunir un resultado (suma) recorriendo. · 065
Acumulador — variable que reúne el resultado a lo largo de un bucle. · 054 · 063
Acumulador de producto — variable que empieza en 1 y se multiplica. · 064
Adaptación — traducir tipos, convenciones y errores entre la librería nativa y tu código. · 158
Agregación — combinar varios valores en uno (suma). · 117
Alcance (scope) — la región del texto del programa donde un nombre es visible y se resuelve a una ligadura concreta. · 082
AND (∧) — conjunción: verdadero solo si ambos operandos lo son. · 046
Anfitrión — la aplicación que hospeda el intérprete y le registra funciones y datos. · 163
Anotación de tipo — escribir el tipo explícitamente (int x). · 052
API vs. ABI — la API es el contrato en el código fuente; la ABI, en el binario. · 157
Aplicación parcial — fijar algunos argumentos y obtener una función nueva. · 115
append / push — añadir un elemento al final. · 090
Árbol — conjunto de nodos conectados jerárquicamente: hay un nodo raíz sin padre, y cada nodo restante tiene exactamente un padre y cero o más hijos. No hay ciclos, de modo que entre dos nodos cualesquiera existe un único camino. · 097
Árbol binario de búsqueda (BST) — árbol donde cada nodo tiene a lo sumo dos hijos y respeta el invariante de orden: izquierda < nodo < derecha (Cormen, cap. 12). · 097
Argumento — el valor concreto que se entrega al llamar (3, 4). · 073
Argumento nombrado (de palabra clave) — el que se pasa indicando explícitamente el parámetro al que va destinado, como y=4. La llamada deja de ser una secuencia posicional para volverse un conjunto de asociaciones nombre-valor. · 075
Argumento opcional — desde la perspectiva de quien llama, es el argumento que se puede no escribir. potencia(3) ejerce la opcionalidad de exp. Un parámetro por defecto es, visto desde afuera, un argumento opcional; son las dos caras del mismo contrato. · 074
Argumento posicional — el que se entrega por su lugar en la lista, sin nombre, y cuyo significado depende enteramente de en qué posición cae. · 075
Arista (edge) — conexión entre dos vértices. · 098
Arquitectura — la estructura de alto nivel de un sistema: qué componentes existen, qué responsabilidad tiene cada uno y cómo se relacionan. · 149
Arreglo (array) — secuencia de elementos del mismo tipo colocados uno tras otro en memoria. · 089
Artefacto versionado — el paquete inmutable que se despliega (un binario, una imagen de contenedor, un .jar, una rueda de Python), identificado por una versión. · 148
ASCII — codificación de 0-127 para el inglés básico; subconjunto de Unicode. · 047
Aserción — El corazón de la prueba: una comprobación que declara "esto debe cumplirse". · 139
Asignación — cambiar el valor de una variable existente. · 042
Asignación múltiple — asignar varias variables a la vez (a, b = b, a). · 042
Asíncrono — iniciar algo que tarda y seguir sin bloquear. · 122
async/await — sintaxis para escribir código asíncrono como si fuera secuencial. · 122
B
Base numérica — sistema para escribir un número (10, 16, 8, 2). · 044
Coerción — conversión automática que inserta el lenguaje. · 049
Cohesión — el grado en que los elementos de un módulo pertenecen realmente juntos. · 149
Coincidencia de patrones — elegir una rama según la estructura o el rango de un valor. · 062
Cola — búfer persistente que desacopla productor y consumidor. · 161
Cola (queue) — colección con disciplina FIFO. Se encola por la cola (enqueue) y se desencola por la cabeza (dequeue), de modo que quien llega primero es atendido primero, como una fila de personas. · 096
Colección — estructura que agrupa varios valores (lista, arreglo). · 065
Combinar — reunir los resultados parciales en el final. · 121
Componente — pieza con una responsabilidad y su propio lenguaje. · 091 · 155
componente — es una unidad con una responsabilidad —Hunt y Thomas, en The Pragmatic Programmer,. · 165
Componente de sistemas — cercano al hardware, con latencia acotada o memoria controlada. · 164
Componente web/datos — interfaz interactiva o consulta sobre datos. · 164
Comportamiento observable — todo lo que el mundo exterior percibe: las salidas para unas entradas dadas, los efectos visibles. · 150
Composición — construir un objeto a partir de otros (tiene-un) en vez de heredar (es-un). · 111
Comprensión de lista — expresión que construye una lista filtrando/transformando otra. · 067
Comprobación de tipos — verificar que las operaciones son válidas para los tipos. · 050
Comunicación entre procesos (IPC) — mecanismos para que procesos con memoria separada intercambien datos. · 161
Concurrencia — estructurar el programa como tareas que progresan a la vez. · 121
Condición — expresión que da verdadero o falso. · 057
Condición de parada — lo que hace terminar el bucle. · 063
Conjunto — colección de elementos únicos respaldada por una tabla hash (Python set, Java/C# HashSet, Rust HashSet); pertenencia, inserción y borrado en O(1) promedio. · 094
Constante — nombre asociado a un valor que no debe reasignarse. · 041
Consulta — pregunta al sistema sobre si algo se cumple. · 118
Contenedor — imagen que incluye el programa y su sistema operativo mínimo (Docker). · 039
continue — salta al siguiente ciclo del bucle. · 070
Contrato — el conjunto de operaciones públicas y lo que prometen hacer. depositar(n) promete «aumentar el saldo en n»; quien la llama no necesita —ni debe— saber cómo está guardado el saldo por dentro. · 087
Contrato de API — acuerdo de qué operaciones y datos expone un servicio. · 160
Convención de Go — devolver (valor, error) y comprobar if err != nil. · 072
Convención de llamada — reglas de paso de argumentos, valor de retorno y limpieza de pila. · 157
Conversión (casting) — cambiar explícitamente el tipo de un valor. · 049
Copia — el duplicado independiente que vive dentro de la función. · 079
Copia defensiva — copiar en la frontera de un módulo, al recibir y al devolver colecciones, para que nadie mute tu estado interno por accidente. · 102
Copia profunda (deep copy) — duplica recursivamente toda la estructura. copy.deepcopy en Python, structuredClone en JavaScript, clone() de un Vec<Vec<T>> en Rust (que es profunda por construcción, porque Vec posee sus elementos). · 102
Copia superficial (shallow copy) — contenedor nuevo, mismos elementos. list(x) o x[:] en Python, [...x] en JavaScript, Arrays.copyOf en Java, clone() en C#, copy() en Go, to_vec() en Rust. · 102
Cortocircuito — && y || no evalúan el segundo operando si el primero ya decide el resultado. · 046 · 057
CSP — Communicating Sequential Processes (Hoare, 1978): procesos que se sincronizan por canales. · 025
CSV (comma-separated values) — formato tabular de texto: una fila por registro, campos separados por un delimitador. · 106
Cultura invariante — política de formato que impone el punto decimal sin importar el locale. · 045
Currying — transformar una función de varios argumentos en una cadena de funciones de uno. · 115
D
Declaración — acto de introducir un nombre en un ámbito. · 041 · 042
Declarativo — paradigma en el que se describe el resultado deseado, no el algoritmo. · 024 · 117
default — rama que se ejecuta si ningún case coincide. · 061
defensa de decisiones — es el género concreto que nos ocupa hoy: un argumento revisable —y por tanto. · 175
Depurador — Programa que controla la ejecución de otro: lo pausa, lee su memoria y sus variables, y lo reanuda bajo tus órdenes. · 141
Descomponer — es dividir un problema en subproblemas más simples, cada uno resoluble y verificable por separado. · 004
Desempaquetar (unpacking / spread) — la operación inversa y complementaria: expandir una colección ya existente en argumentos sueltos al llamar. suma(*[1, 2, 3]) en Python o suma(...[1,2,3]) en JS toman una lista y la «derraman» como si hubieras escrito los elementos uno a uno. · 076
Deserializar (unmarshalling, parsing) — reconstruir estructuras desde el texto. · 105
Desestructuración — repartir los componentes de una tupla en variables independientes de una sola vez (a, b = t). · 091
Desestructuración (destructuring) — la operación de recibir una tupla, arreglo u objeto y repartir sus componentes en variables separadas en un solo paso: q, r = divmod(a, b). Es la contraparte del empaquetado; sin ella, el multi-retorno obligaría a extraer cada campo por índice a mano. · 077
Despliegue (deployment) — el acto de instalar y activar una versión concreta en un entorno. · 148
Divisor — número que divide a otro sin resto. · 070
do-while — variante que ejecuta al menos una vez (comprueba al final). · 063
E
Eco — devolver la entrada tal cual (con un prefijo). · 056
Edition / versión — etiqueta que fija qué características y qué compatibilidad esperar. · 016
Efecto en el llamador — en el paso por valor puro, ninguno. Esa ausencia de efecto es precisamente su garantía: una función que recibe todo por valor no puede tener el efecto secundario de alterar las variables de quien la llamó. · 079
Efecto secundario — cualquier cambio que una función produce fuera de sí misma, aquí la mutación de la variable del llamador. · 080
Ejecución diferida — el cálculo ocurre al consumir, no al declarar. · 066
El matiz de la «llamada por compartición» — cuidado con extrapolar. · 079
Elemento neutro — valor inicial que no altera el resultado (0 al sumar, 1 al multiplicar). · 068
Elixir — 2011 (José Valim), sintaxis moderna sobre la BEAM. · 025
else — rama por defecto si ninguna condición se cumple. · 059
else if — condición alternativa si la anterior falló. · 059
Empaquetado — preparar un programa y sus dependencias para distribuirlo. · 039
Empaquetar — es preparar un programa y sus dependencias para que otra persona lo use, y la palabra decisiva es dependencias. Todo programa no trivial se apoya en cosas que no escribiste: bibliotecas de terceros, la biblioteca estándar del lenguaje, un intérprete o una máquina virtual, y por debajo de todo eso, bibliotecas del…. · 039
Empaquetar (packing) — la operación que ocurre dentro de la función: los argumentos sueltos que pasó el llamador se reúnen automáticamente en una sola estructura. · 076
Encapsulación — agrupar los datos y las operaciones que los manejan en una sola unidad, y ocultar los datos tras las operaciones. · 087
Encapsulación de módulo — la propiedad de exponer solo la interfaz pública y ocultar los detalles internos. · 086
Enfoque — la estrategia elegida para resolver. · 107
Entero — número sin decimales, de tamaño fijo en los estáticos. · 043
Entorno (environment) — la estructura, descrita en SICP §3.2, que asocia nombres a valores en un marco, más un enlace al entorno que lo rodea. · 082
Entornos — copias del sistema con propósitos distintos: dev para desarrollar, staging para ensayar en condiciones casi reales, prod para los usuarios. · 148
Entrega continua (continuous delivery) — la disciplina de mantener el software siempre en un estado desplegable: cada cambio que pasa la CI genera un artefacto versionado y validado, de modo que desplegar sea una decisión de negocio, no una odisea técnica. · 148
Enumeración (enum) — tipo cuyos valores forman un conjunto cerrado y finito de constantes con nombre. · 100
**equalsfrente a==en Java** —==sobre dos variables de tipo objeto compara *referencias*;equalscompara *contenido*. Es la trampa más famosa del lenguaje y la razón por la ques1 == s2con dos cadenas de igual texto puede darfalse`. · 101
Equivalencia observable — Dos implementaciones son equivalentes si, ante las mismas entradas, producen la misma salida observable —aquí, la misma cadena en stdout—. No exige que el código interno se parezca; de hecho, el código de Python y el de C son irreconocibles entre sí. Lo que se contrasta es el comportamiento externo, que es lo…. · 140
Erlang — 1986 (Ericsson, Joe Armstrong y otros), para telecomunicaciones. · 025
Error de representación — diferencia entre el real deseado y el representable más cercano; origen de 0.1 + 0.2 != 0.3. · 045
Espacio de nombres — el territorio de nombres que un módulo reserva para sí. Es lo que convierte sqrt en math.sqrt y evita que dos sqrt de orígenes distintos choquen. · 086
Esquema — estructura acordada de los datos. · 105 · 159
estado de la UI — son los datos que la interfaz muestra en un instante dado; cambia con cada interacción,. · 169
Estado mutable — variables que cambian durante la ejecución. · 108
Estándar — documento que define el lenguaje (ISO C, ECMAScript). · 016
Estático con inferencia — tipos fijos que no hace falta anotar. · 052
Estilo declarativo — describir el resultado, no los pasos. · 067
Estrategias de despliegue — blue-green mantiene dos entornos idénticos y conmuta el tráfico de golpe (rollback = volver a conmutar); canary dirige primero una fracción del tráfico a la versión nueva y la amplía si se comporta; rolling reemplaza instancias poco a poco. Contenedores (Docker) empaquetan el artefacto con su entorno…. · 148
Estructurado — usa solo secuencia, selección e iteración (sin goto). · 108
Etiqueta (tag) — la marca v1.2.3 en el historial de Git que fija un artefacto a un commit exacto. · 148
Etiqueta de bucle — nombre que permite romper un bucle exterior desde uno interior. · 070
Evaluación perezosa — calcular un valor solo cuando se pide. · 066
Evento — suceso al que el programa reacciona (clic, mensaje, dato). · 119
Excepción — objeto que representa un error y desvía el flujo. · 071
Exhaustividad — el compilador exige cubrir todos los casos (Rust). · 062
Exportar — la cara opuesta del importar: marcar qué partes de un módulo son visibles para quien lo importe. · 088
Expresión generadora — la misma sintaxis con paréntesis, que produce elementos bajo demanda. · 067
F
F# — 2005 (Don Syme), funcional tipado derivado de OCaml, sobre .NET. · 020
Fail-fast y caché — dos ajustes prácticos: fail-fast aborta el resto de la matriz en cuanto una celda falla, para no gastar minutos en un resultado ya condenado; la caché de dependencias guarda entre ejecuciones lo descargado (paquetes de pip, ~/.cargo, node_modules) para que el pipeline sea rápido y el equipo no lo evite por…. · 147
fallthrough — en C/Java, un case sigue al siguiente si falta break. · 061
Familia — grupo de lenguajes con ancestro y rasgos comunes. · 015
FFI — interfaz para llamar a funciones de otro lenguaje en el mismo proceso. · 156
Filtro — condición que decide qué elementos entran. · 067 · 117
finally — bloque que se ejecuta siempre (haya error o no). · 071
Firma — el nombre, la lista de parámetros y el tipo de retorno tomados juntos. · 073
Flujo/stream — secuencia de datos procesada por etapas. · 120
for — bucle con inicialización, condición e incremento. · 064
for-each — bucle que recorre cada elemento de una colección. · 065
for-range — recorrer un rango o colección sin gestionar el índice (Python, Rust, Go). · 064
Formateo — conversión a texto con N decimales, que además redondea el valor aproximado. · 045
Formato de intercambio — representación común (JSON, Protobuf, MessagePack). · 159
Fortran — 1957 (IBM, John Backus), primer lenguaje de alto nivel. · 027
Frecuencia — número de apariciones de un elemento; el uso canónico del mapa consiste en usar el elemento como clave y su cuenta como valor. · 095
Frontera — el punto donde dos componentes se comunican. · 155
Función — bloque con nombre que recibe parámetros y devuelve un valor. · 073
Función de orden superior — recibe o devuelve otra función. · 068
Función externa — definida en otro lenguaje (C) y llamada desde el tuyo. · 156
Función variádica — la que acepta un número indeterminado de argumentos en la posición variádica. · 076
Funcional — paradigma basado en funciones puras e inmutabilidad. · 114
Functor — contenedor sobre el que se puede aplicar map (Option, listas). · 116
G
Generador — función que produce una secuencia perezosa (yield). · 066
Genérico — una función o un tipo parametrizado por otro tipo, como mayor<T>. La T es una variable de tipo: un hueco que el llamador rellena. · 078
goto — salto incondicional (existe en C, desaconsejado). · 070
Grafo — par G = (V, E) formado por un conjunto de vértices V y un conjunto de aristas E ⊆ V×V. Es la estructura de relación más general: cualquier árbol es un grafo (uno conexo y sin ciclos), pero no todo grafo es un árbol. · 098
gRPC — framework de RPC con contratos definidos en Protobuf. · 160
Guarda — condición al inicio que corta el flujo si no se cumple. · 058
Guarda de patrón — condición extra dentro de un caso (n if n>0). · 062
Herencia — un tipo hereda estado/comportamiento de otro. · 111
Herencia vs. influencia — heredar es pertenecer a la familia; influir es tomar un rasgo suelto (Rust hereda de C la sintaxis, pero recibe la influencia de ML en sus tipos). · 015
Herramienta de proyecto — el archivo que declara las dependencias externas y cómo se construye el proyecto (pyproject.toml, package.json, go.mod, Cargo.toml, pom.xml, composer.json). · 088
Hilo/goroutine — unidad de ejecución concurrente. · 121
Homoiconicidad — el código tiene la misma estructura que los datos que manipula. · 023
I
Idoneidad — cuánto encaja un lenguaje con una tarea. · 164
if — ejecuta un bloque si la condición es verdadera. · 059
if-expresión — un if que devuelve un valor (Rust, Kotlin). · 060
Importar — el acto de traer un módulo (o parte de él) al alcance del archivo actual, con import, require o use según el lenguaje. · 086
Importar / incluir — el acto de traer un módulo o cabecera al alcance del archivo: import en Python y Java, require/import en JavaScript, use en Rust, using en C#, #include en C. No todos hacen lo mismo por dentro —#include de C pega texto, import de Python ejecuta y vincula un módulo—, pero todos responden a la misma…. · 088
Índice — desplazamiento entero desde el inicio, empezando en 0. arr[0] es el primer elemento porque está a cero celdas del comienzo; arr[i] está a i celdas. · 089
Índice de carácter — posición desde el inicio, base 0; coincide con el índice de byte solo mientras el texto sea ASCII/de ancho fijo. · 093
Inferencia de tipo genérico — el compilador deduce T a partir de los argumentos, así que rara vez hay que escribirlo. · 078
Inferencia de tipos — el compilador deduce los tipos sin anotarlos. · 022 · 052
Inicialización — dar el primer valor a una variable. · 041 · 042
Inmutabilidad — en Python, Java, C#, JS, Go y Rust la cadena no se modifica in situ: se crea una nueva. · 048 · 054 · 114
Inmutable — no se modifica en sitio (Java, C#, Python, JavaScript, Go): invertir o concatenar crea otra cadena. · 093
Instancia (instance / value) — un valor concreto del tipo, Persona("Ada", 36). La gran división: si el tipo tiene semántica de valor, asignar o pasar la instancia la copia entera (dos variables independientes); si tiene semántica de referencia, ambas variables apuntan al mismo objeto y mutar una afecta a la otra. · 099
Integración continua — la práctica de fundir cambios en una línea compartida con frecuencia (idealmente varias veces al día) y verificarlos automáticamente en cada empuje. · 147
Interfaz — conjunto de métodos que un tipo promete implementar. · 112
Interning — compartir una sola copia de cadenas idénticas para ahorrar memoria y acelerar comparaciones. · 048
Interpolación — insertar el valor de una variable dentro de una cadena (f"...{x}", ${x}, %s). · 048
Intervalo semiabierto vs. cerrado — [inicio, fin) (semiabierto, el más común: Python range, Rust .., los índices de casi todo) incluye el inicio y excluye el fin, de modo que su longitud es exactamente fin − inicio. [inicio, fin] (cerrado o inclusivo: Rust ..=, Ruby .., la salida de esta clase) incluye ambos extremos. · 092
Invariante — una regla que el objeto cumple siempre, entre operación y operación (por ejemplo, saldo >= 0). · 087
Inversión — producir la secuencia en orden contrario. · 090
Inversión de control — el sistema invoca tu código, no al revés. · 119
Iterador — objeto que produce valores uno a uno. · 066
Java — 1995 (Gosling, Sun), OO nominal sobre la JVM. · 019
JavaScript — 1995 (Brendan Eich, Netscape), dinámico y basado en prototipos. · 021
JSON (JavaScript Object Notation) — formato de texto para datos estructurados, definido por Douglas Crockford y estandarizado como RFC 8259 y ECMA-404. · 105
Julia — 2012, cálculo científico con rendimiento cercano a C. · 027
Kotlin — 2011 (JetBrains), Java moderno con null-safety y corrutinas. · 019
L
Leer una línea — obtener texto hasta el salto de línea. · 056
Legibilidad de la llamada — la propiedad de entender qué hace una invocación sin necesidad de consultar la firma de la función. · 075
Lenguaje de sistemas — diseñado para software cercano al hardware, con control de memoria y sin GC obligatorio. · 026
Lenguaje embebido — intérprete enlazado como biblioteca dentro de una aplicación anfitriona (Lua, Python, JS). · 163
LIFO frente a FIFO — no son dos nombres de lo mismo: son dos políticas opuestas de salida sobre la misma secuencia de entrada. · 096
Lisp — 1958 (John McCarthy), segundo lenguaje de alto nivel más antiguo. · 023
Lista/vector dinámico — arreglo contiguo cuyo tamaño puede crecer y encoger en tiempo de ejecución (list de Python, Vec<T> de Rust, ArrayList de Java, List<T> de C#, el slice de Go). · 090
Literal — valor escrito directamente en el código fuente (15000, "hola", true). · 041
Log — Mensaje que registra un evento del programa junto al momento y el contexto en que ocurrió. Es la caja negra del avión: cuando algo falla en producción, el log es lo que reconstruye la secuencia. · 142
Logging estructurado — En lugar de una frase ("se procesaron 5 elementos"), se emiten campos (procesados=5, o un JSON {"procesados":5}). · 142
Lógico — paradigma en el que se declaran hechos y reglas y se consultan (Prolog). · 118
Longitud — número de unidades de la cadena; su unidad (byte, code unit, code point) depende del lenguaje. · 048
Longitud y capacidad — len es cuántos elementos contiene; cap es cuántos caben en el bloque reservado antes de tener que crecer. · 090
Lua — 1993 (PUC-Rio), minimalista y embebible. · 018
M
malloc(tamaño) — no pide memoria al sistema operativo en cada llamada. · 130
Malos olores (code smells) — síntomas superficiales de problemas de diseño más hondos: duplicación, funciones demasiado largas, nombres crípticos, clases que hacen de todo. · 150
Manejo explícito — el compilador o el estilo obligan a tratar el error. · 072
map — aplica una función a cada elemento y devuelve una colección nueva. · 068 · 114
map sobre Option — aplica la función si hay valor; si no, propaga la ausencia. · 116
Mapa — colección de pares clave→valor respaldada por una tabla hash (Python dict, Java HashMap, C# Dictionary, Go map, Rust HashMap); acceso por clave en O(1) promedio. · 095
Marco de pila — el bloque que cada llamada apila. · 069
match — construcción de coincidencia de patrones (Rust, Python 3.10+). · 062
Match y exhaustividad — la construcción que inspecciona un valor suma, decide qué variante es y extrae sus datos en el mismo gesto (pattern matching). · 100
Matriz — la ejecución del mismo pipeline sobre varias combinaciones de entorno (versiones de lenguaje, sistemas operativos). · 147
Memoización — cachear resultados ya calculados. · 069
Método — función asociada a un objeto que opera sobre su estado. · 110
ML — familia de 1973 (Robin Milner) con inferencia de tipos Hindley-Milner. · 022
Modelo de actores — concurrencia mediante procesos aislados que intercambian mensajes. · 025
Modularidad — dividir el problema en piezas manejables. · 109
Movimiento (move) — pasar un valor «pesado» (como un String, que posee memoria en el heap) transfiere la propiedad: la variable de origen queda invalidada y el compilador prohíbe seguir usándola. · 081
Multiparadigma — lenguaje que soporta varios estilos (Python, C#, Rust). · 107
Mutabilidad — si un enlace nombre→valor puede cambiar. · 041 · 054
N
Nivel de log — La gravedad del mensaje, en una escala convencional: DEBUG (detalle fino para desarrollo), INFO (hitos normales, como nuestro procesados=5), WARN (algo anómalo pero recuperable) y ERROR (fallo que exige atención). · 142
NOT (¬) — negación: invierte el valor de verdad. · 046
Nulabilidad — posibilidad de que un valor esté ausente. · 053
Objective-C — C + mensajería estilo Smalltalk (1984, Cox). · 017
Objetivo (target) — el formato al que compila un lenguaje. · 162
Objeto — instancia que agrupa estado y comportamiento. · 110
Objeto de opciones — el sustituto idiomático en lenguajes sin argumentos nombrados, sobre todo JavaScript: se pasa un único objeto { x: a, y: b } y sus claves cumplen el papel de los nombres. · 075
Objeto literal — objeto creado directamente con sus campos y métodos. · 113
Observabilidad — La capacidad de inferir el estado interno de un sistema a partir de lo que emite, sin acceder a su interior. · 142
Operador — símbolo que combina valores para producir otro (+, *, %). · 055 · 120
Operador ternario — cond ? a : b: elige a o b según la condición. · 060
Option / Maybe — tipo que envuelve 'hay valor' o 'no hay' (Rust, Haskell). · 053
Option/Maybe — envuelve un valor presente (Some) o ausente (None). · 116
OR (∨) — disyunción: verdadero si al menos uno lo es. · 046
P
Palabra clave (keyword) — el propio nombre del parámetro usado en la llamada. · 075
Paquete — en la mayoría de los lenguajes, la agrupación de varios módulos bajo un nombre común, normalmente mapeada a una carpeta del sistema de archivos. · 086
Paradigma — estilo de estructurar programas (imperativo, OO, funcional, declarativo). · 107
Parámetro — la variable declarada en el hueco de la definición (a, b). · 073
Parámetro de salida (out param) — la técnica de C: devolver un valor por return y entregar los demás escribiéndolos en direcciones de memoria que el llamador pasa por puntero. · 077
Parámetro local — la variable de la función que contiene la copia. · 079
Parámetro por defecto — un parámetro que lleva escrito en la firma el valor que tomará si el llamador lo omite. · 074
Parseo — interpretar un texto como un número. · 049
Paso a paso (step) — Avanzar de forma controlada: step over ejecuta la línea sin entrar en las funciones que llama, step into baja al interior de la llamada, step out termina la función actual y vuelve a quien la invocó. Elegir bien entre ellos es lo que evita ahogarse en detalles irrelevantes. · 141
Paso por referencia — la función recibe un camino de acceso a la variable original, no una copia de su valor. · 080
Paso por referencia vs. referencia por valor — la distinción capital. · 080
Paso por valor — el argumento se copia en el parámetro al invocar la función. · 079
PATH — lista de carpetas donde se buscan los ejecutables. · 040
Perl — 1987 (Larry Wall), rey del texto y las regex. · 018
Persistencia — conservar datos más allá de la vida del proceso. · 106
Pertenencia — comprobar si un elemento está, en O(1) promedio; es la operación que la lista hace en O(n) y el conjunto en tiempo constante. · 094
PHP — 1994 (Lerdorf), nacido para la web incrustado en HTML. · 018
Pila (stack) — colección con disciplina LIFO. Solo se manipula un extremo, la cima: push deposita un elemento encima y pop retira el que esté encima, que siempre es el más reciente. · 096
Pipeline — la secuencia ordenada de pasos que se ejecuta sobre cada cambio: típicamente compilar, ejecutar las pruebas y pasar linters/formatters. · 147
Polimorfismo — el mismo método se comporta distinto según el tipo real. · 111
Polimorfismo paramétrico — la capacidad de que un mismo cuerpo de código opere sobre muchos tipos. · 078
Precedencia — el orden de evaluación (* antes que +). · 055
Precisión relativa — ~15-17 dígitos significativos; el hueco entre representables crece con la magnitud. · 045
Predicado — condición sobre un valor (es positivo, es par). · 057 · 067
Préstamo (borrow) — crear una referencia con & para usar un valor sin tomar su propiedad. · 081
Privado — accesible solo desde dentro del propio tipo. · 087
Procedimental — paradigma que organiza el código en procedimientos/funciones. · 109
Procedimiento — unidad con nombre que realiza una tarea. · 109
Programación estructurada — aporte de ALGOL: bloques, alcance y control de flujo sin goto. · 015
Programar — es expresar la solución de un problema como instrucciones que una máquina ejecuta. · 001
Promesa/Future/Task — objeto que representa un resultado futuro. · 122
Promoción — convertir un entero a real para operar con otro real. · 050
Propiedad (ownership) — la regla de que cada valor tiene un único dueño, y que al terminar el ámbito del dueño el valor se libera automáticamente (Rust llama a eso drop). · 081
Protocolo de iteración — el contrato que un objeto cumple para ser recorrible. · 065
Prototipo — objeto del que otro hereda propiedades y métodos. · 113
Prototipos — modelo de OO donde los objetos heredan de otros objetos, no de clases. · 021
Prueba de integración — Verifica que dos o más piezas colaboran correctamente: no que cada una funcione por separado (eso ya lo cubre la unitaria), sino que sus supuestos encajan en la frontera. · 140
Prueba unitaria — Código que ejerce una unidad de comportamiento —normalmente una función— de forma aislada y automática, y afirma un resultado. · 139
Público — la parte visible, el contrato que otros usan y del que dependen. · 087
Puntero — en C y Go, un valor que guarda la dirección de otra variable. · 080
Punto de código — el entero que Unicode/ASCII asigna al carácter; A es U+0041 = 65. · 047
Punto de ruptura y watch — Un breakpoint pausa la ejecución al llegar a una línea (o cuando se cumple una condición, como i == 100); un watch es una expresión que el depurador reevalúa en cada pausa, o incluso un watchpoint que detiene el programa en cuanto una variable cambia de valor. · 141
Punto flotante — real codificado como signo × mantisa × 2^exponente (IEEE 754 binario64). · 045
Python — 1991 (Guido van Rossum), prioriza la legibilidad. · 018
R
R — 1993 (Ihaka y Gentleman), especializado en estadística y visualización. · 027
Rango — objeto que describe un intervalo de valores consecutivos (2..5, range(2, 6)) sin enumerarlos. · 092
Reactivo — reaccionar a datos que llegan con el tiempo. · 120
Recorridos — hay tres formas recursivas de visitar todos los nodos, que difieren en cuándo se procesa la raíz respecto a sus subárboles: preorden (raíz, izquierda, derecha), inorden (izquierda, raíz, derecha) y postorden (izquierda, derecha, raíz). · 097
Recursión — técnica en que una función se invoca a sí misma. · 069
Recursión de cola — la llamada recursiva es lo último que se hace. · 069
Red de seguridad (safety net) — el conjunto de pruebas que, al seguir en verde tras cada paso, garantiza que la conducta no cambió. Beck la considera el prerrequisito psicológico de la refactorización: convierte una operación arriesgada en un hábito cotidiano. · 150
reduce — combina todos los elementos en un valor (suma, producto). · 068
Refactorización — según Fowler, una transformación que reestructura el código sin cambiar su comportamiento observable, con el fin de hacerlo más fácil de entender y más barato de modificar. · 150
Referencia compartida (aliasing) — dos nombres para el mismo dato en el heap. · 102
Referencia mutable — el enlace explícito que autoriza a cambiar el valor: &mut en Rust, ref en C#, & en C++. Es la forma más honesta de paso por referencia: la firma declara en voz alta «voy a poder modificar esto». · 080
Registro (record / struct) — tipo compuesto que agrupa un número fijo de campos, cada uno con su propio nombre y su propio tipo. · 099
Registro posicional vs. registro nominal — un registro agrupa campos relacionados; la diferencia está en cómo se identifican. · 091
Regla — relación condicional entre términos. · 118
Regresión — Un cambio que rompe algo que antes funcionaba. · 140
Renderizar — es convertir esos datos en elementos visuales —es, literalmente, lo que el usuario ve—. El. · 169
Representación — la lista de adyacencia usa O(V+E) memoria y recorrer los vecinos de un vértice es proporcional a su grado; la matriz de adyacencia usa O(V²) pero responde «¿hay arista entre u y v?» en O(1). · 098
REST — estilo basado en recursos y métodos HTTP (GET, POST, PUT). · 160
Restauración — al abandonar el bloque interior, su marco se descarta y el nombre externo vuelve a ser el visible, sin haber sido tocado. · 082
Restricción de tipo (constraint / bound) — la condición que debe cumplir T para que el cuerpo tenga sentido. · 078
Result/Either — tipo que contiene un valor de éxito o uno de error (Rust, Haskell). · 072
Retorno — el valor que la función entrega de vuelta a quien la llamó. Una función que devuelve valor se distingue de un procedimiento, que solo produce efectos. · 073
Retorno múltiple — la capacidad de una función de devolver varios valores en una sola llamada, sin envolverlos en un objeto que el llamador tenga que abrir. · 077
Retorno temprano — salir de la función en cuanto hay respuesta. · 058
return — abandona la función entera, no sólo el bucle. · 070
Reutilización — apoyarse en código existente en vez de reescribirlo. · 088
Ruby — 1995 (Matz), diseñado para la felicidad del programador. · 018
Runner — La herramienta que descubre las pruebas, las ejecuta y reporta el resultado agregado. · 139
Rust — 2010/2015 (Mozilla, Graydon Hoare), seguridad de memoria sin GC vía propiedad. · 026
Ruta absoluta vs. relativa — desde la raíz (/usr/bin) o desde la carpeta actual (./main). · 040
Scheme — 1975, dialecto minimalista y elegante. · 023
Script embebido — código interpretado que corre dentro del proceso del anfitrión. · 163
Secuencia perezosa vs. materializada — la perezosa produce sus elementos bajo demanda y no los guarda (el range de Python, un generador, un iterador de Rust): O(1) en memoria. · 092
Seguridad de memoria — garantía de no acceder a memoria inválida (use-after-free, desbordamientos). · 026
Separador de rutas — ':' en Unix y ';' en Windows para el PATH; '/' vs. '\' en las rutas. · 040
Serialización — convertir datos en un formato transmisible, texto o binario. · 159
Serializar (marshalling, encoding) — convertir estructuras en memoria a texto JSON. O(n). · 105
Simular el defecto — en los lenguajes sin la característica (C, Go), reconstruir el efecto a mano: comprobar en el sitio de llamada si el dato llegó y, si no, asignar el valor base. · 074
Sintaxis de llaves — bloques con {} y sentencias con ;. · 017
Sistema políglota — software compuesto por partes en distintos lenguajes. · 155
Slice / arreglo receptor — la forma que toma la colección empaquetada según el lenguaje: una tupla en Python, un arreglo en Java y C#, un slice en Go, un Vec/slice en Rust. · 076
Sobrecarga (overloading) — definir varias funciones con el mismo nombre y distinta lista de parámetros, de modo que el compilador elija cuál usar según los argumentos. · 074
Sobrecarga de operador — un operador con distinto significado según los tipos. · 051
Sombreado (shadowing) — cuando un bloque interno declara un nombre igual al de un bloque externo, el interno oculta (no destruye) al externo dentro de su región. · 082
SQL — años 70 (IBM, sobre el modelo relacional de Codd), consulta de bases relacionales. · 024
stdin — canal de entrada estándar de un programa. · 056
Struct / objeto de salida — la alternativa de los lenguajes sin multi-retorno nativo: se define un tipo que agrupa los resultados con nombre —el record DivRes de Java— y se devuelve esa única instancia. · 077
switch — estructura que elige una rama según el valor exacto. · 061
T
take — tomar los primeros n de una secuencia. · 066
Tamaño fijo — la longitud se fija al crear el arreglo y no cambia. · 089
this — referencia al objeto sobre el que se llama el método. · 113
Tipado dinámico — los tipos se resuelven en ejecución (Python, PHP, JS). · 050
Tipado estático — los tipos se fijan y comprueban en compilación (Java, C#, Go, Rust, C). · 050
Tipado fuerte — no permite operar entre tipos incompatibles sin conversión (Python, Java). · 051
Tipo algebraico (ADT) — tipo compuesto por alternativas (suma) o agregados (producto). · 022
Tipo primitivo — tipo básico incorporado al lenguaje (entero, real, booleano, carácter). · 043
Tipo suma / ADT — valor que es una de varias alternativas, y cada alternativa puede llevar datos propios y distintos: Cuadrado(i64) lleva un lado, Rectangulo(i64, i64) lleva ancho y alto. · 100
Trait — el equivalente en Rust; puede llevar métodos por defecto. · 112
Trampa del defecto mutable — en Python el valor por defecto se evalúa una vez, al definir la función, y se reutiliza en cada invocación. · 074
Traza — La secuencia de estados por los que pasa el programa. · 141
Tronco — lenguaje raíz del que desciende una familia (Fortran, Lisp, ALGOL). · 015
Truncamiento — descartar la parte decimal hacia cero. · 049
Tubería — conecta la salida de un proceso con la entrada de otro. · 161
Tupla — un grupo ordenado y a menudo inmutable de valores, posiblemente de tipos distintos, tratado como una sola unidad. · 077 · 091
TypeScript — 2012 (Microsoft), superset de JS con tipos estáticos que se borran al compilar. · 021
U
Umbral — valor límite que separa dos categorías. · 059
Unicidad — cada valor aparece a lo sumo una vez; insertar uno ya presente no cambia el conjunto. · 094
Unicode — catálogo universal que asigna un punto de código a cada carácter de todo idioma. · 047
Unidad de código — pieza de almacenamiento de una codificación (1 byte en UTF-8, 2 en UTF-16). · 047
Unificación — mecanismo que hace coincidir términos ligando variables para satisfacer una consulta. · 024
V
**va_list(C)** — el mecanismo de bajo nivel de C para variádicas reales: un puntero móvil sobre la pila de argumentos que recorres conva_arg`, indicándole tú el tipo de cada uno. · 076
Validación temprana — rechazar entradas inválidas antes del cálculo. · 058
Valor — el dato concreto que existe en memoria durante la ejecución. · 041
Valor centinela — un valor normal usado para significar 'ausente' (aquí, 0). · 053
Valor de error — devolver el error como dato en lugar de lanzarlo. · 072
var / := / let — formas de declarar con inferencia (C#, Go, Rust). · 052
Variable — nombre asociado a un valor que puede reasignarse. · 041
Variable de entorno — valor con nombre que el sistema pasa a los programas (PATH, HOME). · 040
Variante (variant / constructor) — cada alternativa del tipo suma, con su nombre y su carga de datos. · 100
Vectorización — aplicar una operación a un arreglo entero sin escribir el bucle. · 027
Veracidad (truthiness) — regla por la que valores no booleanos se interpretan como verdaderos o falsos. · 046
Verde/rojo — el estado agregado del pipeline. · 147
Verificador de préstamos (borrow checker) — la parte del compilador que comprueba estas reglas en tiempo de compilación: que no uses un valor movido, que las referencias no sobrevivan al dato, que el aliasing mutable sea único. · 081
Vida (lifetime) — cuánto tiempo existe la variable en memoria. · 082
W
WASI — interfaz de sistema para Wasm fuera del navegador, basada en capacidades. · 162
WebAssembly — es el formato binario de una máquina virtual de pila con un conjunto de instrucciones deliberadamente pequeño: enteros y flotantes de 32 y 64 bits, aritmética, control estructurado (bloques, bucles, condicionales — no saltos arbitrarios) y acceso a una memoria lineal. · 162
wheel/jar — formatos empaquetados de Python y Java. · 039
while — bucle que repite mientras la condición sea verdadera. · 063
Wrapper — función que envuelve otra adaptando su interfaz. · 158
Z
Zig — 2016 (Andrew Kelley), alternativa moderna y minimalista a C. · 026