Kilobit to Kibibyte

The iconic dial-up handshake screech was a negotiation protocol between two modems. The initial tones tested line quality; the harsh noise burst was both modems rapidly cycling through modulation schemes (V.34, V.90) to find the fastest reliable speed — typically 28.8–56 kb/s. The sounds encoded training sequences, equaliser coefficients, and error-correction parameters, all transmitted as audio tones over a voice telephone line designed for 3.4 kHz bandwidth. The entire handshake lasted 10–30 seconds and transferred only a few kilobits of control data before the connection went silent for actual data transfer.

128 kb/s is considered acceptable quality for casual listening; 192–256 kb/s is a good balance of quality and file size; 320 kb/s is the maximum MP3 bitrate and is near-indistinguishable from lossless for most listeners. At 128 kb/s, one hour of audio is roughly 57 MB; at 320 kb/s, the same hour is about 144 MB.

No. A kilobit (kb) = 1,000 bits (SI, decimal). A kibibit (Kibit) = 1,024 bits (IEC, binary). The difference is small at this scale (2.4%) but compounds into significant gaps at larger prefixes. Network and telecom equipment use decimal kilobits; some older computing hardware documentation may use the binary definition.

The fastest consumer dial-up modems reached 56 kb/s (V.90 / V.92 standard), though practical speeds were often 40–50 kb/s due to line quality. At 56 kb/s, downloading a 5 MB MP3 file took about 12 minutes. By comparison, a modern 100 Mbps broadband connection is roughly 1,800 times faster.

Common audio bitrates: voice calls use 8–64 kb/s (G.711 codec = 64 kb/s); AAC audio at 96–256 kb/s; MP3 at 128–320 kb/s; lossless FLAC at 700–1,400 kb/s depending on audio content. Streaming services like Spotify use 24 kb/s (low) to 320 kb/s (premium) for music delivery.

KB (kilobyte, SI) = 1,000 bytes. KiB (kibibyte, IEC binary) = 1,024 bytes. The difference is 24 bytes (2.4%) — small individually but the source of the well-known discrepancy between storage manufacturer labels and OS-reported sizes. Storage manufacturers use KB = 1,000 bytes; operating systems traditionally used KB = 1,024 bytes (now correctly called KiB).

Linux memory management, filesystem block sizes, and page sizes are all powers of 2 (typically 4,096 bytes = 4 KiB). Using kibibytes aligns with the physical hardware structure. The GNU coreutils (df, du, ls -h) display sizes in KiB, MiB, GiB by default for consistency with how the kernel allocates memory and disk blocks — decimal kilobytes would produce fractional values for normal aligned allocations.

Most languages expose both conventions depending on the API. Java's Runtime.totalMemory() returns bytes aligned to KiB (binary), but Files.size() returns raw byte counts that file managers may display as decimal KB. Python's os.path.getsize() returns bytes — the developer chooses how to format. Go's humanize library defaults to IEC (KiB) while many JavaScript libraries default to SI (KB). This inconsistency means the same file can appear as different sizes across tools written in different languages.

A memory page is the smallest unit of memory the OS allocates from physical RAM. Most modern CPUs use 4 KiB (4,096 byte) pages; some support 2 MiB or 1 GiB "huge pages" for performance. Every memory allocation is rounded up to the nearest page boundary. This binary alignment is why computer memory sizes are always powers of 2 (4 GB, 8 GB, 16 GB RAM) rather than round decimal numbers (5 GB, 10 GB).

The 3.5-inch floppy's capacity was 1,474,560 bytes — which is neither 1.44 MB (1,440,000 bytes) nor 1.44 MiB (1,509,949 bytes). The label came from a hybrid calculation: 80 tracks × 2 sides × 18 sectors × 512 bytes = 1,474,560 bytes, then divided by 1,000 to get 1,474.56 KB, then divided by 1,024 to get "1.44 MB." This mix of decimal and binary division in the same label is one of the most famous unit blunders in computing history.