Registers and shift registers: Visual walkthrough — Hardware deep dive

Step 1 — One flip-flop: a bit that waits for the whistle

WHAT. A single D flip-flop is a tiny box with one input we call $D$ (short for "Data-in") and one output we call $Q$ (the stored bit). It has a third pin, the clock, drawn as a little triangle. The clock ticks like a metronome: ...low, HIGH, low, HIGH.... The exact instant it flips from low to HIGH is called the active edge — think of it as a whistle blow.

WHY start so small. Everything larger is just this box, duplicated and rewired. If you understand one box perfectly, a register is "many boxes, same whistle" and a shift register is "many boxes, each fed by its neighbour". Nothing new gets invented later.

PICTURE. The blue box is the flip-flop. The yellow line is $D$ , the green line is $Q$ , and the red triangle is the clock. Watch the moment marked "whistle": only there does $Q$ jump to match $D$ .

Step 2 — Two flip-flops in a row: feed one's output into the next

WHAT. Put two boxes side by side. Call them stage 0 (left) and stage 1 (right), with outputs $Q_{0}$ and $Q_{1}$ . Now do the one wiring trick that turns storage into motion: instead of giving stage 1 its own outside input, connect $Q_{0}$ to $D_{1}$ . $D_{1} = Q_{0}$

$D_{1}$ ::: the input pin of stage 1.

$Q_{0}$ ::: the output of stage 0, now feeding stage 1.

WHY this exact wire. We want data to move one step per whistle. A flip-flop naturally copies "input now → output later". So if stage 1's input is stage 0's current value, then after the whistle stage 1 becomes what stage 0 was. The value has walked one seat to the right.

PICTURE. The yellow wire from $Q_{0}$ into $D_{1}$ is the whole idea. Before the whistle stage 0 holds a $1$ and stage 1 holds a $0$ ; after the whistle the $1$ has slid into stage 1.

Step 3 — The chain rule: $Q_{i}^{next} = Q_{i - 1}$

WHAT. Repeat the wire for a whole row of $n$ boxes: stage $i$ 's input is always the previous stage's output. $Q_{i}^{next} = Q_{i - 1} for i = 1, 2, \dots, n - 1$

$i$ ::: which stage we mean, numbered $0$ (leftmost) to $n - 1$ (rightmost).

$Q_{i - 1}$ ::: the neighbour to the left — where stage $i$ 's new value comes from.

The formula is missing one case: stage 0 has no left neighbour. That gap is Step 4.

WHY read it as "everyone shuffles right by one". Apply the rule to every stage at the same whistle: stage 1 becomes old-stage-0, stage 2 becomes old-stage-1, and so on. The entire pattern of bits rigidly slides one position. No bit is created or destroyed in the middle — motion is conserved.

PICTURE. Four boxes, the bit pattern $1011$ before, and each arrow shows exactly which value lands where after one whistle.

Step 4 — The two loose ends: Serial In and Serial Out

WHAT. Two stages have no neighbour, so the chain rule can't cover them:

Stage 0 (leftmost) has nobody on its left. We must choose what feeds it. We call that outside wire Serial In ( $S_{in}$ ): $Q_{0}^{next} = S_{in}$

Stage $n - 1$ (rightmost) has nobody on its right to hand its value to. So its old value simply exits the register. We call that departing bit Serial Out ( $S_{out}$ ): $S_{out} = Q_{n - 1} (old value, before the whistle)$

WHY these must be named. If you forget Serial In, stage 0 is fed by an undriven wire and shifts in random garbage — this is the parent note's first classic mistake. Serial In is the mouth of the pipe; Serial Out is the far end where the oldest bit "falls off". A bit put in the mouth walks the whole line and eventually drops out the other side.

PICTURE. The yellow arrow enters the leftmost box (Serial In); the red arrow leaves the rightmost box (Serial Out — the bit that falls off the cliff).

Step 5 — Watch a single bit walk the whole line ( $n$ edges)

WHAT. Put a $1$ on Serial In for exactly one whistle, then hold Serial In at $0$ . Track where that lone $1$ sits after each whistle in a 4-stage register (SISO — Serial-In, Serial-Out).

After edge	$Q_{0} Q_{1} Q_{2} Q_{3}$	Where is our $1$ ?
0 (start)	$0000$	not in yet
1	$1000$	just entered stage 0
2	$0100$	moved to stage 1
3	$0010$	stage 2
4	$0001$	stage 3 (about to exit)
5	$0000$	fell out as Serial Out

WHY it takes $n$ edges. One edge = one seat. With $n$ seats, a bit needs $n$ edges to cross from the mouth to the far end. This is the parent's "Forecast-then-Verify": a SISO register is a delay line of exactly $n$ clocks. That delay is the whole trick behind Serial communication (UART, SPI) — data can travel one wire, one bit per tick.

