Variables & Memory

1. What Is It?

A variable is a name bound to a value stored somewhere in memory. When you write x = 10, you're telling the language: reserve space for the number 10 and give me a way to refer to it as x. Without variables, you'd have to re-compute or re-read every value every time you needed it — and you'd have no way to express "the thing I just calculated" in a program.

What goes wrong without a clean mental model: you get surprised when two variables seem to point at the same data, when a value changes "by itself," or when code runs slower than expected because values are being copied instead of referenced. These are memory-behavior bugs, not syntax bugs, and they only make sense once you picture where the data actually lives.

2. How It Works

When a variable is introduced, three things happen:

1. A name enters a scope (a lookup table the language uses to resolve identifiers).
2. Memory is allocated somewhere — on the stack for small fixed-size data, on the heap for dynamically-sized or longer-lived data.
3. The name is bound to that memory, either directly (the name is the slot) or indirectly (the name holds a reference/pointer to the slot).

Copy
# Python
x = 10          # x is a name bound to an int object in Python's managed memory
y = x           # y binds to the SAME object; no copy
x = 11          # x now binds to a different int object; y is unchanged
print(y)        # 10

(Small ints like 10 are cached by CPython, so the object already exists — but the mental model "the name points at an object" is what matters here.)

Copy
// Java
int x = 10;     // x is a stack slot holding the int 10 directly (primitive)
int y = x;      // y is a new stack slot; value 10 is COPIED
x = 11;
System.out.println(y);   // 10

String a = "hi";         // a is a stack slot holding a reference to a String object on the heap
String b = a;            // b holds the SAME reference; no String copy

Copy
// C++
int x = 10;     // x is a stack slot holding the int 10 directly
int y = x;      // y is a new stack slot; value 10 is COPIED
int& z = x;     // z is a reference — another name for x's slot
z = 99;         // x is now 99

int* p = new int(5);   // p on stack, int on heap; manual lifetime
delete p;              // you must free it

-+ResetFullscreen

3. What You Actually Need to Know

• Assignment is not always a copy. In Python and Java (for objects), assignment copies the reference, not the data. In C++, = copies the value by default — which can be expensive for large objects.
• "Uninitialized" means different things. In C++, a local int x; holds garbage — reading it is undefined behavior. In Java, local variables must be assigned before use (compiler error); instance fields default to 0/null. In Python, a name that was never assigned raises NameError.
• Scope controls lifetime (mostly). A variable declared inside { } in Java/C++ stops existing when that block ends. In Python, function-local names disappear when the function returns. But if something else still references the object (not the name), the object itself survives.
• Common error signals:
  • NameError: name 'x' is not defined (Python) — you misspelled a name or used it before assignment.
  • error: use of uninitialized variable (C++ compilers with warnings on) — declared but never set.
  • NullPointerException (Java) — variable holds a reference, but the reference is null.
  • Mysterious value changes across functions — you passed a reference and the callee mutated the shared object.

4. Language Differences

The key divergence: Python has no "variable" in the C sense — every name is a reference to an object. Java splits the world in two (primitives are values, objects are references). C++ gives you full control and full responsibility.

5. Tradeoffs & Decisions

• Value semantics vs. reference semantics. If two variables should always move in lockstep, you want reference semantics. If changes to one must not leak to the other, you want value semantics. Python/Java force reference semantics for objects; C++ lets you pick (T, T&, T*, std::shared_ptr<T>).
• Stack vs. heap allocation. Stack is fast and auto-freed but fixed in size and tied to scope. Heap is flexible but slower and needs cleanup. In C++ you decide; in Java/Python the runtime decides for you (objects on heap, primitives/locals on stack).
• Re-assignment vs. immutability. const (C++), final (Java), and convention-based constants in Python prevent accidental rebinding. Use them when a variable represents a fixed configuration or when you want the compiler to catch logic bugs.

If you see mysterious shared mutation, it usually means two names reference the same object. You'd choose a copy (or an immutable type) when isolation matters more than memory.

6. Interview Cheat Sheet

• A variable is a named binding to a value in memory — the name lives in a scope, the value lives in a memory region (stack or heap).
• Assignment semantics differ by language and type. Python and Java object variables copy references; Java primitives and C++ values copy the data itself.
• Lifetime is scope-driven for locals, reference-count- or GC-driven for heap objects. The name disappears when its scope ends; the object disappears when nothing references it (GC languages) or when you free it (C++).
• In C++, uninitialized locals hold garbage; reading them is undefined behavior. Java forbids it at compile time; Python throws NameError at runtime.

Follow-ups:

• "What happens when you do b = a in Python?" — Both names bind to the same object; no copy.
• "Where do Java primitives live?" — On the stack (for locals) or inline in the enclosing object (for fields), not as separate heap objects.
• "Why would you prefer a reference over a copy?" — Avoid duplicating large data and keep a single source of truth; cost is shared mutation risk.