Operaciones bit a bit explicadas: AND, OR, XOR, desplazamientos y máscaras

Abres una migración antigua de PostgreSQL y te encuentras con permissions & 0b100. Un compañero despliega un sistema de feature flags que empaqueta 32 booleanos en un solo entero. Un cálculo de subred en Kubernetes escupe 192.168.1.0/24 y necesitas extraer la dirección de red en código. Tres situaciones, una misma habilidad de base: las operaciones bit a bit.

La mayoría de desarrolladores de capa aplicación nunca toca & o ^ en una webapp, hasta que de repente sí. Esta guía recorre los seis operadores bit a bit, el complemento a dos, los nueve patrones que conviene memorizar y las trampas concretas de cada lenguaje (sobre todo de JavaScript). Código en JS, Python, Go y C, con cada ejemplo ejecutable.

Abre nuestro Convertidor de base en otra pestaña: varias secciones te invitan a teclear un número y ver cómo cambia el patrón binario.

Por qué las operaciones bit a bit siguen importando en 2026

Los lenguajes de alto nivel no han vuelto obsoletas las operaciones bit a bit. Solo han escondido dónde ocurren. Algunos sitios donde hoy dependes de ellas, lo sepas o no:

• Row-Level Security de PostgreSQL guarda privilegios ACL (SELECT, INSERT, UPDATE, DELETE…) en un bitmap entero.
• Las capabilities de Linux reemplazan el viejo modelo root-o-nada con más de 40 bits de permiso que se combinan con |.
• Las cabeceras de algoritmo JWT codifican el hash en un campo pequeño donde la comparación a nivel de bit es habitual en la capa librería.
• Snowflake, ULID y UUIDv7 empaquetan timestamp, ID de máquina y secuencia en un entero de 64 o 128 bits mediante desplazamientos a la izquierda.
• BITCOUNT y BITOP de Redis exponen primitivas bit a bit directamente al código de aplicación para estimación de cardinalidad y A/B bucketing.
• El procesamiento de imagen lee píxeles RGBA de 32 bits y extrae canales con & y >>.

Las operaciones bit a bit siguen siendo O(1) al nivel de instrucción de CPU. Empaquetar 32 booleanos en un entero ahorra 31 bytes de memoria y, sobre todo, permite comprobar “si alguno de estos 32 flags está activado” con una sola prueba != 0.

Un apunte cercano para equipos hispanohablantes: el DNIe español y varios esquemas de firma electrónica del ecosistema europeo (eIDAS) guardan los keyUsage y extendedKeyUsage de los certificados X.509 como campos de bits (BIT STRING en ASN.1). Cada bit corresponde a un uso permitido: firma digital, cifrado de clave, autenticación de cliente. Validar un certificado es, en el fondo, una serie de & contra la máscara esperada.

Fundamentos binarios que debes tener claros

Esta guía asume que ya entiendes binario. Si necesitas repasar, lee primero nuestra Guía de conversión entre bases y vuelve.

Un glosario rápido antes de empezar:

• Un bit es 0 o 1.
• Un nibble son 4 bits (un dígito hexadecimal).
• Un byte son 8 bits.
• Una palabra son típicamente 32 o 64 bits según la CPU.

Los enteros en la mayoría de lenguajes tienen anchura fija: 8, 16, 32 o 64. La anchura importa mucho en operaciones bit a bit, porque los desplazamientos pueden empujar bits fuera del borde y el bit de signo vive en la posición más a la izquierda de los enteros con signo.

Pruébalo ahora: abre el Convertidor de base, introduce 170 como decimal y mira la salida binaria. Deberías ver 10101010, un patrón alterno al que volveremos varias veces.

Los seis operadores bit a bit

Todo lenguaje mainstream te da los mismos seis operadores con pequeñas variaciones sintácticas. &, |, ^, ~, << y >> funcionan igual en JavaScript, Python, Go, Rust, C, C++, Java y C#. JavaScript añade uno más: >>>, el desplazamiento a la derecha sin signo.

AND (&): filtro de bits

El bit resultante vale 1 solo si los dos bits de entrada valen 1.

A	B	A & B
0	0	0
0	1	0
1	0	0
1	1	1

Piensa en AND como una puerta: solo los bits activados en ambos operandos sobreviven. El uso más habitual es enmascarar: conservar algunos bits y poner a cero el resto.

