 So to expand on the idea of operators from the last video, we start to look at some of the more advanced operators. For example, the one on the screen right now is what is known as the augmented assignment operator. Again, in the last video, I said that the equal sign, this guy right here, this is also known as my assignment operator because I can put any memory address, memory address, or also known as a variable, on this side and any expression that I want on the right side and I've now assigned value to the left side. Well, what we can do with this is again, we you tack on that magical word there, augmented. So what we're actually just saying here is that we've changed how we're going to do that assignment operator. Let's actually take a look. Say for example, x equals 5. If I kept that as is, but I wanted to then run a total. I was keeping count. I was a, I want to add to that 5. Well, it would be very annoying if I had to do this each time and then I had to keep count of how many times that 1 was a 1 and have to make that 2 now. Honestly, the logic behind that gets a little kind of confusing. So what happens is again, that left to right association comes into play. If we look again, memory address, that's the left side of the equation. So that would be my x. Well, what I can do is I can throw in something. Like I said, if I wanted to increment that word, we'll see a little bit later, increment 5 by 1 make it go to 6. What I could say is something like this x plus 1. Again, the left side of our code right now is saying the memory address, the where. The right side is the expression, the evaluation. It's the what. So what will happen is this first x, this is going to refer back to my memory. It's going to refer back to some block in my memory stick. So we'll just say it right here. And then over here, this what side, the right side, this is going to look and evaluate what x happened, what x is before doing the mathematical equation. So it'll actually look at this and go, well, what is x right now? x is 5, so it'll become 5 plus 1. That 5 plus 1 gets evaluated, becomes 6, and then that 6 gets replaced right here. Well, we can shortcut this if you think about it. We don't have to always do x equal x plus 1. What we can do is we can turn that into something like x plus equal 1 using these augmented assignment operators. They are roughly the exact, they are basically the exact same thing. They just have shorthanded it so I don't have to write my variable twice. And in this case, it doesn't seem like there's too big of a deal, but when we start getting into very massive variable names, this can start to become a little bit of a problem. Say, for example, my variable name, instead of it being x, it was dist between two points. That's how much I had to write there. That's a very long variable name. Again, I don't want to have to write it twice because as you can see, that took a little bit of time. There was a little bit of a pause going on there, and if I did, it would just take too much time. As you can see, you can already be skipping this video or part of the video just so I can do plus 1. Or I can go the opposite route. I can do it one more time. I know. I know. Between two points and using the augmented assignment operator plus equal 1. Shortcuts how much I actually have to type. So another thing that we can do is, again, we're lazy people. If I'm just going to be doing a plus equals 1, what I can actually design are something known as my increment and decrement operators. And these simply are adding plus pluses or minus minuses to my variable. So in this example here, we say int i equals 3 and j equals 5. This is actually a little shorthand for if you have multiple variables of the same data type. So what I've done is I've made these two variables, and what happens is if I do plus plus before my variable, what happens is something that is a pre increment. Before that expression gets evaluated, before that even happens, automatically bump it up by 1. So if we were to look at that equation again, if we were to look at x equals x plus 1. Remember, int x will say equals 5. Now, this by itself would evaluate out to 6. However, if I were to tack on plus pluses right in front of that x, and I'll just for good safety measure do something like this, put it in parentheses. What happens is before the expression gets evaluated, that plus plus to x, x gets incremented by 1 immediately. So suddenly it goes from just being a 5, it goes 6 plus 1. So suddenly x becomes a 7. Now, this is actually considered very bad, very bad code, very bad form. You should always try and make only one expression happen per line. So you would not want to do something like this because it's a little harder to read. Because now two things are happening, inexperienced programmers don't really realize which one happens first, they might miss a step, and so all of a sudden it becomes a little bit more confusing. Now just to at least kind of keep going down the line, if I add the plus plus to the opposite end of it, what will happen is the expression will occur and then that will be incremented. Isn't that bad? That's one of the things we'll see later on when we review loops. Then we get into decrementing, and the same options come into play. A minus minus before the variable will happen before the expression. A minus minus after the variable happens after the expression.