Foundations — Endianness (big vs little)

Before you can even ask "big-endian or little-endian?", you must already be fluent in a small pile of ideas that the parent note quietly assumes: what a bit is, what a byte is, what an address is, what significance means, and what that scary-looking $256^k$ actually counts. This page builds every one of them from nothing, in order, each on top of the last.

1. The bit — the smallest yes/no

We need the bit because it is the atom of all digital storage. Everything above — bytes, numbers, addresses — is just a group of bits with an agreed meaning.

Figure 1 shows two switches side by side: the teal one down (value $0$, off) and the orange one up (value $1$, on). Read it as the visual definition of a bit — only two states exist, with nothing in between.

2. The byte — eight bits packed together

Why $256$? Each of the 8 bits doubles the number of patterns: $2\times 2\times \dots$ (eight times) $=2^8=256$. Look at the strip of 8 switches below — every distinct arrangement is one value.

The byte matters because it is the smallest chunk memory actually hands you. You never fetch a single bit from memory; you fetch whole bytes. This is exactly why endianness exists — a big number must be split into bytes, not bits.

Figure 2 draws one byte as a row of 8 coloured switches set to the pattern 00010010. Orange switches are $1$, teal are $0$; below each you see its bit number ($7$ on the far left down to $0$ on the far right, matching the numbering just defined). That exact pattern is the value we will meet again as 0x12. Use the figure to see that "one byte = eight ordered on/off cells".

3. Hexadecimal — writing bytes without pain

Why does two hex digits equal one byte? Because $16\times 16=256$ — exactly the number of patterns in a byte. One hex digit covers one nibble ($4$ bits), so two hex digits cover both nibbles ($8$ bits).

We need hex because the parent note writes values like 0x12345678 — that's just 4 bytes (12, 34, 56, 78), each a pair of hex digits. Hex makes the byte boundaries visible at a glance.

4. Significance — which digit is worth more

For 0x12345678, the 12 on the far left is the MSB (worth the most) and the 78 on the far right is the LSB (worth the least). This ordering is the whole reason "big end" vs "little end" even means something.

Figure 3 stacks the four bytes of 0x12345678 as bars whose height is their significance: the tall orange 0x12 (weighted by $256^3$) down to the short 0x78 (weighted by $256^0$). The arrow across the top reminds you significance decreases as you move right toward the LSB.

5. The power $256^k$ — why bytes are weighted by powers of 256

Why exactly $256^k$ and not something else? Because each byte contributes $8$ bits, and $2^8=256$. Stacking $k$ bytes below a byte multiplies that byte's value by $256$ exactly $k$ times — that is $256^k$. Note $256^0=1$ (any number to the power $0$ is $1$), so the LSB is weighted by $1$: it truly is the "ones" byte.

6. The floor and mod tools — pulling ONE byte out

The parent's key formula is $b_k=\lfloor V/256^k\rfloor \mathrm{mod}256$. Two new symbols appear here; both answer a precise question.

Why these two, and why together? To grab byte number $k$ you need to (1) shift away the $k$ bytes below it, then (2) keep only the single byte on the bottom:

• Dividing by $256^k$ slides byte $k$ down to the "ones" position — but leaves higher bytes stuck on top. floor cleans off any fractional leftovers so we have a clean whole number.
• mod 256 then chops off everything above the bottom byte — because $256$ is exactly one byte's worth of values.

7. The address — a numbered slot in memory

With $A$ and $i$ pinned down, the parent's two rules read cleanly ($N$ is the number of bytes in the value, $N=4$ for a 32-bit integer):

• Little-endian: $\text{mem}[i]=b_i$ (byte $i$ goes to offset $i$ — straight copy, so $\text{mem}[0]=b_0=$ LSB at address $A$).
• Big-endian: $\text{mem}[i]=b_{N-1-i}$ (the index is reversed, so the biggest byte lands at offset $0$, i.e. address $A$).

8. Beyond two: are big and little the only orders?

Prerequisite map

Equipment checklist

Cover the right side and answer out loud — if any stalls, re-read that section before the main note.

Connections

• Parent: Endianness (big vs little) — these foundations feed straight into it.
• Data Representation — where $V=\sum b_{k}256^k$ comes from.
• Memory Addressing — supplies the numbered-slot model behind $A$ and $\text{mem}[i]$.
• Bitwise Operations — the floor/mod extraction is done in practice with shifts and masks.
• Pointers and Type Punning — reads individual bytes at chosen addresses.
• Network Protocols — the reason two conventions ever meet.