PICTURE. The lone yellow $1$ marches one square right per whistle, then drops off the edge at edge 5.

Step 6 — WHY a shift is ×2 or ÷2 (the arithmetic meaning)

WHAT. A binary word gives each position a weight that is a power of two. For $Q_{3} Q_{2} Q_{1} Q_{0}$ the value is $V = Q_{3} \cdot 2^{3} + Q_{2} \cdot 2^{2} + Q_{1} \cdot 2^{1} + Q_{0} \cdot 2^{0}$

$2^{i}$ ::: the weight of position $i$ — each step left doubles the weight ( $1, 2, 4, 8, \dots$ ).

Left shift moves every bit into the next higher weight, so every term's weight doubles: $V_{new} = 2 V (if nothing falls off the top)$

Right shift moves every bit into the next lower weight, halving: $V_{new} = ⌊ \frac{V}{2} ⌋$

$⌊ ⌋$ ::: "floor" = round down. It appears because the bottom bit ( $2^{0}$ ) has no lower position to go to, so it's discarded.

WHY it's exactly powers of two and not something else. Shifting doesn't change which bits are $1$ ; it only changes what each position is worth. Since positions are spaced by factors of $2$ , sliding one seat multiplies or divides the whole value by $2$ . This is the engine inside Binary multiplication and division (shift-and-add).

PICTURE. The value $0011 = 3$ shifts left to $0110 = 6$ to $1100 = 12$ — each row is double the last, drawn as the weights lighting up.

Step 7 — The edge cases: overflow and the signed trap

WHAT. Two things break the tidy ×2 / ÷2 story:

Overflow (left shift). If the top bit $Q_{n - 1}$ is a $1$ and we shift left, that $1$ falls off as Serial Out — there's no $2^{n}$ position to hold it. The result is not $2 V$ ; it's $2 V mod 2^{n}$ .

Signed right shift. For unsigned numbers, right-shift fills the vacated top with $0$ . But if the word represents a signed number (top bit = sign), filling with $0$ turns a negative number positive — a disaster. The fix is arithmetic right shift: copy the old sign bit back into the top position. $Q_{n - 1}^{next} = Q_{n - 1} (old sign) instead of 0$

WHY these deserve their own step. The contract says cover every case. A reader who only saw the clean $3 \to 6 \to 12$ would be blindsided when $12$ ( $1100$ ) shifts left to $1000 = 8$ , not $24$ . And a signed reader would silently corrupt data. Naming both keeps you safe.

PICTURE. Left: $1100$ shifting left loses its top $1$ (overflow, red). Right: negative $1011$ shifted right — the wrong $0$ -fill (red) versus the correct sign-copy (green).

The one-picture summary

Everything on this page in one frame: the chain rule in the middle ( $D_{i} = Q_{i - 1}$ ), Serial In feeding the mouth, Serial Out at the cliff, and the two arithmetic readings (left = ×2, right = ÷2) hanging off the ends.

Recall Feynman retelling — the whole walkthrough in plain words

Picture a row of little lockers, each holding one bit. Every locker only ever opens on a whistle. One locker alone just remembers its bit until the next whistle (Step 1). Now run a wire from each locker's window into the next locker's slot — so at the whistle, each locker copies what its left neighbour was holding a moment ago (Steps 2–3). The very first locker has no left neighbour, so we feed it from outside — that outside wire is Serial In, the mouth of the pipe. The last locker has nobody to pass to, so its old bit falls off the end — that's Serial Out (Step 4). Drop a single $1$ into the mouth and watch it walk one locker per whistle, taking exactly $n$ whistles to cross and fall off the far cliff (Step 5). Because each locker is worth twice its right neighbour, sliding everything one seat left doubles the number, and sliding right halves it (Step 6). But mind the two traps: shift a $1$ off the top and you overflow (you wrapped around), and if the number is signed you must copy the sign bit back in on a right shift instead of a plain $0$ (Step 7). That's the entire machine: copy-your-neighbour, feed one end, spill the other, and read it as doubling or halving.

Connections

D flip-flop — the single box every step is built from
Multiplexers — a mux on stage 0 chooses Serial In vs. parallel load
Serial communication (UART, SPI) — the delay-line of Step 5 is how bits ride one wire
Binary multiplication and division — Step 6's ×2/÷2 is the shift-and-add core
Counters — feed Serial Out back to Serial In and you get a ring counter
Clocking and setup/hold time — Step 2's "read old, then all update" needs correct timing
Yeh page Hinglish mein padho →