El Curso de bases numéricas y bits es un tutorial interactivo de 17 niveles que convierte el «sistema binario» de concepto abstracto en interruptores que se tocan con el dedo: escribes un número y sus cuatro escrituras (binaria, octal, decimal y hexadecimal) cambian a la vez; enciendes o apagas un bit y el valor se actualiza al instante; haces AND / OR / XOR / desplazamientos con dos números y el resultado se alinea bit a bit; escribes un decimal y lo ves desglosado en signo, exponente y mantisa, junto con el decimal exacto al que equivale en doble precisión. Cada nivel tiene un objetivo concreto —convertir un número, componer 200, escribir el complemento a dos de -5, calcular 5 << 3— y el evaluador responde al momento.

El curso se divide en cuatro bloques: conversión de bases (binario ↔ decimal, potencias de 2, por qué el hexadecimal y el octal son una «taquigrafía»); números con signo (cómo el complemento a dos convierte la resta en suma, por qué el desbordamiento hace que 127 + 1 pase a -128); operaciones de bits (máscaras con AND, poner bits con OR, invertir con XOR, multiplicar y dividir con desplazamientos y su aplicación directa en los bits de permisos de Linux 755); y coma flotante (el diseño de campos de IEEE 754 y el verdadero motivo de que 0.1 + 0.2 !== 0.3).

Se completa en unos 45 minutos. Está pensado para quienes empiezan a programar, para desarrolladores que preparan entrevistas y para quien tiene que consultar 0x1F, & 0xFF o chmod 644 cada vez que los ve; no hace falta base matemática, basta con saber sumar.

1. 01Mira el objetivo y el panelcada nivel empieza con su objetivo arriba; debajo, el panel cambia según el nivel: el panel «Valor» tiene una caja de entrada, la lectura en las cuatro bases y una fila de interruptores de bits en los que se puede hacer clic, con conmutador entre lectura con signo y sin signo; el panel «Operaciones» ofrece dos operandos y un operador y muestra el resultado alineado bit a bit; el panel «Permisos» tiene 9 interruptores rwx y la lectura octal; y el panel «Coma flotante» acepta un decimal y muestra el desglose en campos de 32 / 64 bits y su desarrollo decimal exacto.
2. 02Opera y observacambia entradas, pulsa interruptores de bits y alterna el ancho de bits: todas las lecturas se actualizan en vivo. Observar es parte del aprendizaje; por ejemplo, pasa 128 a lectura con signo y lo verás convertirse en -128.
3. 03Respondeen la mayoría de niveles se escribe en la caja de respuesta un número decimal, una cadena binaria, hexadecimal u octal; los niveles de «interruptores de bits» piden que compongas el valor solo con clics; el último nivel de coma flotante es de opción múltiple.
4. 04Evaluaciónla barra de resultados dice al momento si has acertado o en qué fallas; en las respuestas binarias se permiten ceros a la izquierda (salvo en los niveles que exigen «exactamente 8 bits»), y el hexadecimal no distingue mayúsculas ni minúsculas y admite 0x.
5. 05Pistas, respuestas y progreso«Pista» da una idea y «Ver respuesta» muestra una respuesta de referencia que se puede rellenar; el progreso se guarda en el navegador local y ?lesson=n lleva directo a un nivel.

El nivel 9, «Completa a dos», pide escribir el complemento a dos de -5 en 8 bits:

El nivel 16, «Campos IEEE 754», acepta 0,15625 y el panel muestra:

Valor absoluto   5        0 0 0 0 0 1 0 1
Negación bit a bit        1 1 1 1 1 0 1 0
Más uno                   1 1 1 1 1 0 1 1      ← respuesta 11111011
Comprobación     sin signo 251; con signo 251 − 256 = −5   ✓

0.15625 = 0.00101₂ = 1.01₂ × 2⁻³
Signo  0
Exponente  −3 + 127 = 124 = 01111100      ← respuesta 124
Mantisa  01000000000000000000000 (1 inicial implícito)
32 bits 0 01111100 01000000000000000000000 = 0x3E200000

Niveles 1–2: pesos posicionales y conversión

