Bitwise operations. The very words can conjure images of arcane, low-level code, perhaps from the days of C and assembly. While modern, high-level languages often abstract away the need to manipulate individual bits, understanding bitwise operations remains a powerful tool in a developer’s arsenal.

Why should you care? Because they are fundamental to understanding how computers work at a deeper level. They are crucial for optimizing performance in specific scenarios, working with hardware registers, implementing cryptographic algorithms, parsing network packets, and even for clever data structures. More often than not, they provide an elegant and efficient way to handle flags, permissions, and specific data manipulations.

This post will demystify bitwise operations with practical, runnable examples in both C and Python, demonstrating their utility and helping you master their use.

The Foundation: Binary Numbers

Before we dive into operations, a quick refresher on binary numbers is essential. Computers store all data as bits (binary digits), which can be either 0 or 1. Numbers are represented in base-2.

For example:

• Decimal 1 is 0001 in binary.
• Decimal 2 is 0010 in binary.
• Decimal 4 is 0100 in binary.
• Decimal 5 is 0101 in binary.

Each position in a binary number represents a power of 2, starting from 2^0 on the right.

The Core Bitwise Operators

Let’s break down each operator with examples. We’ll use 8-bit representations for clarity, though real-world integer sizes vary (e.g., 32-bit, 64-bit).

1. Bitwise AND (&)

The bitwise AND operator compares two bits at corresponding positions. If both bits are 1, the resulting bit is 1. Otherwise, it’s 0.

Symbol: &

Common Use Cases:

• Checking if a specific bit is set: ANDing with a mask where only that bit is 1.
• Masking: Clearing specific bits or extracting a subset of bits.

Example 1: Checking for Even/Odd Numbers (Python)

A number is odd if its least significant bit (LSB) is 1, and even if it’s 0. We can check this by ANDing the number with 1 (binary 00000001).

# Python
def is_even(n):
    return (n & 1) == 0

print(f"Is 4 even? {is_even(4)}")
print(f"Is 7 even? {is_even(7)}")

Is 4 even? True
Is 7 even? False

Example 2: Extracting the Lower Nibble (C)

A “nibble” is 4 bits. The lower nibble consists of the four least significant bits. We can extract it using a mask of 0x0F (binary 00001111).

// C
#include <stdio.h>

int main() {
    unsigned char value = 0b10101101; // Decimal 173
    unsigned char mask = 0b00001111;   // Decimal 15 (0x0F)

    unsigned char lower_nibble = value & mask;

    printf("Original value: 0x%X (Binary: %s)\n", value, "10101101");
    printf("Mask:           0x%X (Binary: %s)\n", mask,  "00001111");
    printf("Lower nibble:   0x%X (Binary: %s)\n", lower_nibble, "00001101"); // 1101 is 13

    return 0;
}

To compile and run the C example:

gcc -o bitwise_and bitwise_and.c
./bitwise_and

Original value: 0xAD (Binary: 10101101)
Mask:           0xF (Binary: 00001111)
Lower nibble:   0xD (Binary: 00001101)

2. Bitwise OR (|)

The bitwise OR operator compares two bits at corresponding positions. If at least one bit is 1, the resulting bit is 1. Otherwise, it’s 0.

Symbol: |

Common Use Cases:

• Setting a specific bit: ORing with a mask where only that bit is 1.
• Combining flags or permissions: If a resource needs multiple permissions, you can OR their bit values together.

Example 1: Setting a Specific Bit (Python)

Let’s say we have a number 5 (binary 00000101) and we want to set the 3rd bit (0-indexed, so the bit representing 2^2 = 4). The mask would be 1 << 2 which is 4 (binary 00000100).

# Python
initial_value = 5   # 00000101
bit_to_set = 2      # We want to set the 2^2 bit

# Create a mask with only the desired bit set
mask = 1 << bit_to_set  # 00000100 (4)

result = initial_value | mask # 00000101 | 00000100 = 00000101

print(f"Initial value: {initial_value} (Binary: {bin(initial_value)[2:].zfill(8)})")
print(f"Mask:          {mask} (Binary: {bin(mask)[2:].zfill(8)})")
print(f"Result:        {result} (Binary: {bin(result)[2:].zfill(8)})")

