Every binary place is a power of two — filled bars are the ones your number actually uses. That's all binary is: a checklist of which powers of two to add.
Why some tidy decimals repeat forever in binary: a fraction terminates in base 2 only if its denominator is a pure power of two. One tenth is 1/10 = 1/(2·5) — that stray 5 condemns 0.1 to the infinite tail 0.0(0011), which is the seed of the most famous bug-that-isn't in computing (the Inside a Float tab tells the whole story). Our hexadecimal, octal, and duodecimal converters play the same game in their own bases — and the negabinary converter plays it in base −2, where even negative numbers need no minus sign.
Convert decimal to binary exactly — negative numbers, fractions with repeating binary digits detected and bracketed, arbitrarily large integers, with hexadecimal and octal equivalents and worked division steps.
Each 1 in your number claims its power of two; each 0 declines. Add the claimed bars and you have the decimal value — place value is the whole trick.
The three-bit shortcut families: binary groups perfectly into octal (3 bits per digit) and hexadecimal (4 bits per digit), which is why programmers rarely read long bit strings raw — 1101.101 chunks into D.A hex or 15.5 octal at a glance, no arithmetic required. The grouping works because 8 and 16 are powers of 2; decimal, stubbornly 2·5, never gets a shortcut.
Convert binary to decimal with exact fractions — place-value expansion shown digit by digit, the value as a reduced fraction, and instant hexadecimal and octal equivalents.
Every bit pattern, read as unsigned (left to right) against its signed meaning: the top half counts up normally, then the cliff — the next pattern after the biggest positive is the most negative. Your number is the glowing dot.
Why two's complement won: sign-magnitude and one's complement both have two zeros (+0 and −0) and need special-case circuitry for subtraction. Two's complement has one zero, and addition just works — the same adder circuit handles positives and negatives because the encoding is arithmetic modulo 2n. The price is the famous cliff: add 1 to the biggest positive and you land at the most negative, the overflow behind countless bugs — including the original Y2K38 problem, when 32-bit Unix time runs off its cliff in January 2038.
Two's complement converter and lab — negative decimals to binary at 4, 8, 16 and 32 bits, one's complement and sign-magnitude compared, unsigned reinterpretation, ranges, and the overflow wraparound.
Floating point means the representable numbers spread out as they grow — near 1 the gap is about 2×10⁻¹⁶, but past 2⁵³ (~9 quadrillion) the gap exceeds 1 and whole integers start going missing. This is why money should never live in floats.
The most famous "bug" that isn't: 0.1 + 0.2 = 0.30000000000000004. Neither 0.1 nor 0.2 exists as a double — the machine stores 0.1000000000000000055511151231257827… and 0.2000000000000000111022302462515654…, their exact sum lands between two representable doubles, and rounding picks the one that prints as 0.30000000000000004. Every step is correct; only the expectation was decimal. It's the repeating-binary tail from the first tab, arriving with a 53-bit haircut.
IEEE 754 double-precision anatomy — sign, exponent and mantissa bits decoded, the exact decimal value actually stored, storage error, subnormals and specials, and why 0.1 plus 0.2 is not 0.3.
The byte values behind the message — classic ASCII lives below 128; anything taller is multi-byte UTF-8 at work (accents, symbols, emoji).
The single most elegant bit in ASCII: uppercase and lowercase letters differ by exactly one bit — bit 5, worth 32. 'A' is 01000001, 'a' is 01100001 — so case-insensitive comparison is just ignoring one bit, a trick from 1963 still humming in every server. And a modern honesty note: one on-screen character isn't one byte anymore — 'é' takes two, '€' three, most emoji four (and some, like family emoji, are several characters glued together). The Characters and Bytes stats above will disagree the moment you type one.
Text to binary and binary to text via UTF-8 — per-character code points and byte breakdowns, ASCII compatibility check, and the one-bit uppercase trick.