Cualquier base es una «suma de pesos posicionales». En decimal, 203 = 2×100 + 0×10 + 3×1; en binario, 1011 = 1×8 + 0×4 + 1×2 + 1×1 = 11. De derecha a izquierda los pesos son 1, 2, 4, 8, 16, 32, 64, 128…: pasar de binario a decimal es sumar los pesos de los bits que valen 1, y pasar de decimal a binario, dividir entre 2 y anotar los restos, o restar de mayor a menor las potencias de 2 (los interruptores del nivel 7 son justo eso, visualizado).

Nivel 3: por qué 1.024

$2^{10} = 1024$ es solo un 2,4 % más que 1000, y por eso en los primeros tiempos se usaba KB para 1.024 bytes. De ahí viene una confusión que sigue viva: los fabricantes de discos etiquetan 1 GB como $10^9$ y los sistemas operativos calculan con $2^{30}$, así que un disco de 500 GB aparece como 465 GiB. Para arreglarlo, la IEC definió KiB, MiB y GiB (prefijos binarios); Linux y macOS ya los van adoptando, mientras Windows sigue mostrando GB aunque calcule GiB. Merece la pena memorizar unos cuantos números: $2^8 = 256$, $2^{10} = 1024$, $2^{16} = 65536$ y $2^{32} \approx 4.29 \times 10^9$.

Niveles 4–6: hexadecimal y octal

El binario es demasiado largo para leerlo con la vista. El hexadecimal (0–9 más A–F) representa 4 bits con un solo símbolo, justo dos por byte: 11111111 = FF, 10110110 = B6. No hace falta pasar por el decimal: basta con cortar el binario en bloques de 4 bits de derecha a izquierda y consultar la tabla, que es lo que se practica en el nivel 5. El octal representa 3 bits por símbolo y se usó en máquinas de 12, 24 y 36 bits; hoy sobrevive sobre todo en los permisos de Linux (755) y en el escape \012 de C. En el código, los prefijos son 0x para hexadecimal, 0o para octal y 0b para binario.

Nivel 7: el bit es un interruptor

Cada entero no negativo tiene una única escritura binaria, así que un número de 8 bits sirve como 8 interruptores independientes (bits de bandera): flags = READ | WRITE, if (flags & EXEC). El font-weight de CSS, los permisos de archivos de Unix o los campos de banderas de las cabeceras de red se empaquetan así. En el nivel 7 hay que componer 200 solo con clics en los interruptores: de mayor a menor, 200 ≥ 128 (se enciende), quedan 72 ≥ 64 (se enciende), quedan 8 = 2³ (se enciende) y sale 11001000.

Niveles 8–9: complemento a dos