# Let's try setting a bit that's currently 0
initial_value = 1   # 00000001
bit_to_set = 3      # We want to set the 2^3 bit (8)
mask = 1 << bit_to_set # 00001000 (8)
result = initial_value | mask # 00000001 | 00001000 = 00001001 (9)

print("\n--- Setting a bit that's currently 0 ---")
print(f"Initial value: {initial_value} (Binary: {bin(initial_value)[2:].zfill(8)})")
print(f"Mask:          {mask} (Binary: {bin(mask)[2:].zfill(8)})")
print(f"Result:        {result} (Binary: {bin(result)[2:].zfill(8)})")

Initial value: 5 (Binary: 00000101)
Mask:          4 (Binary: 00000100)
Result:        5 (Binary: 00000101)

--- Setting a bit that's currently 0 ---
Initial value: 1 (Binary: 00000001)
Mask:          8 (Binary: 00001000)
Result:        9 (Binary: 00001001)

Example 2: Combining Permissions (C)

Imagine you have flags for file permissions: READ, WRITE, EXECUTE.

// C
#include <stdio.h>

// Define permission flags using powers of 2 for distinct bit positions
#define PERM_READ    (1 << 0) // 0001
#define PERM_WRITE   (1 << 1) // 0010
#define PERM_EXECUTE (1 << 2) // 0100
#define PERM_DELETE  (1 << 3) // 1000

int main() {
    unsigned char user_permissions = 0; // No permissions initially

    printf("Initial permissions: 0x%X\n", user_permissions);

    // Grant read and write permissions
    user_permissions = user_permissions | PERM_READ;
    user_permissions = user_permissions | PERM_WRITE;

    printf("Permissions after granting READ and WRITE: 0x%X\n", user_permissions); // Should be 0x3 (0011)

    // Grant execute permission as well
    user_permissions |= PERM_EXECUTE; // Shorthand for user_permissions = user_permissions | PERM_EXECUTE;

    printf("Permissions after granting EXECUTE: 0x%X\n", user_permissions); // Should be 0x7 (0111)

    // Check if user has read permission
    if (user_permissions & PERM_READ) {
        printf("User has READ permission.\n");
    }

    // Check if user has delete permission (which they don't)
    if (!(user_permissions & PERM_DELETE)) {
        printf("User does NOT have DELETE permission.\n");
    }

    return 0;
}

gcc -o bitwise_or bitwise_or.c
./bitwise_or

Initial permissions: 0x0
Permissions after granting READ and WRITE: 0x3
Permissions after granting EXECUTE: 0x7
User has READ permission.
User does NOT have DELETE permission.

3. Bitwise XOR (^)

The bitwise XOR (exclusive OR) operator compares two bits. If the bits are different, the resulting bit is 1. If they are the same, it’s 0.

Symbol: ^

Common Use Cases:

• Toggling a bit: XORing with a mask where only that bit is 1 will flip its value.
• Swapping two numbers without a temporary variable: A classic interview trick.
• Simple encryption/decryption: XORing data with a key. Applying the same key again decrypts it because (A ^ K) ^ K = A.

Example 1: Toggling a Specific Bit (Python)

Let’s toggle the 3rd bit (0-indexed) of 13 (binary 00001101). The 3rd bit is 1. We expect it to become 0.

# Python
initial_value = 13  # 00001101
bit_to_toggle = 2   # The 2^2 bit (value 4)

# Create a mask with only the desired bit set
mask = 1 << bit_to_toggle # 00000100 (4)

result = initial_value ^ mask # 00001101 ^ 00000100 = 00001001 (9)

print(f"Initial value: {initial_value} (Binary: {bin(initial_value)[2:].zfill(8)})")
print(f"Mask:          {mask} (Binary: {bin(mask)[2:].zfill(8)})")
print(f"Result:        {result} (Binary: {bin(result)[2:].zfill(8)})")

# Let's try toggling a bit that's currently 0
initial_value = 5   # 00000101
bit_to_toggle = 3   # The 2^3 bit (value 8)
mask = 1 << bit_to_toggle # 00001000 (8)
result = initial_value ^ mask # 00000101 ^ 00001000 = 00001101 (13)

print("\n--- Toggling a bit that's currently 0 ---")
print(f"Initial value: {initial_value} (Binary: {bin(initial_value)[2:].zfill(8)})")
print(f"Mask:          {mask} (Binary: {bin(mask)[2:].zfill(8)})")
print(f"Result:        {result} (Binary: {bin(result)[2:].zfill(8)})")

