Last time we learned that everything that's in a computer is represented with ones and zeros. This time we'll talk about data types, variables, and constants. So let's say we actually have a sequence of bits like this sequence of bits here. What does that actually mean? Well, it depends on how we decide to interpret those bits. So this sequence of bits could be the number 65, if we were representing an integer number and we were converting it to decimal, that's 65. It could represent capital A if we are talking about a character, it could represent a lot of different things. So because of everything is represented with ones and zeros, we have to know how to interpret those ones and zeros in our C programs. The data type that we provide for a particular variable tells us how do we interpret those bits. So we'll see very soon that we actually declare variables with a particular data type and then those ones and zeros in the memory location for that variable are interpreted as whatever data type we've picked. So the data type tells us how to interpret those ones and zeros. The other thing a data type tells us is what operations are valid for those bits. So if you think about numbers, right, numeric data types like floating point numbers, or whole numbers, or something like that. It makes sense to able to add, and subtract, and divide, and multiply, and all those things, because they're numbers, but we'll soon see that there are other kinds of data types like char which is for a single character. And bool, which stores true or false, and adding a bool to a char doesn't really make any sense. And so the data type of the variables that we're using, the bits that are in memory, tells us what those valid operations are. So, here's a conceptual picture of memory. Memory doesn't look precisely like this, but in fact we have a bunch of ones and zeros in each memory location. And there's always something there, every bit in the computer is either a zero or a one. So sometimes I ask people, well, what's in this memory location and people say nothing. But there's never nothing in a memory location, there are always bits. Those switches, those tiny transistors are either on or off. And so we can't have nothing, we can have something unknown, but we can't have nothing in memory. Now, we could in fact try to program by talking about each location and memory by it's address. And certainly that has been a way that we've programmed in the past. But we're certainly not going to do it that way in this course. So the question is how can we reserve a place in memory that we can refer to by name instead of memory address? And the bits in that memory location will be interpreted the way that we want them to be interpreted. And the answer is we declare variables or constants. So let's talk about variables first. A variable gives us a named memory location with the bits to be interpreted in a particular way, and we force that to happen by providing a data type to tell how the bits will be interpreted. And the name of the variable, so that we can refer to that memory location by the variable name rather than by the actual physical address in memory. We can optionally with a variable also decide to give it a value when we declare the variable. And if we do that, then that value gets put into the memory location. But if we don't do that, then the bits in that memory location are just whatever happens to be there. If we want to actually have a number or something else with a specific name, for example, minutes per hour, we want to throughout our code use minutes per hour and we know that there are 60 minutes in an hour. But we want our code to be readable and we want to save minutes per hour, we actually declare a constant, and the way we do that is using something called a macro. And I will show you the syntax for how we actually do that in the next lecture. So there's a way for us to actually also have, they're not really named locations and memory, they're more named values that we want to include in our code. But we'll see how those can be really useful as well. To recap, in this lecture, we learned that data types tell us how we interpret the bits in a particular location and memory. And they also tell us the valid operations for a variable that we have declared to be of that data type.