Bit Manipulation

"""Unix file permissions are pure bit manipulation in practice.

Each permission is one bit:
  Read (r)    = 4 = 100 in binary
  Write (w)   = 2 = 010 in binary
  Execute (x) = 1 = 001 in binary

Three groups of 3 bits each: owner | group | others
  chmod 755 = 111 101 101
            = rwx r-x r-x
            = owner can do everything, group/others can read+execute
"""

# Permission bits (each is a power of 2 — one bit)
READ    = 0b100  # 4
WRITE   = 0b010  # 2
EXECUTE = 0b001  # 1

def parse_permissions(octal_mode):
    """Convert chmod number to human-readable permissions string.
    
    chmod 755 → owner=rwx, group=r-x, others=r-x
    This is just reading individual bits from a bitmask.
    """
    result = []
    for shift, name in [(6, "owner"), (3, "group"), (0, "others")]:
        bits = (octal_mode >> shift) & 0b111  # Extract 3 bits for this group
        perms = ""
        perms += "r" if bits & READ else "-"      # Bit 2 set?
        perms += "w" if bits & WRITE else "-"      # Bit 1 set?
        perms += "x" if bits & EXECUTE else "-"    # Bit 0 set?
        result.append(f"{name}={perms}")
    return ", ".join(result)

def check_access(file_mode, user_type, action):
    """Check if a user type has a specific permission.
    
    user_type: 'owner', 'group', or 'others'
    action: READ, WRITE, or EXECUTE
    
    This is what the OS kernel does on every file access — 
    extract the relevant 3 bits and check with AND.
    """
    shifts = {"owner": 6, "group": 3, "others": 0}
    user_bits = (file_mode >> shifts[user_type]) & 0b111
    return bool(user_bits & action)

def grant_permission(file_mode, user_type, action):
    """Add a permission using OR (set the bit)."""
    shifts = {"owner": 6, "group": 3, "others": 0}
    return file_mode | (action << shifts[user_type])

def revoke_permission(file_mode, user_type, action):
    """Remove a permission using AND + NOT (clear the bit)."""
    shifts = {"owner": 6, "group": 3, "others": 0}
    return file_mode & ~(action << shifts[user_type])

# Demo
mode = 0o755  # Common permission: rwxr-xr-x
print(parse_permissions(mode))
# "owner=rwx, group=r-x, others=r-x"

print(check_access(mode, "group", WRITE))   # False — group can't write
print(check_access(mode, "owner", EXECUTE)) # True — owner can execute

mode = grant_permission(mode, "group", WRITE)
print(f"After granting group write: {oct(mode)}")  # 0o775
print(parse_permissions(mode))
# "owner=rwx, group=rwx, others=r-x"

// Feature flags as a bitmask — one integer replaces a whole config object
const FEATURES = {
  DARK_MODE:       1 << 0,  // 0b0001
  BETA_UI:         1 << 1,  // 0b0010
  ANALYTICS:       1 << 2,  // 0b0100
  PREMIUM_CONTENT: 1 << 3,  // 0b1000
  NEW_CHECKOUT:    1 << 4,  // 0b10000
  AI_ASSISTANT:    1 << 5,  // 0b100000
};

// User's features stored as a single integer (fits in one DB column)
let userFlags = FEATURES.DARK_MODE | FEATURES.ANALYTICS;  // 0b0101 = 5

// Check if a feature is enabled — single AND operation, one CPU cycle
function hasFeature(flags, feature) {
  return (flags & feature) !== 0;
}

// Enable a feature — OR sets the bit
function enableFeature(flags, feature) {
  return flags | feature;
}

// Disable a feature — AND with NOT clears the bit
function disableFeature(flags, feature) {
  return flags & ~feature;
}

// Toggle a feature — XOR flips the bit
function toggleFeature(flags, feature) {
  return flags ^ feature;
}

console.log(hasFeature(userFlags, FEATURES.DARK_MODE));   // true
console.log(hasFeature(userFlags, FEATURES.BETA_UI));     // false

userFlags = enableFeature(userFlags, FEATURES.PREMIUM_CONTENT);
console.log(userFlags.toString(2));  // "1101" — bits 0, 2, 3 set

// Why bitmasks over objects? In a hot path (middleware checking flags
// on every request), one integer comparison is 100x faster than
// property lookups on an object. At 10,000 requests/sec, it adds up.

def extract_rgba(color):
    """Extract individual color channels from a 32-bit ARGB integer.
    
    0xFF3366AA → A=255, R=51, G=102, B=170
    Each channel is 8 bits. Shift right to position, mask with 0xFF.
    """
    a = (color >> 24) & 0xFF  # Shift right 24, mask 8 bits
    r = (color >> 16) & 0xFF
    g = (color >> 8) & 0xFF
    b = color & 0xFF
    return a, r, g, b