Initial value: 13 (Binary: 00001101)
Mask:          4 (Binary: 00000100)
Result:        9 (Binary: 00001001)

--- Toggling a bit that's currently 0 ---
Initial value: 5 (Binary: 00000101)
Mask:          8 (Binary: 00001000)
Result:        13 (Binary: 00001101)

Example 2: Swapping Two Numbers (C)

This is a classic trick. It works because XOR is commutative and associative, and A ^ A = 0, A ^ 0 = A.

// C
#include <stdio.h>

int main() {
    int a = 10; // Binary 00001010
    int b = 25; // Binary 00011001

    printf("Before swap: a = %d, b = %d\n", a, b);

    a = a ^ b; // a becomes (10 ^ 25) = 00001010 ^ 00011001 = 00010011 (19)
    b = a ^ b; // b becomes (19 ^ 25) = (A^B) ^ B = A = 00010011 ^ 00011001 = 00001010 (10)
    a = a ^ b; // a becomes (19 ^ 10) = (A^B) ^ A = B = 00010011 ^ 00001010 = 00011001 (25)

    printf("After swap:  a = %d, b = %d\n", a, b);

    return 0;
}

gcc -o bitwise_xor_swap bitwise_xor_swap.c
./bitwise_xor_swap

Before swap: a = 10, b = 25
After swap:  a = 25, b = 10

4. Bitwise NOT (~)

The bitwise NOT (complement) operator inverts all the bits of its operand. 0s become 1s, and 1s become 0s.

Symbol: ~

Important Note on ~ and Signed Integers: For signed integers, ~x is equivalent to -(x + 1) due to the two’s complement representation used for negative numbers. If x is 5 (binary 00000101), ~x will be 11111010. In two’s complement, 11111010 represents -6. This is a common source of confusion, so be mindful of integer types. For unsigned integers, it simply inverts all bits.

Common Use Cases:

• Creating masks: ~0 (all bits set to 1) or ~mask to clear bits.

Example 1: Simple Inversion (Python)

# Python
value = 5 # 00000101 (assuming 8-bit for demonstration)
inverted_value = ~value

print(f"Value:          {value} (Binary: {bin(value & 0xFF)[2:].zfill(8)})") # Mask with 0xFF for 8-bit display
print(f"Inverted value: {inverted_value} (Binary: {bin(inverted_value & 0xFF)[2:].zfill(8)})")
print(f"As signed int:  {inverted_value}")

Value:          5 (Binary: 00000101)
Inverted value: -6 (Binary: 11111010)
As signed int:  -6

Example 2: Clearing a Bit (C)

To clear a specific bit (set it to 0), we create a mask where that bit is 0 and all other bits are 1. We achieve this by taking NOT of a bit-set mask.

// C
#include <stdio.h>

int main() {
    unsigned char value = 0b10101101; // Decimal 173
    int bit_to_clear = 2; // We want to clear the 2^2 bit (value 4)

    // Create a mask with only the desired bit set
    unsigned char bit_mask = (1 << bit_to_clear); // 00000100 (4)

    // Invert the mask: ~00000100 = 11111011
    unsigned char clear_mask = ~bit_mask;

    unsigned char result = value & clear_mask;

    printf("Original value: 0x%X (Binary: %s)\n", value, "10101101");
    printf("Bit to clear:   %d\n", bit_to_clear);
    printf("Bit mask:       0x%X (Binary: %s)\n", bit_mask, "00000100");
    printf("Clear mask (~): 0x%X (Binary: %s)\n", clear_mask, "11111011");
    printf("Result:         0x%X (Binary: %s)\n", result, "10101001"); // 10101001 is 169

    return 0;
}

gcc -o bitwise_not bitwise_not.c
./bitwise_not

Original value: 0xAD (Binary: 10101101)
Bit to clear:   2
Bit mask:       0x4 (Binary: 00000100)
Clear mask (~): 0xFB (Binary: 11111011)
Result:         0xA9 (Binary: 10101001)

5. Left Shift (<<)

The left shift operator shifts all bits of a number to the left by a specified number of positions. Vacated bit positions on the right are filled with 0s.

Symbol: <<

X << N

Effect: Equivalent to multiplying X by 2^N. This is often faster than actual multiplication by powers of 2.

Common Use Cases:

