Boolean lane quick reference.

Boolean operators (0 denotes False, 1 denotes True)
And / AndAlso / & / &&
Cond1Cond2Result
000
010
100
111
The output is only 1 when the left condition And right condition are 1.
Or / OrElse / | / ||
Cond1Cond2Result
000
011
101
111
The output is 1 when either the left condition Or right condition are 1.
Xor / ^
Cond1Cond2Result
000
011
101
110
The output is 1 when the conditions are not the same (either input1 or input2, but not both.)
Not / ! (has only one condition operand)
Cond1Result
01
10
The output is Not the condition.
Eqv / Not (cond1 Xor cond2)
Cond1Cond2Result
001
010
101
111
The output is 1 when the inputs are equal.
Imp / Not cond1 And cond2
Cond1Cond2Result
001
011
100
111
The output is 1 when the first condition is less than/equal to the second condition.
Some common uses besides checking conditions:
Getting certain bits.

  00110110    01101100
& 00001000  & 00001000
= 00000000  = 00001000

Is number odd?
  Number And 1  (the bold zero will tell if it is (1) or not (0).

12 = 0000 1100, 13 = 0000 1101, 14 = 0000 1110, 15 = 0000 1111...
-1 = 1111 1111, -2 = 1111 1110, -3 = 1111 1101,  0 = 0000 0000

Setting certain bits.

   00110110     01101100
Or 00001000  Or 00001000
=  00111110  =  01101100

Resetting certain bits.

  00110110    01101100
& 11110111  & 11110111
= 00110000  = 01100100

Computing remainder: If you so happen to want the remainder of a division, where you are dividing by a power of 2.
Mod (or %) is the remainder operator.

N Mod #, # is 2 to the Xth power =
N Mod # = N And (# - 1)

  26 Mod 4 = 26 And 3
  (2)      = 0001 1010
           & 0000 0011
           = 0000 0010 = 2

  188 Mod 16 = 188 And 15
  (12)       = 1011 1100
             & 0000 1111
             = 0000 1100 = 12

Bit Shifting.

  0000 1100          0010 0110
<<        2        <<        3
  0011 0000          0011 0000

  0000 1100          0010 0110
>>        2        >>        3
  0000 0011          0000 0100

Aside from that, if you want to multiply or divide by a power of 2:
Multiplication (as long as some of the bits don't fall off of the left).

N  # = N << X
17  4 = 68 = 17 << 2 = 0001 0001
                      <<        2
                      = 0100 0100 = 68

7  8 = 56 = 7 << 4 = 0000 0111
                    <<        4
                    = 0011 1000 = 56

Division (Integer Division, but still Division).

N  # = N >> X
72  4 = 18 = 72 >> 2 = 0100 1000
                      >>        2
                      = 0001 0010 = 18

200  16 = 12 (actually 12.5, but I'm using Integer division)
= 200 >> 4 = 1100 1000
           >>        4
           = 0000 1100 = 12

(Bit Shifting is included within VB.NET 2003 and later, not in VB.NET 2002 or earlier versions)