About this video
The video traces a program that assigns, reassigns and accesses variables. It shows that the computer simplifies the right-hand side of an assignment first, stores values in short-term memory under a label, and substitutes values when a variable is accessed. It also shows that assigning one variable to another just points both names at the same location, with no permanent link, and that unreachable memory is cleared.
You'll be able to
- trace assignment statements, including ones with expressions on the right-hand side.
- tell when a variable is being set and when it is being accessed.
- explain why x = x + 1 works by evaluating the right-hand side first.
- explain why assigning one variable to another does not link them forever.
Key words
- Working memory
- Where the computer holds the current instruction; it is cleared after each line.
- Short-term memory
- Where variables are stored while the program runs; it is cleared when the program ends.
- Accessing a variable
- Using a variable's name (not on the left of =) to look up and substitute its value.
- Self-referencing assignment
- An assignment where the same variable appears on both sides, like num_mutations = num_mutations + 1.
- Unreachable
- A memory location no variable points to any more, so the computer clears it.
Transcript
- [Instructor] What happens when you assign, reassign, or access a variable in a program? Let's trace the execution of a program with variables to find out. When the program starts running, the computer loads the first instruction into its working memory. This instruction is an assignment statement.
The left-hand side is the variable name, the equal sign is the assignment operator, and the right-hand side is the value to be stored in that variable. The computer looks for any expressions to simplify on the right-hand side. But in this case, the string is already a single value.
When the computer executes an assignment statement, it goes off to its short-term memory and looks for a label with that variable name. Here, it looks for the name gene, but it doesn't find it. That means it doesn't already know a gene. It needs to create one.
So the computer allocates a new chunk of memory for this new variable. It tags that chunk of memory with the name gene so it can distinguish it from its other chunks of memory. Then it takes the value on the right-hand side of the assignment operator and copies it over to that location in short-term memory.
That way, it doesn't forget it when it clears out its working memory in a second. Okay, well, this instruction is complete. So the computer's going to clear out its working memory, forget all of this stuff here, and move on to the next line. However, anything that it stored in its short-term memory stays behind.
Here we have another assignment statement. With this one though, on the right-hand side of the assignment operator, there's an unsimplified expression. Like humans, it's much easier for the computer to remember a single value, like 11, than the long expression four plus five plus two.
So the computer makes sure to simplify any expressions on the right-hand side of the assignment operator down to a single value before it memorizes it. Now we have 11. So the computer goes off to its short-term memory, looks for the label num_mutations. Doesn't find it, so creates a new variable, allocates a new chunk of memory, tags it, and copies the value 11 over from working memory.
Once that value is stored, this instruction is complete. So the computer clears out working memory and moves to the next line. Now we have a print instruction. The computer looks inside of the parentheses first for any expressions to simplify and finds the variable name gene.
Now this is not an assignment. The name gene is not on the left-hand side of an equal sign or assignment operator. That means we are accessing the value stored in gene, not setting it. The computer goes off to its short-term memory, looks for the label gene, finds it, and then follows it to the location in memory that it points to.
Then it substitutes the value stored there into the instruction in working memory. For the second part, note that there are quotation marks here. That means that this is just the string gene, not the variable gene. So we're not going off to access anything in short-term memory.
We're just concatenating these two strings together. Once we're down to a single value, the computer peeks outside the parentheses, asks what it's supposed to do with that value, sees print, and prints BRCA2gene to the console. Next line, we have a self-referencing assignment statement.
The variable we're assigning to on the left-hand side is num_mutations, but we're also accessing the variable num_mutations on the right-hand side. Not a problem, because we always evaluate the right-hand side first. So we access the variable num_mutations, look up what value it currently has stored there, and substitute that in on the right-hand side only.
Then we evaluate this expression. Now that we have a single value, we're ready to store. The computer sees that it already has a variable num_mutations, so it's not going to create a new one. Instead, it'll allocate a new chunk of memory, store the value 12 there, and then take that existing num_mutations and move it to point to that new chunk of memory.
That old chunk of memory with that old value is now unreachable. So the computer will come in and clear that out at some point to make more room. Then it clears out and picks up the next line. How do you think this assignment works? Though it may look like it, this does not create some special permanent link between the variable gene and the variable num_mutations where they'll forever be the same value now.
What it does is go off to its short-term memory, looks for the variable gene, and then moves it to point to the same location as num_mutations. The computer does this as an optimization because it could have allocated a new chunk of memory, store the value 12 there, too, and then have gene point to it.
In some cases though, we may be storing really big values. It could take up a lot of space and memory if the computer had to copy over a big value multiple times. So it would rather not if it can avoid it. And now that this old location is unreachable, it goes away.
We clear out and we load in the next line. On the right-hand side of the assignment operator, we have an expression. So we need to simplify that first. We're accessing the variable gene 'cause it's on the right-hand side. So we go off to short-term memory, grab that value, substitute it in, and then we just add these integers together.
We find the label num_mutations in short-term memory. So we allocate a new chunk of memory, store the value 17 there, and then move num_mutations to point to that new location. Note that this doesn't affect the value of gene. We moved num_mutations to point to a different location, but we didn't move gene.
It still points to that old location with the value 12. Because that location is still reachable through the variable gene, it sticks around. This last line is just a print function. So we evaluate the expression inside the parentheses first. We go off, we grab the value stored in num_mutations, we substitute it in, and then we do the same for the variable gene.
We add those two integers together to get a single value. And then we peek outside the parentheses and see that we need to print that value to the console. The computer looks for the next line and finds that it's at the end of the program. When the program terminates, short-term memory gets cleared.
So all these variables go away. And now the computer has room again to remember new things the next time you run a program.
Video © Khan Academy, used under CC BY-NC-SA. Watch on Khan Academy. Puzzicle is not affiliated with Khan Academy.