• Fast multiplication by powers of 2.
• Creating bitmasks (e.g., 1 << n creates a mask with only the nth bit set).
• Packing data into larger types.

Example 1: Fast Multiplication (Python)

# Python
value = 7  # 00000111

# Shift left by 1 (multiply by 2^1 = 2)
result1 = value << 1 # 00001110 (14)

# Shift left by 3 (multiply by 2^3 = 8)
result2 = value << 3 # 00111000 (56)

print(f"Value:    {value} (Binary: {bin(value)[2:].zfill(8)})")
print(f"Value << 1: {result1} (Binary: {bin(result1)[2:].zfill(8)}) (7 * 2 = 14)")
print(f"Value << 3: {result2} (Binary: {bin(result2)[2:].zfill(8)}) (7 * 8 = 56)")

Value:    7 (Binary: 00000111)
Value << 1: 14 (Binary: 00001110) (7 * 2 = 14)
Value << 3: 56 (Binary: 00111000) (7 * 8 = 56)

Example 2: Creating a Bitmask (C)

A common pattern is to create a mask for a specific bit position using 1 << bit_position.

// C
#include <stdio.h>

int main() {
    int bit_position = 5; // We want a mask for the 2^5 bit

    // Creates a number with only the 5th bit set
    unsigned int mask = (1 << bit_position); // 00100000 (Decimal 32)

    printf("Bit position: %d\n", bit_position);
    printf("Mask:         0x%X (Binary: %s)\n", mask, "00100000");

    bit_position = 0; // For the 0th bit
    mask = (1 << bit_position); // 00000001 (Decimal 1)
    printf("Bit position: %d\n", bit_position);
    printf("Mask:         0x%X (Binary: %s)\n", mask, "00000001");

    return 0;
}

gcc -o left_shift left_shift.c
./left_shift

Bit position: 5
Mask:         0x20 (Binary: 00100000)
Bit position: 0
Mask:         0x1 (Binary: 00000001)

6. Right Shift (>>)

The right shift operator shifts all bits of a number to the right by a specified number of positions.

Symbol: >>

X >> N

Important Note on Right Shift: The behavior of the right shift operator for signed integers is implementation-defined in C++ (and historically in C) when the most significant bit (sign bit) is 1.

• Logical Right Shift: Vacated positions are filled with 0s (common for unsigned integers).
• Arithmetic Right Shift: Vacated positions are filled with copies of the sign bit (common for signed integers to preserve the sign).

Python performs an arithmetic right shift for signed integers and a logical right shift for unsigned integers. In C, unsigned int will always use logical shift, signed int usually uses arithmetic shift but it’s not guaranteed by the standard for negative numbers. Stick to unsigned for predictable bit manipulation.

Effect: Equivalent to integer division of X by 2^N.

Common Use Cases:

• Fast integer division by powers of 2.
• Extracting higher bits or a specific range of bits.
• Unpacking data.

Example 1: Fast Division (Python)

# Python
value = 56 # 00111000

# Shift right by 1 (divide by 2^1 = 2)
result1 = value >> 1 # 00011100 (28)

# Shift right by 3 (divide by 2^3 = 8)
result2 = value >> 3 # 00000111 (7)

print(f"Value:    {value} (Binary: {bin(value)[2:].zfill(8)})")
print(f"Value >> 1: {result1} (Binary: {bin(result1)[2:].zfill(8)}) (56 / 2 = 28)")
print(f"Value >> 3: {result2} (Binary: {bin(result2)[2:].zfill(8)}) (56 / 8 = 7)")

Value:    56 (Binary: 00111000)
Value >> 1: 28 (Binary: 00011100) (56 / 2 = 28)
Value >> 3: 7 (Binary: 00000111) (56 / 8 = 7)

Example 2: Extracting Higher Nibble (C)

To get the higher nibble (the four most significant bits), we right-shift the value by 4 positions and then mask the result.

// C
#include <stdio.h>

int main() {
    unsigned char value = 0b10101101; // Decimal 173
    unsigned char mask = 0b00001111;   // Decimal 15 (0x0F)

    // Shift right by 4 to bring higher nibble to lower nibble position
    unsigned char shifted_value = value >> 4; // 00001010 (10)

    // Mask to ensure only the lower 4 bits are kept (redundant here, but good practice)
    unsigned char higher_nibble = shifted_value & mask;

    printf("Original value: 0x%X (Binary: %s)\n", value, "10101101");
    printf("Shifted value (>> 4): 0x%X (Binary: %s)\n", shifted_value, "00001010");
    printf("Higher nibble:  0x%X (Binary: %s)\n", higher_nibble, "00001010"); // 1010 is 10

    return 0;
}