def pack_rgba(a, r, g, b):
    """Pack four 8-bit channels into a single 32-bit integer."""
    return (a << 24) | (r << 16) | (g << 8) | b

def alpha_blend(fg, bg):
    """Blend foreground over background using alpha compositing.
    
    This is what happens billions of times per frame when your
    browser composites translucent elements, drop shadows, and
    overlapping windows. GPUs do this in parallel across millions
    of pixels simultaneously.
    """
    fa, fr, fg_r, fb = extract_rgba(fg)
    _, br, bg_r, bb = extract_rgba(bg)
    
    alpha = fa / 255.0
    out_r = int(fr * alpha + br * (1 - alpha))
    out_g = int(fg_r * alpha + bg_r * (1 - alpha))
    out_b = int(fb * alpha + bb * (1 - alpha))
    
    return pack_rgba(255, out_r, out_g, out_b)

# Example: semi-transparent red over white
red_50 = pack_rgba(128, 255, 0, 0)   # 50% transparent red
white = pack_rgba(255, 255, 255, 255)  # solid white
blended = alpha_blend(red_50, white)
print(extract_rgba(blended))  # (255, 255, 127, 127) — pinkish

class BloomFilter:
    """A simple Bloom filter — a bit array with multiple hash functions.
    
    Used by Chrome to check URLs against a malware list (locally,
    before sending the URL to Google's servers). Cassandra uses them
    to avoid disk reads for keys that definitely don't exist.
    
    Space: a few KB for millions of entries with <1% false positive rate.
    A hash set for the same data would use megabytes.
    """
    def __init__(self, size=1024, num_hashes=3):
        self.size = size
        self.num_hashes = num_hashes
        self.bit_array = 0  # Single integer as a bit array!
    
    def _hashes(self, item):
        """Generate multiple hash positions using double hashing."""
        h1 = hash(item)
        h2 = hash(str(item) + "salt")
        for i in range(self.num_hashes):
            yield (h1 + i * h2) % self.size
    
    def add(self, item):
        """Set the bits at each hash position."""
        for pos in self._hashes(item):
            self.bit_array |= (1 << pos)  # Set bit with OR
    
    def might_contain(self, item):
        """Check if ALL hash positions are set.
        
        If any bit is 0, the item is DEFINITELY not in the set.
        If all bits are 1, the item PROBABLY is (could be false positive).
        """
        for pos in self._hashes(item):
            if not (self.bit_array & (1 << pos)):  # Check bit with AND
                return False  # Definitely not present
        return True  # Probably present (could be false positive)

bf = BloomFilter(size=64, num_hashes=3)
bf.add("hello")
bf.add("world")
print(bf.might_contain("hello"))   # True (definitely added)
print(bf.might_contain("world"))   # True (definitely added)
print(bf.might_contain("python"))  # Probably False (unless collision)

function ipToInt(ip) {
  // "192.168.1.100" → 32-bit integer
  // Each octet is 8 bits, packed left to right
  const parts = ip.split('.').map(Number);
  return ((parts[0] << 24) | (parts[1] << 16) |
          (parts[2] << 8) | parts[3]) >>> 0;
}

function intToIp(n) {
  return [
    (n >>> 24) & 0xFF,
    (n >>> 16) & 0xFF,
    (n >>> 8) & 0xFF,
    n & 0xFF
  ].join('.');
}

function cidrToMask(prefix) {
  // "/24" → 255.255.255.0 (the top 24 bits are 1)
  // ~0 is all 1s. Shift left by (32-prefix) to clear the lower bits.
  return (~0 << (32 - prefix)) >>> 0;
}

function getNetworkAddress(ip, prefix) {
  // AND the IP with the mask — this is what routers do
  const ipInt = ipToInt(ip);
  const mask = cidrToMask(prefix);
  return intToIp((ipInt & mask) >>> 0);
}

function isOnSameSubnet(ip1, ip2, prefix) {
  // Two IPs are on the same subnet if their network addresses match
  return getNetworkAddress(ip1, prefix) === getNetworkAddress(ip2, prefix);
}

console.log(getNetworkAddress("192.168.1.100", 24));
// "192.168.1.0" — network address

console.log(isOnSameSubnet("192.168.1.100", "192.168.1.200", 24));
// true — same /24 subnet

console.log(isOnSameSubnet("192.168.1.100", "192.168.2.100", 24));
// false — different /24 subnets