// Extraer los 4 bits bajos (nibble de la derecha)
const value = 0b11010110;   // 214
const low4  = value & 0x0F; // 0b00000110 = 6

// Comprobar paridad
const isOdd = (n) => (n & 1) === 1;
isOdd(7);  // true
isOdd(42); // false

# Lo mismo en Python
value = 0b11010110
low4 = value & 0x0F  # 6

def is_odd(n):
    return (n & 1) == 1

OR (|): activador de bits

El bit resultante vale 1 si al menos uno de los bits de entrada vale 1.

A	B	A | B
0	0	0
0	1	1
1	0	1
1	1	1

OR combina banderas. Si READ = 1, WRITE = 2 y EXECUTE = 4, entonces READ | WRITE es 3, los dos permisos activos.

const READ  = 0b001;
const WRITE = 0b010;
const EXEC  = 0b100;

const rw = READ | WRITE;  // 0b011 = 3

READ, WRITE, EXEC = 0b001, 0b010, 0b100
rw = READ | WRITE  # 3

XOR (^): conmutador de bits

El bit resultante vale 1 cuando los bits de entrada difieren.

A	B	A ^ B
0	0	0
0	1	1
1	0	1
1	1	0

XOR tiene tres propiedades algebraicas que sostienen algunos de los trucos más ingeniosos de la computación:

• a ^ a = 0: cualquier valor XOR consigo mismo se cancela.
• a ^ 0 = a: XOR con cero es la identidad.
• a ^ b ^ a = b: XOR es su propio inverso.

La última propiedad explica por qué XOR aparece en todas partes, desde comprobaciones de paridad hasta cifrados de flujo y la conocida pregunta de entrevista “encuentra el número único en un array donde los demás aparecen dos veces”.

// Encontrar el número único en un array donde el resto aparecen dos veces
const findUnique = (arr) => arr.reduce((a, b) => a ^ b, 0);
findUnique([4, 1, 2, 1, 2]);  // 4

from functools import reduce
from operator import xor
find_unique = lambda arr: reduce(xor, arr, 0)
find_unique([4, 1, 2, 1, 2])  # 4

NOT (~): inversor de bits

El ~ unario invierte cada bit: 0 pasa a 1, y 1 pasa a 0.

~0b00001111  // -16  (JavaScript fuerza 32 bits con signo)
~5           // -6

~5  # -6

// Go usa ^ como NOT bit a bit unario; ojo con el símbolo
var x int8 = 5
fmt.Println(^x)  // -6

Que ~5 sea -6 sorprende a los principiantes en casi todos los lenguajes. La razón es el complemento a dos, que cubrimos en la siguiente sección. Por ahora basta esto: en cualquier lenguaje que use complemento a dos para negativos (es decir, todos), ~x equivale a -(x + 1).

Desplazamiento a izquierda (<<): multiplicador por potencia de 2

x << n desplaza todos los bits de x n posiciones a la izquierda y rellena con ceros a la derecha. Matemáticamente multiplica por 2ⁿ.

1 << 0   // 1    (2^0)
1 << 1   // 2    (2^1)
1 << 3   // 8    (2^3)
1 << 10  // 1024 (2^10 = 1 KiB)

// Construir flags de bits
const FLAG_ADMIN    = 1 << 0;
const FLAG_EDITOR   = 1 << 1;
const FLAG_REVIEWER = 1 << 2;

La gracia de 1 << n es que produce un número con un único bit activado en la posición n. Ese bit se convierte en bandera.

Cuidado con el desbordamiento. En JavaScript, 1 << 31 es -2147483648 (no 2147483648), porque las operaciones bit a bit en JS trabajan sobre enteros de 32 bits con signo.

Desplazamiento a derecha (>> vs >>>): ¿con signo o relleno?

El desplazamiento a la derecha mueve los bits a la derecha. La pregunta es qué llena las posiciones de la izquierda que quedan vacías:

• >> (desplazamiento aritmético) preserva el bit de signo. Los negativos siguen siendo negativos.
• >>> (desplazamiento lógico, sin signo) rellena con ceros. Solo JavaScript tiene este operador dedicado.

-8 >> 1   // -4   (signo preservado)
-8 >>> 1  // 2147483644  (el bit de signo pasa a ser dato)

8 >> 1    // 4
8 >> 2    // 2

