N = 5 = (101)2 Actually, with 32-bit ints: N = 5 = 00000000000000000000000000000101 So ~N = ~5 = 11111111111111111111111111111010 And when those bits are in a signed int, you have the value -6 More on reddit.com

I have a binary representation of a number as a char array which is at most 18 bits long. I need to store the three bits on the right, and the remaining bits into two different strings using bitwise More on stackoverflow.com

He is unpacking an RGB pixel into its 3 components (into 3 separate variables). In computer graphics, it's common to store a pixel as a single 24-bit integer (or 32-bit integer if you're including an alpha channel), where 8 bits represent the red value, 8 bits represent the green value, and 8 bits represent the blue value. Imagine a 32-bit value being like so: 00000000RRRRRRRRGGGGGGGGBBBBBBBB Where the first 8 bits (the 0s) are not interesting, the next 8 bits are the red value of the pixels, and so on. What if you want to know what the value of red is in that pixel? Well you need to isolate the R bits and get rid of all the rest. The >> shifts all of the bits over the right by the specified number of bits. So color >> 16 looks like: 000000000000000000000000RRRRRRRR Note the G and B bits have been shifted off the end (they're no longer there). Some extra 0s have been added to the left. To understand the point of the & operator, consider we want to isolate the G bits. First we do a color >> 8: 0000000000000000RRRRRRRRGGGGGGGG We've got the G bits in the right place, and have got rid of the B bits. But we still have R bits hanging around that we want to get rid of. The & 0xff says to do a bitwise AND operation with 8 1-bits like so: 0000000000000000RRRRRRRRGGGGGGGG 00000000000000000000000011111111 If we do a bitwise AND operation between those two values, the R bits get masked away and we're left with only the G bits. For the blue bits, they're already in the right position (don't need any shifting), but you still need the AND operation to mask away the R and G bits. More on reddit.com

0xFE is hexadecimal. The digits are 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, and F. There are exactly 16 digits (hence "hexadecimal"). If you think about binary, if you have 4 binary digits, these can represent exactly 16 values. So, each hexadecimal digit maps nicely to 4 bits. 2 hexadecimal digits maps to exactly one byte. If you memorize the bit patterns for the 16 hex digits, then hexadecimal is a convenient way to type/read binary data. 0xFE is, in binary, 11111110 and since I'm familiar with hexadecimal, I didn't really have to think about it to know that. As for why you need to manipulate bits, there are a few reasons. One, some hardware register might define certain bits to do certain things, and you need to construct values to put in registers to make the right things happen on the hardware. Or, maybe a bunch of bits is a very compact way to represent a set of integers (1 = present, 0 = absent) or to represent, e.g. free or occupied array elements if you're writing your own fixed size allocator. There are undoubtedly many other reasons clever people can think of to use bitwise operations. Edit: an obvious one is e.g. the "flags" argument to open(2), which packs a bunch of boolean flags into a single integer parameter. As for where to learn about them, hexadecimal is easy enough, first column is binary, 2nd is corresponding hex digit: 0000 0x0 0001 0x1 0010 0x2 0011 0x3 0100 0x4 0101 0x5 0110 0x6 0111 0x7 1000 0x8 1001 0x9 1010 0xA 1011 0xB 1100 0xC 1101 0xD 1110 0xE 1111 0xF As for bitwise operations, there's a book called "Hacker's Delight" which has all manner of bit twiddling tricks in it. More on reddit.com