gcc -o right_shift right_shift.c
./right_shift

Original value: 0xAD (Binary: 10101101)
Shifted value (>> 4): 0xA (Binary: 00001010)
Higher nibble:  0xA (Binary: 00001010)

Practical Bitwise Patterns and Applications

Beyond individual operators, these are common composite patterns.

1. Checking if a Bit is Set

To check if the Nth bit (0-indexed) of num is set: (num & (1 << N))

If the result is non-zero, the bit is set.

# Python
num = 0b10101101 # 173
bit_pos = 2 # Check the 2^2 bit

if (num & (1 << bit_pos)):
    print(f"Bit {bit_pos} is set in {num} (Binary: {bin(num)[2:].zfill(8)})")
else:
    print(f"Bit {bit_pos} is NOT set in {num} (Binary: {bin(num)[2:].zfill(8)})")

bit_pos = 1 # Check the 2^1 bit (which is 0)
if (num & (1 << bit_pos)):
    print(f"Bit {bit_pos} is set in {num} (Binary: {bin(num)[2:].zfill(8)})")
else:
    print(f"Bit {bit_pos} is NOT set in {num} (Binary: {bin(num)[2:].zfill(8)})")

Bit 2 is set in 173 (Binary: 10101101)
Bit 1 is NOT set in 173 (Binary: 10101101)

2. Setting a Bit

To set the Nth bit of num: num = num | (1 << N)

# Python
num = 0b10100000 # 160
bit_pos_to_set = 2 # Set the 2^2 bit

print(f"Original: {bin(num)[2:].zfill(8)}")
num = num | (1 << bit_pos_to_set)
print(f"After setting bit {bit_pos_to_set}: {bin(num)[2:].zfill(8)}")

bit_pos_to_set = 0 # Set the 2^0 bit
num = num | (1 << bit_pos_to_set)
print(f"After setting bit {bit_pos_to_set}: {bin(num)[2:].zfill(8)}")

Original: 10100000
After setting bit 2: 10100100
After setting bit 0: 10100101

3. Clearing a Bit

To clear the Nth bit of num: num = num & ~(1 << N)

# Python
num = 0b10101101 # 173
bit_pos_to_clear = 2 # Clear the 2^2 bit

print(f"Original: {bin(num)[2:].zfill(8)}")
num = num & ~(1 << bit_pos_to_clear)
print(f"After clearing bit {bit_pos_to_clear}: {bin(num)[2:].zfill(8)}")

bit_pos_to_clear = 0 # Clear the 2^0 bit
num = num & ~(1 << bit_pos_to_clear)
print(f"After clearing bit {bit_pos_to_clear}: {bin(num)[2:].zfill(8)}")

Original: 10101101
After clearing bit 2: 10101001
After clearing bit 0: 10101000

4. Toggling a Bit

To toggle the Nth bit of num: num = num ^ (1 << N)

# Python
num = 0b10101010 # 170
bit_pos_to_toggle = 0 # Toggle the 2^0 bit

print(f"Original: {bin(num)[2:].zfill(8)}")
num = num ^ (1 << bit_pos_to_toggle)
print(f"After toggling bit {bit_pos_to_toggle}: {bin(num)[2:].zfill(8)}")

bit_pos_to_toggle = 1 # Toggle the 2^1 bit
num = num ^ (1 << bit_pos_to_toggle)
print(f"After toggling bit {bit_pos_to_toggle}: {bin(num)[2:].zfill(8)}")

Original: 10101010
After toggling bit 0: 10101011
After toggling bit 1: 10101001

5. Isolating the Least Significant Bit (LSB)

To get the LSB: num & -num (for two’s complement systems) or num & (~num + 1) which is the same as num & (num ^ (num - 1))

This typically yields a number that is a power of 2, representing the value of the LSB. For example, if num = 12 (binary 1100), ~num + 1 would be 0100, and 1100 & 0100 = 0100 (which is 4).

# Python
num = 12 # 00001100
lsb = num & (-num)