En C, si >> sobre tipos con signo es aritmético o lógico depende de la implementación. La mayoría de compiladores hace aritmético, pero no te apoyes en ello sin comprobarlo. Go exige que la cantidad de desplazamiento sea entero sin signo y distingue con claridad entre con-signo y sin-signo. Python no tiene >>> porque no tiene enteros de anchura fija.

Complemento a dos: cómo las computadoras guardan negativos

Si los bits solo valen 0 y 1, ¿cómo codificas -5? La respuesta que se impuso en los años 60 es el complemento a dos, y toda CPU moderna lo usa.

El enfoque ingenuo, reservar un bit para el signo, tiene dos problemas. Primero, acabas con +0 y -0, que es incómodo. Segundo, los circuitos de suma y resta tienen que comprobar el bit de signo, lo que complica el hardware. El complemento a dos resuelve ambos.

La regla es corta:

1. Toma la representación binaria positiva.
2. Invierte cada bit (eso es el “complemento a uno”).
3. Suma 1.

Ejemplo trabajado: codificar -5 en complemento a dos de 8 bits.

 5 en binario:           0000 0101
 invertir bits:          1111 1010   (¡esto es -6 en complemento a dos!)
 sumar 1:                1111 1011   ← esto es -5

Verifica con nuestro conversor: introduce 251 (decimal) en el Convertidor de base con base 10, y la salida binaria es 11111011. En contexto de 8 bits con signo, 11111011 es -5. En 8 bits sin signo, el mismo patrón es 251. Los bits son idénticos; la interpretación difiere.

Esto explica la sorpresa ~5 = -6. El NOT bit a bit produce el complemento a uno. El complemento a dos es complemento a uno más 1. Por tanto:

~x    = -(x + 1)    // válido en cualquier lenguaje con complemento a dos
~5    = -6
~(-3) = 2

Para enteros con signo de n bits, el rango representable va de -2ⁿ⁻¹ a 2ⁿ⁻¹ − 1. 8 bits con signo cubren de -128 a 127. 32 bits con signo cubren aproximadamente de -2.100 millones a +2.100 millones.

Nueve patrones de manipulación de bits que conviene memorizar

Estos nueve patrones cubren cerca del 95% de la manipulación de bits que escribirás. Memorízalos y los reconocerás por todo el código de sistemas.

Activar un bit: x | (1 << n)

Pone a 1 el bit n y deja los demás intactos.

let flags = 0b0100;
flags = flags | (1 << 0);  // 0b0101

Borrar un bit: x & ~(1 << n)

Apaga el bit n y deja los demás. ~(1 << n) es una máscara con todos los bits activos excepto n.

let flags = 0b0111;
flags = flags & ~(1 << 1);  // 0b0101

Conmutar un bit: x ^ (1 << n)

Invierte el bit n independientemente de su estado.

let flags = 0b0100;
flags = flags ^ (1 << 2);  // 0b0000
flags = flags ^ (1 << 2);  // 0b0100 de nuevo

Comprobar un bit: (x >> n) & 1

Devuelve 1 si el bit n está activo, 0 en otro caso. Una forma equivalente es (x & (1 << n)) !== 0.

const flags = 0b0101;
const isBit2Set = (flags >> 2) & 1;  // 1

Aislar el bit activo más bajo: x & -x

Produce un valor que conserva solo el 1 más a la derecha de x. Funciona porque en complemento a dos -x equivale a ~x + 1, que invierte cada bit hasta el activo más bajo (incluido).

const x = 0b10110100;
const lowest = x & -x;  // 0b00000100 = 4

Es el truco central de los árboles de Fenwick (Binary Indexed Trees) para sumas prefijas en O(log n).

Contar bits activos (popcount)

Cuenta cuántos 1 hay en un entero. La mayoría de lenguajes ya trae función nativa:

// JavaScript (versión manual)
const popcount = (n) => {
  let count = 0;
  while (n) { count += n & 1; n >>>= 1; }
  return count;
};
popcount(0b10110100);  // 4

# Python 3.10+
(0b10110100).bit_count()  # 4

// Go
import "math/bits"
bits.OnesCount(0b10110100)  // 4

Intercambio XOR sin variable temporal

Un truco clásico: intercambiar dos enteros sin una tercera variable. No lo uses en producción (es más lento que una variable temporal y se rompe si a y b apuntan a la misma memoria), pero conviene entenderlo.

