Shifting as multiplication and division by powers of two
A left shift moves every bit toward the more significant end, filling the vacated low bits with zero — and because each bit position represents a power of 2, shifting left by one bit doubles the value (equivalent to multiplying by 2), shifting left by four is equivalent to multiplying by 16, and so on. A right shift does the reverse: dividing by the corresponding power of 2, discarding any remainder, which is why 0x0F (15) shifted right by 1 gives 0x07 (7) rather than 7.5 — bit shifts always produce integer results, silently truncating rather than rounding.
Why right shift has two different behaviors
Left shift only has one sensible behavior, since there's nothing meaningful to preserve on the vacated low end — it's always filled with zero. Right shift is different because the vacated high bits could reasonably be filled with either zero (logical shift) or a copy of the original sign bit (arithmetic shift), and which one is correct depends entirely on whether the value being shifted represents an unsigned quantity or a signed (two's complement) one. Logical shift right is correct for unsigned data — bit flags, raw byte values, unsigned counters. Arithmetic shift right is correct for signed integers, because it preserves the number's sign: shifting a negative number right should produce another negative number (dividing by 2, rounding toward negative infinity), not suddenly flip its sign by filling with zeros.
A worked comparison
Take 0x80 at 8 bits — as an unsigned value, that's 128; as a signed 8-bit value, it's -128 (the most negative representable value at that width). Shifting right by 4 logically gives0x08 (8 in decimal) — treating the original top bit as ordinary data and filling with zeros. Shifting right by 4 arithmetically instead gives 0xF8 — because the original top bit was 1 (indicating a negative signed value), the vacated bits are filled with 1s to preserve that sign, producing -8 in decimal, which is 128 ÷ 16 with the correct negative sign, rounded toward negative infinity. Applying the wrong shift type to signed data silently produces a completely different, wrong number rather than raising any kind of error.
Where shifting shows up beyond arithmetic shortcuts
Bit shifting is used constantly in low-level code for purposes well beyond fast multiplication or division: extracting a specific sub-field from a packed value (shifting a field into the low bits before masking it out), building up a multi-byte value from individual bytes (shifting each byte into its correct position before combining with OR), implementing hash functions and checksums (which the CRC-32 algorithm used elsewhere on this site relies on shifts for), and working with bitmask flags where individual bits need to be tested or set at a specific position determined by a shift amount.
Shift operators across common languages
Most C-derived languages spell logical left shift as << in every context. Right shift is where languages diverge: C, C#, and Python's >> performs arithmetic shift on signed types automatically based on the variable's declared type, while Java explicitly distinguishes the two with separate operators — >> for arithmetic (sign-preserving) shift and>>> for logical (zero-filling) shift — specifically because Java's designers wanted to avoid the ambiguity of one operator silently behaving differently depending on a type that might not be obvious at the call site. Knowing which convention a given language uses is important before trusting a shift result on a value that might be negative.
Shift amount limits
A shift amount equal to or greater than the declared bit width is meaningless — shifting an 8-bit value by 8 or more positions would move every original bit out of range entirely, and different languages and processors handle that edge case inconsistently (some wrap the shift amount modulo the width, others produce zero, others are formally undefined behavior). This tool restricts the shift amount to less than the chosen bit width specifically to avoid that ambiguity, rather than silently picking one of several possible interpretations.