Keeping track of Variables

• Any intermediate values that occur during any computation are stored in variables.
  • Usually these are local to a function → Not available to you after the function has been finished.
  • We may also need to refer to some global variables that are outside the function.
  • We also need variables that stored dynamically created data → Adding a node to a linked list during runtime.
  • How to keep track of these variables in memory.

Important terms

Scope of a variable

• Defines when the variable is available for use.

• Example:

  def f(l):
  	...
  	for x in l:
  		y = y+ g(x)
  	...
  

  def g(m):
  	...
  	for x in range(m): # the x here is not same as x in the function f()
  		...
  	...
  

  In the above codes, the variable x in f() is NOT in scope within the call to g()

Lifetime of a Variable

• Defines how long the storage of a variables remains allocated.
• In the above codes, lifetime of x is only till f() exits.

<aside> 💡 Hole in Scope → Variable is alive but not in scope.

</aside>

Memory Stack

• Each function needs certain amount of storage for local variables.
• For this need, an activation record is created for the function whenever the function is called.

1. call factorial(3)

1. factorial(3) calls factorial(2)

• Activation records are stacked.
  • The records are popped out when the function exits.
  • Control Link points to the start of the previous record.
  • Return Value Link tells where to store the result of the function that has exited with a return value.
• About the Scope of variable.
  • The variables that are in the top of the stack ( here factorial(2))are in scope.
  • Accessing global variables are done by following the control links to the required variables.

Memory with 2 activation records.

• Lifetime of the variable is till the storage allocated for that variable is still on the stack.

Passing arguments to functions