let a = 5, b = 9;
a = a ^ b;  // a = 5 ^ 9
b = a ^ b;  // b = (5 ^ 9) ^ 9 = 5
a = a ^ b;  // a = (5 ^ 9) ^ 5 = 9
// a = 9, b = 5

Detectar potencia de 2: (x & (x - 1)) === 0

Una potencia de 2 tiene exactamente un bit activo. Restar 1 apaga ese bit y activa todos los inferiores. El AND da cero solo en potencias de 2 (y también en 0, por eso se añade x > 0).

const isPow2 = (x) => x > 0 && (x & (x - 1)) === 0;
isPow2(16);  // true
isPow2(17);  // false

Comprobación rápida de impar: x & 1

Más rápida que x % 2 en algunos lenguajes y equivalente tras optimización en otros. Útil en bucles calientes o cuando la legibilidad no es la prioridad.

const isOdd = (x) => (x & 1) === 1;

Banderas con máscara de bits en código real

Aquí las operaciones bit a bit dejan de ser truco y se vuelven práctica.

32 booleanos en una sola bandera de funcionalidad

En vez de una struct con 32 campos booleanos, empaquétalos en un entero:

const FLAGS = {
  DARK_MODE:      1 << 0,
  NEW_NAV:        1 << 1,
  AI_SUGGESTIONS: 1 << 2,
  BETA_EDITOR:    1 << 3,
  // ... hasta 1 << 31
};

let userFlags = 0;
userFlags |= FLAGS.DARK_MODE | FLAGS.AI_SUGGESTIONS;  // activar

if (userFlags & FLAGS.AI_SUGGESTIONS) {
  showSuggestions();
}

userFlags &= ~FLAGS.DARK_MODE;  // desactivar

Guarda 32 booleanos en 4 bytes y te permite consultar cualquier subconjunto con un único AND. A las bases de datos les encanta este patrón: una columna en vez de 32.

Permisos de archivos Unix

chmod 755 es bit a bit. Los tres dígitos octales corresponden a tres tríos de bits:

7 = 111  (propietario: rwx)
5 = 101  (grupo:       r-x)
5 = 101  (otros:       r-x)

Pruébalo: abre el Convertidor de base, fija el origen a octal, introduce 755 y observa la salida binaria 111101101. Así, literalmente, almacena el sistema de archivos el campo de permisos.

Para añadir solo “escritura para grupo”:

const perms = 0o755;
const withGroupWrite = perms | 0o020;  // 0o775

Máscara de subred IP

Dado 192.168.1.10/24, extrae la dirección de red haciendo AND con la máscara:

const ip      = 0xC0A8010A;  // 192.168.1.10
const mask    = 0xFFFFFF00;  // 255.255.255.0 (/24)
const network = ip & mask;   // 0xC0A80100 = 192.168.1.0

IDs empaquetados: Snowflake

El Snowflake de Twitter empaqueta timestamp, ID de máquina y secuencia en un entero de 64 bits:

┌─ 1 bit ─┬─── 41 bits ───┬─ 10 bits ─┬─ 12 bits ─┐
│  signo  │   timestamp   │  máquina  │    seq    │
└─────────┴───────────────┴───────────┴───────────┘

Codificar un ID son dos desplazamientos y dos OR:

const id = (BigInt(timestamp) << 22n) |
           (BigInt(machineId) << 12n) |
            BigInt(sequence);

Decodificar hace lo inverso: desplazar a la derecha y enmascarar. Para elegir entre Snowflake, ULID y UUIDv7, consulta nuestra comparativa de IDs distribuidos.

Trampas específicas de cada lenguaje

JavaScript: la trampa de la coerción a 32 bits

JavaScript convierte los operandos a enteros de 32 bits con signo antes de cada operación bit a bit, y el resultado vuelve a Number. Cualquier valor por encima de 2³¹ − 1 = 2147483647 desborda:

2147483647 | 0   // 2147483647   (aún va bien)
2147483648 | 0   // -2147483648  (¡desbordó!)
4294967295 | 0   // -1           (todos los bits a 1, interpretado con signo)

Para trabajo de 64 bits, usa BigInt: tiene operadores bit a bit propios sin límite de anchura:

(2n ** 40n) | 1n  // 1099511627777n

