An explanation at a more basic level:

In Boolean logic, we are interested in how to make compound statements out of primitive statements and a few logical operators.

To do this consistently, we need rules about what these operators do.

In Boolean logic, each statement evaluates to either T or F, representing True or False. Because each operator has one or two operands, which may only have the values T or F, we can define our logical operators by means of truth tables.

Consider two statements:

  • (A) it is dark
and
  • (B) we're wearing sunglasses
Now consider the compound statements:
  • (C) A and B (= 'it is dark and we're wearing sunglasses')
  • (D) A or B (= 'it is dark or we're wearing sunglasses')
Let's draw a little table:
A  B      C (= A and B)
-------+-------------
F  F   |     F          
F  T   |     F          
T  F   |     F          
T  T   |     T
This tells us that C ( 'it is dark and we're wearing sunglasses') is only true when both A ('it is dark') and B ('we're wearing sunglasses') are true. If one of them is false, then C is false.

The table is all we need to define 'and' for use in our algebra.

In the case of D:

A  B      D (= A or B)
-------+-------------
F  F   |     F          
F  T   |     T          
T  F   |     T          
T  T   |     T
D ('it is dark or we are wearing sunglasses') is only false when both A and B are false. We only need one out of A and B to be true in order for D to be true. Thus, we can precisely define how we want 'or'to behave in our algebra.

the table for the not operator is very simple, because it only has one operand:

A    not A
---+------
F  |  T
T  |  F
This just says that if A is true, then 'not A' is false, and the converse.

These tables are normally called truth tables. (Or sometimes, apparently, logic tables.)

I seem to remember reading somewhere that they were invented by Ludwig Wittgenstein.

Ah, I see Gritchka has something to impart on this. Thanks Gritchka!