¿Cómo se guarda un número negativo? Lo intuitivo es reservar un bit para el signo, pero así habría dos ceros («+0» y «−0») y el circuito de suma tendría que distinguir casos. El complemento a dos (two's complement) establece que el bit más alto vale 1 en los negativos y que el valor es el valor sin signo menos $2^n$. En 8 bits, 11111111 es 255 y también 255 − 256 = −1; 10000000 es −128. Para hallar el complemento a dos de un número negativo: escribe su valor absoluto, niega todos los bits y suma uno; −5 es 00000101 → 11111010 → 11111011.

La elegancia del complemento a dos es que la suma no necesita saber el signo: −5 + 5 = 11111011 + 00000101 = 1 00000000, y al descartar el acarreo del noveno bit queda exactamente 0. La resta se convierte así en «sumar el complemento» y la CPU solo necesita un sumador. El rango de 8 bits en complemento a dos va de −128 a 127: hay un negativo más que positivos, porque el 0 ocupa un hueco del lado positivo.

Nivel 10: desbordamiento

El ancho es finito y, si te pasas dándole vueltas, vuelves al principio. En int8, 127 = 01111111, y al sumar uno sale 10000000, que en complemento a dos se lee como −128. Los desbordamientos en C, Java y Go ocurren así, en silencio; en JavaScript el Number normal es de coma flotante y no se desborda, pero Int8Array, |0 y todas las operaciones de bits funcionan en complemento a dos de 32 bits, y (2 ** 31) | 0 da −2147483648. El famoso problema del año 2038 es un contador de segundos de 32 bits con signo que se desborda a negativo el 2038-01-19 03:14:07 UTC; lo de los juegos antiguos con «puntuación que se vuelve negativa» o «monedas a cero» es exactamente lo mismo.

Niveles 11–13: AND, OR y XOR

Las tres operaciones lógicas bit a bit tienen usos fijos:

«Apagar» un bit es la combinación de AND con NOT: flags & ~FLAG. Las dos identidades del XOR, $x \oplus x = 0$ y $x \oplus 0 = x$, son el origen de todos sus usos: a ^= b; b ^= a; a ^= b intercambia dos números, y para encontrar el único elemento que aparece un número impar de veces en un array basta con ir aplicando XOR a todos.

Nivel 14: desplazamientos

Desplazar a la izquierda n bits es multiplicar por $2^n$ (los bits bajos se rellenan con 0), y desplazar a la derecha equivale a dividir entre $2^n$ redondeando hacia abajo. 5 << 3 = 101000 = 40. Desplazar es la multiplicación y la división más barata, pero el uso más frecuente es empaquetar campos pequeños en un entero: (r << 16) | (g << 8) | b junta tres valores de 0 a 255 en un color de 24 bits, y a la inversa (rgb >> 8) & 0xFF saca el verde. Ojo: hay dos desplazamientos a la derecha; el aritmético >> conserva el bit de signo (un negativo sigue siendo negativo) y el lógico >>> rellena con 0. En JavaScript los desplazamientos se hacen en 32 bits: 1 << 31 da −2147483648 y 1 << 32 es como 1 << 0 = 1, porque la cantidad se toma módulo 32.

Nivel 15: chmod 755

Los permisos de archivo de Linux son 9 bits: tres para el propietario, tres para el grupo y tres para el resto, y en cada grupo lectura r = 4, escritura w = 2 y ejecución x = 1. La suma de cada trío es un dígito octal: rwxr-xr-x = 7, 5, 5 → 755; rw-r--r-- = 644. Es el uso más directo de los pesos posicionales y las máscaras en el día a día: chmod u+x es un OR con 0o100 y chmod o-w es un AND con ~0o002. Delante pueden aparecer más bits (el 10–12: setuid, setgid y sticky), y por eso a veces se ve un número de cuatro cifras como 4755.

Nivel 16: los tres campos de IEEE 754

Un flotante es la notación científica del binario:

En precisión simple, 32 bits = 1 de signo s + 8 de exponente e (sesgo 127) + 23 de mantisa f; en doble precisión, 64 bits = 1 + 11 (sesgo 1023) + 52. La mantisa solo guarda la parte fraccionaria: el 1 de la parte entera va implícito y se gana un bit de precisión gratis. El exponente se guarda con sesgo para que comparar flotantes bit a bit sea monótono igual que con enteros. 0,15625 = $0.00101_2$ = $1.01_2 \times 2^{-3}$; el campo del exponente es −3 + 127 = 124 = 01111100, y el de la mantisa es 01 seguido de ceros.

Algunas codificaciones especiales: exponente todo 0 es subnormal (valores extremadamente próximos a 0 y ±0); exponente todo 1 con mantisa todo 0 es ±∞; exponente todo 1 con mantisa distinta de 0 es NaN. Por eso 0/0 es NaN y 1/0 es Infinity, y por eso NaN tiene muchos patrones de bits y todos «distintos de sí mismos».

Nivel 17: 0,1 + 0,2

Una fracción binaria solo puede representar con exactitud sumas de potencias negativas de 2: 0,5, 0,25, 0,125… $\tfrac{1}{10}$ en binario es un decimal periódico infinito $0.0\overline{0011}$ y la mantisa de 52 bits tiene que redondear. Así, el 0,1 de doble precisión es exactamente

un poco mayor que 0,1; el 0,2 también queda algo por encima; al sumarlos y redondear sale 0,3000000000000000444…, mientras que el valor de doble precisión más cercano al literal 0,3 es 0,29999999999999998889…: dos números binarios distintos, así que 0.1 + 0.2 === 0.3 es false. No es un bug de JavaScript: cualquier lenguaje con IEEE 754 (Python, Java, C, Go) hace lo mismo.

La solución depende del caso: para dinero, usa céntimos enteros o una biblioteca decimal (decimal, BigDecimal, Decimal.js); para comparar, usa un margen Math.abs(a − b) < ε; para mostrar, redondea solo al final con toFixed(2); para contar, usa enteros, porque la doble precisión representa exactamente todos los enteros hasta $\pm 2^{53}$ y a partir de ahí toca BigInt. La pregunta de opción múltiple del último nivel, «¿el 0,1 guardado es mayor o menor que el valor real?», se responde «mayor»: basta mirar los 55511… a partir del dígito 18 del desarrollo exacto.

Ancho de bits

el panel de valor admite 8 / 16 / 32 bits; no cubre enteros de 64 bits ni operaciones de bits con BigInt.

Coma flotante

solo trata el diseño de campos de IEEE 754 binary32 / binary64 y su desarrollo decimal exacto; no explica modos de redondeo, el rendimiento de los subnormales, Math.fround ni media precisión o bfloat16.

Semántica de las operaciones de bits

los desplazamientos se explican según JavaScript (32 bits con signo); en C, desplazar a la izquierda un negativo o desplazar más que el ancho es comportamiento indefinido y el curso no lo desarrolla.

Bits de permisos

solo los 9 bits básicos y su representación octal; setuid, setgid, sticky y las ACL se mencionan en el texto, pero el panel no los ofrece.

Evaluación

las respuestas numéricas se comparan exactamente; el binario admite ceros a la izquierda (salvo en los niveles marcados como «8 bits»); el hexadecimal no distingue mayúsculas y admite 0x.

Lo que no hace

no es un conversor por lotes (para datos reales usa «Conversor de bases» o «Calculadora chmod»), no analiza errores de coma flotante ni entra en implementaciones a nivel de instrucciones de CPU.

• «1 KB = 1000 bytes» o «= 1024 bytes»: se usan las dos. Los discos y las redes van con 1000; la memoria y los sistemas operativos suelen ir con 1024 (lo que la IEC llama KiB). Mira el contexto o si aparece una i.
• «Un negativo es un positivo con el bit más alto a 1»: eso es el «signo-magnitud», y casi ningún hardware lo guarda así. En complemento a dos, 10000000 es −128 y no −0; el −1 es todo unos.
• «>> es dividir entre 2»: con negativos redondea hacia abajo, no hacia cero: −5 >> 1 da −3 y Math.trunc(−5 / 2) da −2.
• «Los flotantes son imprecisos»: cada flotante es exactamente igual a una fracción binaria; lo impreciso es la conversión de decimal a binario. 0,5, 0,25 y 3,0 son exactos.
• «Con toFixed ya se arreglan los importes»: toFixed solo redondea al mostrar, y el error de las operaciones intermedias ya se ha acumulado; el dinero debe tratarse con céntimos enteros desde el principio.
• «JavaScript no tiene enteros, así que no hay desbordamiento»: los desplazamientos, Int32Array y | 0 funcionan en complemento a dos de 32 bits y se desbordan; un Number pierde precisión entera por encima de $2^{53}$.

El curso funciona por completo en local: la conversión de bases, las operaciones de bits, el desglose de campos de coma flotante y los desarrollos exactos son cálculos puros dentro de la página, sin peticiones al servidor; el progreso se guarda en el localStorage del equipo.

• IEEE, IEEE 754-2019, IEEE Standard for Floating-Point Arithmetic — diseño de campos, sesgos, valores especiales y reglas de redondeo de binary32 / binary64: https://standards.ieee.org/ieee/754/6210/(consultado el 2026-09-09)
• David Goldberg, What Every Computer Scientist Should Know About Floating-Point Arithmetic, ACM Computing Surveys 23(1), 1991 — el artículo clásico sobre el error de redondeo, los desarrollos exactos y «por qué 0,1 no se guarda con precisión»: https://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html(consultado el 2026-09-09)
• ECMA-262, ECMAScript Language Specification, el tipo Number y las operaciones abstractas ToInt32 / ToUint32 — la base normativa de que las operaciones de bits de JavaScript se hagan en complemento a dos de 32 bits: https://tc39.es/ecma262/#sec-ecmascript-language-types-number-type(consultado el 2026-09-09)
• IEEE / The Open Group, POSIX.1-2024, la herramienta chmod — definición de los modos simbólico y octal: https://pubs.opengroup.org/onlinepubs/9799919799/utilities/chmod.html(consultado el 2026-09-09)
• IEC 80000-13:2008, Quantities and units — Part 13: Information science and technology — definición de los prefijos binarios KiB / MiB / GiB: https://www.iso.org/standard/31898.html(consultado el 2026-09-09)
• Charles Petzold, Code: The Hidden Language of Computer Hardware and Software, 2.ª ed., Microsoft Press, 2022 — una explicación divulgativa desde los interruptores al sumador y al complemento a dos.