Bugs por precedencia de operadores

Uno de los bugs bit a bit más frecuentes en la vida real:

// Con bug: se lee (x & (1 == 0)) porque == liga más fuerte que &
if (x & 1 == 0) { /* ... */ }

// Correcto: paréntesis
if ((x & 1) == 0) { /* ... */ }

En C, JavaScript, Python, Go y sus descendientes, los operadores de comparación ligan más fuerte que AND/OR/XOR bit a bit. Si dudas, ponlo entre paréntesis.

Tabla comparativa de lenguajes

Lenguaje	Coerción de anchura	>> negativo	Soporte BigInt
JavaScript	Fuerza 32 bits con signo; >>> sin signo	aritmético	BigInt con operadores propios
Python	Precisión arbitraria, sin anchura fija	aritmético	Nativo
Go	Estricto; desplazamiento debe ser sin signo	aritmético para tipos con signo	math/big
C/C++	Sigue el tipo; int, unsigned, etc.	definido por la implementación en tipos con signo	Nada integrado
Rust	Estricto; panic por desbordamiento en debug	aritmético para tipos con signo	u128 / crates externos

El giro de anchura infinita de Python

Los enteros en Python no tienen anchura fija, así que la lógica de complemento a dos se extiende “infinitamente” hacia la izquierda. Por eso ~5 es -6 (no 250 ni 65530): Python trata el resultado como entero negativo, no como un patrón de bits de anchura fija. Si necesitas semántica de wrap-around, enmascara explícitamente:

# Simular NOT de 8 bits
(~5) & 0xFF  # 250

Reality check de rendimiento en 2026

El mito habitual dice que las operaciones bit a bit son “siempre más rápidas”. En 2026 eso es media verdad.

Los compiladores ya hacen las reescrituras obvias. Los optimizadores modernos convierten x * 2 en x << 1 automáticamente. Escribir x << 1 en código de aplicación “por velocidad” es optimización de culto: no ayuda y perjudica la legibilidad.

Dónde sí gana el código bit a bit:

• Bucles calientes numéricos: popcount, conteo de ceros iniciales o finales, motores de ajedrez con bitboards.
• Estructuras compactas: filtros de Bloom, roaring bitmaps, árboles de Fenwick.
• Registros de hardware y E/S mapeada en memoria: embebido, kernel, firmware.
• Primitivas criptográficas: AES, ChaCha20 y SHA están construidos con XOR, rotaciones y desplazamientos.
• Compresión y descompresión: Huffman, RLE, enteros empaquetados.
• Motores de bases de datos: índices bitmap y formatos columnares como Parquet con codificación de diccionario.

Dónde no ayuda: sustituir x % 2 por x & 1 en una función de lógica de negocio que se ejecuta dos veces por petición. La aceleración no es medible y el coste de legibilidad sí es real.

El único caso en el que la manipulación de bits siempre gana es el tamaño en memoria. Empaquetar 32 flags en un int ahorra 31 bytes frente a 32 booleanos. A escala (millones de registros, miles de millones de eventos) esa es la diferencia entre un layout cache-friendly y una tormenta de fallos de caché.

Chuleta rápida

Operación	Operador	Ejemplo	Resultado	Uso típico
AND	&	0b1100 & 0b1010	0b1000	Máscara/extraer
OR	|	0b1100 | 0b1010	0b1110	Combinar banderas
XOR	^	0b1100 ^ 0b1010	0b0110	Alternar/detectar diferencias
NOT	~	~0b1100	...11110011	Máscara inversa
Desplazamiento izq.	<<	1 << 3	8	Multiplicar por 2ⁿ
Desplazamiento der.	>>	16 >> 2	4	Dividir por 2ⁿ (con signo)
Despl. der. sin signo (JS)	>>>	-1 >>> 0	4294967295	Tratar como sin signo
Activar bit n	|	x | (1 << n)		Encender
Borrar bit n	& ~	x & ~(1 << n)		Apagar
Conmutar bit n	^	x ^ (1 << n)		Invertir
Probar bit n	&	(x >> n) & 1	0 o 1	Comprobar
Bit bajo aislado	& -	x & -x		Aislar
Potencia de 2	&	x > 0 && (x & (x-1)) == 0	booleano	Detectar

FAQ

¿Qué diferencia hay entre AND lógico (&&) y bit a bit (&)?

