Hi, welcome to this new video. We are going to be introducing week three, where we're going to start
looking into Boolean logic. So let's try to understand this idea of
Boolean logic that it's at the center of computing in many ways, right? Boolean logic is an expression
that after we evaluate, it will return a true or
false statement, right? Boolean meaning, there's only two options,
there's no in between, right? So it's a zero and a one, right? A true or a false, right? So what kind of expressions can we use
to evaluate this condition, right? So we have many specific operators
within our programming environment, our syntax, that check for
this Boolean condition, right? So we have operators like equal to, right, which is used with this double
equal sign or bigger than, right? So if you have a number five,
is it bigger than number six? The answer would be false, right? But you have several others, right,
like greater than, less than or equal to, greater than or
equal to, and not equal to, right? So we're going to be looking
at those specifically in code. Let's just look at an example of
how we could actually use these expressions, right? So let's imagine we have two variables,
a and b. In this case, a is 5, b is 10. And if we would like to print
the result of a bigger than b, you have to think of this expression
as a question mark, right? Is a bigger than b? Right? And in this case, that is not true. It's false, right? So the result of that
expression would be false. If we had the symbol in the other
direction, it would be true, right? If we would ask the question,
are those equal? Because the double equal sign would
ask the question, is it equal? We would also get a false because those
two items are not the same value, right? So let's look at the different
expressions that we have and see how we would actually write
them in our programming language. So here we are in processing once more. Let's just repeat that example, but we're going to play with a few
different expressions, right? So a = 5, b = 10, right? So let's evaluate our print expression a is bigger than b, right? Just to make sure we have,
it's very visible there and we're just going to print
it in the console here. As you can see, that is in fact false. If the screen is getting in the way,
we can do this a lot smaller. I mean,
we don't really need a screen right now, we really trying to understand these
Boolean expressions first, and then we're going to start digging into
how we can use them in design, right? So as I was mentioning, you could actually use this symbol
in the opposite direction, right? And you would see that it's true, right? Let's use the equal or double equal sign. That is a question mark. I get this question a lot, which is, what is the difference between
one symbol of equal sign? Right?
This and this, right? So if you think about it,
when you're using one equal sign, you're assigning,
you're saying a = b, right? In this case, this wouldn't really work. You are assigning some
attributes to a variable. But a double equal, it's a question mark. You have to think of all these kind
of Boolean expressions as question marks, right? Is a equal to b? Right? And the result will naturally
become true or false, right? In this case, if we try,
it would be false. The version of this statement
which is not equal, right, which basically we are checking for
equality, but at the same time we're actually saying,
is it not equal? And that would be true, right,
because those two values are not equal. Let's do one more. Let's imagine that the actual
ones that are quite interesting is like bigger or
equal, right? This is kind of, you will realize
that you use these expressions, you'll start using these
expressions quite a bit, especially when you have a domain,
let's say that goes from zero to 10 and you want to make inclusive the last value,
let's say 10, right? So maybe you have a value of 9 and
that would be, let's just do it smaller than
to make this example, right? So we have this case where the value
of a is smaller than 9, that's correct. But eventually, maybe we have
an iterator and eventually a reaches 10. If we would have the value
just bigger than, right, as we have here,
we would actually get a false, right? But sometimes you do want to include, that it includes this
final value on equality. So bigger and equal than might
become handy in those cases, or smaller than equal than. So there's a series of Boolean
expressions that are very, very useful. We're going to start learning how to use
these Boolean expressions in conditionals. So we'll look at that in the next video.