print(f"Number: {num} (Binary: {bin(num)[2:].zfill(8)})")
print(f"LSB:    {lsb} (Binary: {bin(lsb)[2:].zfill(8)})")

num = 5 # 00000101
lsb = num & (-num)
print(f"\nNumber: {num} (Binary: {bin(num)[2:].zfill(8)})")
print(f"LSB:    {lsb} (Binary: {bin(lsb)[2:].zfill(8)})")

Number: 12 (Binary: 00001100)
LSB:    4 (Binary: 00000100)

Number: 5 (Binary: 00000101)
LSB:    1 (Binary: 00000001)

6. Counting Set Bits (Brian Kernighan’s Algorithm)

A common interview question and a practical use case. This algorithm efficiently counts the number of ‘1’ bits in an integer. It works by repeatedly clearing the LSB until the number becomes zero. Each clear operation counts one set bit.

num = num & (num - 1) clears the LSB of num.

# Python
def count_set_bits(n):
    count = 0
    while n > 0:
        n &= (n - 1) # Clear the least significant set bit
        count += 1
    return count

num1 = 0b10101101 # 173 (5 set bits)
num2 = 0b00000000 # 0 (0 set bits)
num3 = 0b11111111 # 255 (8 set bits)

print(f"Number: {bin(num1)[2:].zfill(8)}, Set bits: {count_set_bits(num1)}")
print(f"Number: {bin(num2)[2:].zfill(8)}, Set bits: {count_set_bits(num2)}")
print(f"Number: {bin(num3)[2:].zfill(8)}, Set bits: {count_set_bits(num3)}")

Number: 10101101, Set bits: 5
Number: 00000000, Set bits: 0
Number: 11111111, Set bits: 8

When to Use Bitwise Operations (and When Not To)

Use them when:

• Performance is critical: Bitwise operations are typically single CPU instructions, making them extremely fast for operations like multiplication/division by powers of 2, or setting/clearing flags.
• Memory efficiency matters: Packing multiple boolean flags or small integer values into a single byte or word can save significant memory, especially in embedded systems or large data sets.
• Interacting with hardware: Device drivers, network protocols, and embedded systems often require direct manipulation of bits in registers or packets.
• Implementing specific algorithms: Hash functions, error detection (checksums, CRCs), compression algorithms, and some cryptographic routines heavily rely on bitwise logic.
• Working with data structures like bitsets/bitmaps: Representing sets of booleans efficiently.

Avoid them when:

• Readability suffers disproportionately: If a bitwise operation makes your code harder to understand for little gain, prefer more straightforward arithmetic or logical operations. num / 4 is generally clearer than num >> 2 unless performance is profiled as an issue.
• Premature optimization: Don’t reach for bitwise operations just because they might be faster. Profile your code. Modern compilers are very good at optimizing arithmetic operations, sometimes even replacing them with shifts where appropriate.
• The problem naturally maps to higher-level abstractions: If you’re managing user roles in a web application, an Enum or a dictionary of boolean flags might be clearer than a bitmask, even if slightly less performant.

Potential Pitfalls

• Signed vs. Unsigned Integers: As noted with ~ and >>, the behavior can differ. Always use unsigned types in C/C++ when doing bit manipulation to avoid surprises related to the sign bit and two’s complement representation. Python handles integers differently and usually abstracts away fixed-size integer issues, but the ~ operator still behaves as -(x+1).
• Operator Precedence: Bitwise operators have lower precedence than arithmetic operators. For example, 1 << 2 + 1 is 1 << (2 + 1) (i.e., 1 << 3), not (1 << 2) + 1. Always use parentheses () to clarify intent: (1 << 2) + 1.
• Undefined Behavior in C/C++: Shifting by more bits than the integer size, or shifting a negative number left, can lead to undefined behavior.
• Endianness: When dealing with multi-byte data (e.g., network packets), the order of bytes (endianness) can affect how bits are interpreted. This is more of a system-level concern than a bitwise operator one, but it’s often encountered in the same contexts.

Conclusion

Bitwise operations are a powerful set of tools that allow for fine-grained control over data at its most fundamental level. While not always necessary in day-to-day high-level development, they are indispensable for certain domains and understanding them deepens your knowledge of how computers work.

Practice these operations, experiment with different numbers, and watch how the bits flip. The more you use them, the more intuitive they become, and you’ll soon be wielding them to write more efficient and robust code when the situation calls for it.