# Logical operators

Logical operators are also, maybe more commonly, called boolean operators.

The term “boolean” originates from the book “The Mathemetical Analysis of Logic” written by George Boole in 1847. Boolean logic has been fundamental in the development of computers, and programming, since at their core, computers are all about processing whether or not there is current flow: on vs off (true vs false).

If you are curious, feel encouraged to google and read up on this online, but
for now, we can simply look at the 3 fundamental boolean operators and
what they do: `and`

, `or`

, and `not`

.

The operator `and`

returns `true`

if, and only if, both values also are `true`

.
So, only the expression `true and true`

is also `true`

. All of the expressions
`true and false`

, `false and true`

, `false and false`

evaluate to `false`

.

If you think about this, and come up with English sentences, then this will
make a lot of sense: *At the restaurant I’ll have a tomato soup IF it is vegan
AND they still have some.*

The operator `or`

on the other hand returns `true`

if at least one of the
values is `true`

. So, only if both values are `false`

, the operator returns
`false`

.

That’s why it is logically correct to answer the question *Would you like tea
or coffee for breakfeast?* with *Yes, please.* IF you’d like either tea, or
coffee, or both. You’d only say *Hell, no!* if you’d like an orange juice
instead :)

The operator `not`

simply returns the negated, opposite value. `not true`

returns `false`

, and `not false`

returns `true`

. Therefore, the following
lines of code are the same:

```
puts "Always true" if not false
puts "Always true" unless false
```

Each of these three operators comes in two versions:

`and`

and`&&`

`or`

and`||`

`not`

and`!`

The difference between them has to do with what is called “operator precedence”.

From math you know that `1 + 2 * 3`

evaluates to `7`

, not `9`

. This is
because the multiplication `*`

operator binds stronger, and precedes the
addition operator `+`

. In other words `1 + 2 * 3`

is same as `1 + (2 * 3)`

, and
not the same as `(1 + 2) * 3`

.

In Ruby, the operators `&&`

, `||`

, and `!`

bind stronger than, and thus precede
their fellows `and`

, `or`

, and `not`

.