Explain binary, decimal and hexadecimal. How do you convert between them, and why do developers use hexadecimal so often?

1. Place values side by side

position:     7    6    5    4    3    2    1    0
binary:     128   64   32   16    8    4    2    1      (2^n)
hex:          -    -    -    - 4096  256   16    1      (16^n)
decimal:  10^7 ...                1000  100   10    1      (10^n)

2. Worked conversions

Decimal 202 to binary (divide by 2, read remainders bottom-up):

202 / 2 = 101 r0
101 / 2 =  50 r1
 50 / 2 =  25 r0
 25 / 2 =  12 r1
 12 / 2 =   6 r0
  6 / 2 =   3 r0
  3 / 2 =   1 r1
  1 / 2 =   0 r1      ->  1100 1010

Binary to hex (group in fours): 1100 1010 → C A → 0xCA. Hex to decimal: 0xCA = 12×16 + 10 = 202.

3. The nibble table to memorise

4. Useful powers of two

Note the difference between KB (1,000 bytes) and KiB (1,024 bytes). Disk vendors use KB/MB/GB; Windows Explorer and many tools show KiB/MiB/GiB values with KB/MB/GB labels.

5. Hex as a debugging tool

Hex keeps byte boundaries visible, so patterns jump out that decimal hides.

Example: an upload API rejected some "PDF" files. A hex dump of the first bytes showed 50 4B 03 04: they were Word documents renamed to .pdf. Checking the signature instead of the file extension fixed the validation, and also closed a hole where any file type could be uploaded with a .pdf name.

6. Hex in real artefacts

• GUID: 3F2504E0-4F89-11D3-9A0C-0305E82C3301 is 16 bytes in hex (with mixed byte order in the first three groups; see the endianness question).
• HRESULT: 0x80070002 means a Win32 error (facility 7) with code 2, "file not found".
• Hex dump: offset, 16 bytes in hex, then the printable ASCII characters. This is how you inspect files and network packets.

7. Octal, briefly

Base 8 (three bits per digit) still appears in Unix file permissions: chmod 755 means rwx r-x r-x. C# has no octal literal; use Convert.ToInt32("755", 8) or UnixFileMode flags.

8. Why built-in conversions beat hand-written ones

• Convert.FromHexString rejects odd-length strings and invalid characters with a FormatException; hand-written parsers often accept garbage silently, which matters when parsing untrusted input such as tokens or signatures.
• Convert.ToHexString is vectorised and allocates once; string concatenation in a loop is slow and allocation-heavy.
• For single values where bad input is expected, use int.TryParse(text, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var value) instead of catching exceptions.

9. Try it yourself

1. Convert 173 to binary and hex by hand, then check with 173.ToString("B8") and 173.ToString("X2").
2. Compute the SHA-256 of "hello" with SHA256.HashData and print it with Convert.ToHexStringLower. Count the characters (64) and explain why.
3. Write a tiny hex-dump tool that prints a file 16 bytes per line with offsets, then run it on a UTF-8 text file containing é and spot the two-byte sequence C3 A9.
4. Run the same tool on a .docx and a .pdf and identify each from its first four bytes.

namespace NumberSystems;

using System.Globalization;
using System.Security.Cryptography;
using System.Text;

public static class Program
{
    public static void Main()
    {
        int value = 0b1100_1010;                    // binary literal with a digit separator
        Console.WriteLine(value);                   // 202
        Console.WriteLine(value.ToString("X2"));    // CA
        Console.WriteLine(value.ToString("x2"));    // ca
        Console.WriteLine(value.ToString("B8"));    // 11001010

        bool ok = int.TryParse("CA", NumberStyles.HexNumber, CultureInfo.InvariantCulture, out int fromHex);
        int fromBinary = Convert.ToInt32("11001010", 2);
        Console.WriteLine(ok && fromHex == fromBinary);  // True

        // A hex literal above int.MaxValue is a uint
        uint mask = 0x80000000;
        int asInt = unchecked((int)mask);           // -2147483648: same bits, different meaning
        Console.WriteLine($"{mask} {asInt}");

        byte[] hash = SHA256.HashData(Encoding.UTF8.GetBytes("hello"));
        Console.WriteLine(Convert.ToHexStringLower(hash)); // 64 hex chars

        // Compare secrets as bytes, in constant time, not as hex strings
        byte[] received = Convert.FromHexString(Convert.ToHexString(hash));
        Console.WriteLine(CryptographicOperations.FixedTimeEquals(hash, received)); // True

        HexDump(Encoding.UTF8.GetBytes("Café ☕"));
    }

    private static void HexDump(ReadOnlySpan<byte> data)
    {
        for (var offset = 0; offset < data.Length; offset += 16)
        {
            var line = data.Slice(offset, Math.Min(16, data.Length - offset));
            var hex = new StringBuilder();
            var text = new StringBuilder();
            foreach (var b in line)
            {
                hex.Append(b.ToString("X2")).Append(' ');
                text.Append(b is >= 0x20 and < 0x7F ? (char)b : '.');
            }
            Console.WriteLine($"{offset:X8}  {hex,-48} {text}");
        }
    }
}