title: Nibble
text: # Nibble
  
  En arquitectura de computadoras, se conoce como nibble, semiocteto, cuarteto o medio-byte a un conjunto de cuatro dígitos binarios (bits) o medio octeto.
  
  Su interés se debe a que cada cifra en hexadecimal (0, 1, 2,..., 9, A, B, C, D, E, F) se puede representar con un cuarteto, puesto que 2 elevado a la 4 es 16 $(2^4=16).$ También el cuarteto es la base del sistema de codificación BCD.
  
  Las arquitecturas que emplean cuatro bits como su unidad fundamental fueron usadas para la creación de los primeros microprocesadores y las calculadoras de bolsillo.
  
  ## Ejemplo
  
  A continuación se muestra la correspondencia entre las 16 cifras hexadecimales y sus correspondientes representaciones binarias en forma de cuarteto $(_{hex}$ = hexadecimal, $_{oct}$ = octal, $_{dec}$ = decimal):
  
  | $0_{hex}$ | = | $0_{dec}$ | = | $0_{oct}$ | 0 | 0 | 0 | 0 |
  | - | - | - | - | - | - | - | - | - |
  | $1_{hex}$ | = | $1_{dec}$ | = | $1_{oct}$ | 0 | 0 | 0 | 1 |
  | $2_{hex}$ | = | $2_{dec}$ | = | $2_{oct}$ | 0 | 0 | 1 | 0 |
  | $3_{hex}$ | = | $3_{dec}$ | = | $3_{oct}$ | 0 | 0 | 1 | 1 |
  | $4_{hex}$ | = | $4_{dec}$ | = | $4_{oct}$ | 0 | 1 | 0 | 0 |
  | $5_{hex}$ | = | $5_{dec}$ | = | $5_{oct}$ | 0 | 1 | 0 | 1 |
  | $6_{hex}$ | = | $6_{dec}$ | = | $6_{oct}$ | 0 | 1 | 1 | 0 |
  | $7_{hex}$ | = | $7_{dec}$ | = | $7_{oct}$ | 0 | 1 | 1 | 1 |
  | $8_{hex}$ | = | $8_{dec}$ | = | $10_{oct}$ | 1 | 0 | 0 | 0 |
  | $9_{hex}$ | = | $9_{dec}$ | = | $11_{oct}$ | 1 | 0 | 0 | 1 |
  | $A_{hex}$ | = | $10_{dec}$ | = | $12_{oct}$ | 1 | 0 | 1 | 0 |
  | $B_{hex}$ | = | $11_{dec}$ | = | $13_{oct}$ | 1 | 0 | 1 | 1 |
  | $C_{hex}$ | = | $12_{dec}$ | = | $14_{oct}$ | 1 | 1 | 0 | 0 |
  | $D_{hex}$ | = | $13_{dec}$ | = | $15_{oct}$ | 1 | 1 | 0 | 1 |
  | $E_{hex}$ | = | $14_{dec}$ | = | $16_{oct}$ | 1 | 1 | 1 | 0 |
  | $F_{hex}$ | = | $15_{dec}$ | = | $17_{oct}$ | 1 | 1 | 1 | 1 |
  
  De acuerdo con la anterior correspondencia, es posible codificar números decimales o hexadecimales en decimal codificado en binario según se muestra en los siguientes ejemplos:
  
  * 0110 1101= 6D (decimal = 109);
  * 0001 0001 0010 = 112 (decimal = 274);
  * 0101 1001 0001 0000 0111 = 5 9107 (decimal = 364807);
  
  Un byte completo está representado por dos dígitos hexadecimales, por tanto, es común visualizar un byte de información como dos nibbles. El nibble a menudo se llama semi-octeto o cuarteto en un contexto de redes o telecomunicaciones. En inglés hay un juego de palabras gastronómico con nibble (que significa mordisqueo), en comparación con bite/byte (bocado) y bit (trozo pequeño).
  
  El nibble se utiliza para describir la cantidad de memoria utilizada para almacenar un dígito de un número almacenado en BCD en una mainframe de IBM. Esta técnica se utiliza para reducir los requisitos de espacio, haciendo la computación más rápida y la depuración más sencilla. Un byte de 8 bits es dividido en mitades y cada nibble se utiliza para almacenar un dígito. El último nibble de la variable se reserva para el signo. Así una variable que puede almacenar más de nueve dígitos se "empaquetaría" en 5 bytes. Fácil de depurar resultaban los números que son legibles en un hex dump, donde dos números hexadecimales se utilizan para representar el valor de un byte, ya que 16×16 = $2^8$ = 256.
  
  Históricamente, ha habido casos donde el término "nybble" se ha utilizado para un conjunto de bits inferior a 8, pero no necesariamente 4. En la línea Apple II, muchos de los drivers de control de disco se implementaron en software. La escritura de datos en disco se hizo convirtiendo páginas de 256 bytes en conjuntos de 5 bits, o después en nibbles de 6 bits . Los datos cargados del disco necesitaban lo contrario. Hay que notar que el término byte también tiene esta ambigüedad, a la vez, byte significa un conjunto de bits pero no necesariamente 8.
  
  Hoy, los términos byte y nibble generalmente se refieren a colecciones de 8 y 4 bits respectivamente y no se utilizan a menudo para otros tamaños. El nibble se usa también cuando aparecen los primeros microprocesadores a principios de los años 1970, ya que dichos dispositivos trabajaban con microinstrucciones las cuales estaban constituidas por grupos de 4 bits. Sin embargo, cuando llega la comercialización de los microprocesadores, estos ya pueden trabajar con grupos de 8 bits y es así como inicia la popularidad del byte en el ámbito de los sistemas digitales y de la informática. En algunos lenguajes, un nibble es llamado un tetrade —del griego tetra ("cuatro")—. Esta utilización refleja el número de bits —cuatro— en medio byte (considerando 1 byte = 8 bits).
  
  