El AND lógico opera sobre valores booleanos completos y cortocircuita: false && expr nunca evalúa expr. El AND bit a bit opera sobre bits individuales de enteros y siempre evalúa ambos lados. Usa && para condiciones y & para manipular bits.

¿Por qué ~1 vale -2 en casi todos los lenguajes?

El NOT bit a bit invierte cada bit y produce el complemento a uno. En representación de complemento a dos, invertir todos los bits de x equivale a calcular -(x + 1). Así obtienes ~1 = -2, ~0 = -1 y ~(-1) = 0. Esto vale en JavaScript, C, Go, Java y cualquier lenguaje con aritmética de complemento a dos.

¿De verdad x << 1 es más rápido que x * 2?

En la práctica no lo es. Cualquier compilador moderno reconoce x * 2 y emite la misma instrucción de desplazamiento a la izquierda. Usa x * 2 por claridad cuando el contexto sea aritmético y reserva << para cuando piensas en términos de bits, como al construir una máscara, empaquetar campos o manipular flags. Legibilidad antes que micro-optimización.

¿JavaScript soporta operaciones bit a bit de 64 bits?

Con los operadores estándar &, |, ^, << y >>, no: el motor fuerza los operandos a enteros de 32 bits con signo antes de operar. Para trabajar con 64 bits o más, usa literales BigInt (por ejemplo 1n << 40n), que te dan operaciones bit a bit de precisión arbitraria sin desbordamiento silencioso. Cuidado: no puedes mezclar BigInt con Number en la misma expresión.

¿Cómo cuento bits activos eficientemente?

Usa la función nativa de tu lenguaje siempre que exista: bits.OnesCount en Go, Integer.bitCount en Java, .bit_count() en Python 3.10 o superior, e intrinsics popcount (__builtin_popcount) en C y C++. Todas se mapean a una única instrucción POPCNT en x86 y ARM modernos, mucho más rápida que un bucle manual desplazando bits.

¿Cuándo conviene usar banderas con máscara en vez de una struct de booleanos?

Usa máscaras cuando necesites almacenar muchas banderas de forma compacta (bases de datos, protocolos de red, formatos de fichero) o probar combinaciones rápido (flags & REQUIRED_MASK). Una struct, cuando los campos tengan tipos distintos o la legibilidad pese más que la memoria.

¿Qué pasa si desplazo más que la anchura del tipo?

En C/C++ es comportamiento indefinido. En JavaScript, la cantidad de desplazamiento se toma módulo 32, así que 1 << 32 es 1, no 0. En Python no hay anchura, así que 1 << 100 es sencillamente un entero mayor. No te fíes del comportamiento de sobre-desplazamiento: enmascara la cantidad tú mismo si hace falta.

¿Por qué ~5 en Python es -6 y no 2?

Los enteros de Python no tienen anchura fija, así que el complemento a dos se extiende conceptualmente al infinito. ~5 vale -(5 + 1) = -6, igual que en cualquier lenguaje con complemento a dos. Si quieres el valor “invertido” de 8 bits 250, enmascara: (~5) & 0xFF.

¿Es seguro el cifrado XOR?

Un one-time pad con clave verdaderamente aleatoria, tan larga como el mensaje, es indescifrable en teoría de la información. Reutilizar la misma clave entre mensajes es catastróficamente inseguro: el “cifrado XOR” con clave corta repetida se rompe trivialmente. Los cifrados reales como AES y ChaCha20 usan XOR dentro, pero solo como un paso entre muchos.

¿Cómo escribo a mano un negativo en complemento a dos?

Escribe el valor positivo en binario con la anchura objetivo, invierte cada bit y suma 1. Ejemplo: -5 en 8 bits = 00000101 → invertir 11111010 → sumar 1 → 11111011. Verifícalo en nuestro Convertidor de base convirtiendo 251 (la interpretación sin signo de 11111011) y confirmando que la salida binaria es 11111011.

Herramientas relacionadas y lecturas adicionales

• Convertidor de base: teclea cualquier número y observa los bits.
• Guía de conversión entre bases: lectura previa sobre binario, octal y hexadecimal.
• UUID v4 vs v7 vs ULID vs Snowflake: empaquetado de bits en IDs distribuidos.
• Mejores prácticas de seguridad: bitmaps de permisos y sus trampas.