From Philosophy to Bits: A Minimalist Computer History and Bitwise Operator Mastery

1. A Minimalist History of Computers

Computer science students may be familiar with logical operators (also known as bitwise operators). To help non‑specialists quickly understand, I review a minimalist development history of computers; readers already familiar can skip this section.

The origin of computers is a long evolution from philosophy to circuits: philosophy → mathematical logic → Boolean algebra → logic gates → computers, culminating in modern computers.

Initially, philosophers like Aristotle studied true/false propositions, later mathematician George Boole abstracted this logic into algebraic operations, i.e., Boolean algebra (the 0/1 we often use in programming). Electrical engineers then realized that voltage on/off (high/low) could represent true/false, inventing AND, OR, NOT logic gates, where a gate is a switch controlling current. Once logic could be realized in circuits, the prototype of a computer was born.

Thus logical operations became physical digital circuits. Designing various AND, OR, NOT gates is the key to computation, enabling SQL WHERE conditions, control structures (if‑else, for loops, switch, etc.).

In Liu Cixin’s The Three‑Body Problem , Qin Shi Huang used ten‑thousands of soldiers as a giant logic‑gate circuit, substituting human judgment for electronic switches, successfully performing logical computation. As long as a medium can execute logical operations—people, stones, or electric current—we can compute, though electric current is the most stable and efficient.

Alan Turing proved in 1936 that any system capable of logical judgment can, in principle, compute. This statement is the most fundamental explanation of computer science.

In short, modern computer development relies on the contributions of these scientists: 1. Boole made logic computable 2. Shannon made logic electrically transmissible 3. Turing made logic executable 4. von Neumann made logic storable

2. Bitwise Operators

All data inside a computer is stored in binary, and bitwise operators directly manipulate these 0 and 1 bits. These operators originate from logical algebra; scientists discovered optimal, stable, fast ways when building logic circuits.

1. AND

The AND operator ("&") returns 1 only when both bits are 1. It is often used with a mask such as 0xFF to keep the lowest 8 bits, e.g., when designing a unique ID that retains an 8‑bit serial number.

// 300 converted to binary, take last 8 bits, equals 44
int a = 300 & 0xFF;
a = 44;

Other useful masks: 0x0F → binary 00001111 → keep low 4 bits 0xF0 → binary 11110000 → keep high 4 bits 0xFFFF → 16‑bit all 1s → keep low 16 bits

Checking odd numbers can be done with x & 1 != 0, because an odd number has a trailing 1 in binary.

2. OR

The OR operator ("|") returns 1 when either bit is 1. It is widely used for state and permission control, such as Java NIO’s readable, writable, executable flags.

int A = 0b0001; // Feature A
int B = 0b0010; // Feature B
int C = 0b0100; // Feature C
int flags = A | C; // 0001 | 0100 = 0101

3. NOT

The NOT operator ("~") flips each bit: 0 becomes 1 and 1 becomes 0. Its usage scenarios are relatively few.

4. XOR

The XOR operator ("^") returns 0 when bits are the same and 1 when they differ. It is the most magical bitwise operation because, if b is a known key, you can encrypt a into c and decrypt back using the same key.

a ^ b = c
c ^ b = a

5. Right Shift

The right‑shift operator ( >>) moves bits to the right. In binary, the left side holds higher bits, similar to decimal where leftmost digits have larger place values.

Example: 1000 >> 3 = 0001. For positive numbers, right shifting by n bits is equivalent to integer division by 2ⁿ (floor).

Original:  [1][0][0][0]
Right shift 1: [ ][1][0][0]  (rightmost bit discarded)
Right shift 2: [ ][ ][1][0]
Right shift 3: [ ][ ][ ][1] → final [0][0][0][1]

Using x & 0xFF extracts the lowest 8 bits; right‑shifting 8 bits first then applying the mask extracts the 8‑15th byte.

6. Left Shift

The left‑shift operator ( <<) moves bits to the left. x << n is equivalent to multiplying x by 2ⁿ, the opposite of right shift.

3. Algorithm Analysis

Below is a coupon‑code generation algorithm:

long raw = ((long) version & 0xF) << 60
        | ((long) activityId & 0xFFFFFF) << 36
        | ((long) batchId & 0xFFF) << 24
        | ((long) seq & 0xFFFFF) << 4;

long checksum = (raw ^ secret) & 0xF;
long raw64 = raw | checksum;
long perm = (raw64 * MUL) ^ XORK;

1. ((long) version & 0xF) << 60 masks the version to its lowest 4 bits and shifts them to bits 60‑63 of a 64‑bit long, allowing version values 0‑15.

2. ((long) activityId & 0xFFFFFF) << 36 masks the activity ID to 24 bits and places it in bits 36‑59.

3. ((long) batchId & 0xFFF) << 24 masks the batch ID to 12 bits and positions it in bits 24‑35.

4. ((long) seq & 0xFFFFF) << 4 masks the sequence number to 20 bits and puts it in bits 4‑23.

5. Bitwise OR combines the non‑overlapping segments into a single 64‑bit value raw64.

6. long checksum = (raw ^ secret) & 0xF; XORs the raw value with a server‑side secret and extracts the lowest 4 bits as a checksum.

7. raw64 = raw | checksum writes the checksum back into the lowest 4 bits, completing the 64‑bit value.

8. long perm = (raw64 * MUL) ^ XORK; first multiplies by an odd constant MUL (odd numbers have multiplicative inverses in binary modulo space), then XORs with another secret XORK for obfuscation; the same XORK can reverse the operation.

The above constitutes the entire content; if the coupon generation algorithm is not clear now, the next article will elaborate on it with concrete cases.

Feel free to leave any good ideas in the comments below; I look forward to growing together with you.