Variables

Why Do We Need Variables?

Think about a basic physical calculator. You punch in a number, multiply it, and get a result. If you need that result again later, you either write it on paper or use the calculator's memory button.

Programs process data millions of times a second. If we type 0.075 every time we want a 7.5% tax rate, the code becomes brittle: when the rate changes next year, we have to hunt down every copy.

We need a way to store information, give it a name, and reuse it. We need a variable.

What Is a Variable?

If a data type is the kind of information, a variable is how your program refers to a particular piece of it.

Declaring a Variable

Before a program can refer to a variable, the variable must be introduced according to the language's rules. This is called declaration. In a statically typed language you also state what kind of value it will hold:

int score;       // "I need a box for an integer, label it 'score'"String username; // "I need a box for text, label it 'username'"

The name now exists and the program knows its type. Whether it also has a usable value depends on where it was declared: the two above are Java locals, which have none yet, while a field on an object is given 0, false or null automatically.

Initializing a Variable

Initialization gives the variable its first value.

score = 0;

Usually the two are combined into one line, which is the common case:

int score = 0;

Trying to read a variable before it has a valid value is handled differently across languages:

• Java refuses to compile: a local must be definitely assigned before it is read.
• Python raises a NameError the moment you try.
• C and C++ allow some variables to exist without an explicit initializer, but reading an uninitialized value can lead to invalid or undefined behaviour depending on the language, type, and context.

As a good programming habit, initialize a variable before you rely on its value. The exact rules for uninitialized variables depend on the language and context.

Assigning and Updating Values

Changing a variable's value later is reassignment, and this is where = catches beginners out. It does not mean "is equal to"; it means assign the value on the right to the variable on the left.

score = 50        # Put 50 into the score variablescore = 100       # Throw away the 50, put 100 in the score variable

The rule is that the right-hand side is evaluated first, and the resulting value is assigned to the variable on the left. That is why you will see this line everywhere:

score = score + 10

In maths, x = x + 10 is impossible. In programming it makes sense: the right side is worked out first (score + 10), and that total is then assigned back to score.

Variables and Memory

Variables are a programming abstraction for referring to values. Where a value is actually kept - memory, a CPU register, somewhere else again - is handled by the language implementation.

We will study how variables relate to memory in the Memory chapter.

Variables and Types

Two ideas get confused here, so it is worth separating them.

In a statically typed language, the type of a variable or expression is determined and checked by the language's compile-time type system:

int age = 25;age = "Hello";   // error: String is not assignable to int

In a dynamically typed language, type checking happens at runtime, and a name can be associated with values of different types over time:

age = 25        # age refers to an integer objectage = "Hello"   # now it refers to a string object

Nothing is converted and no box is swapped: age is a name, and rebinding it points it elsewhere.

Naming Variables

The name is called an identifier, and the rules are strict: letters, digits and underscores only, no spaces, never starting with a digit (user1 is valid, 1user is not), and case-sensitive, so Score and score are different variables.

Because spaces are out, conventions fill the gap:

• camelCase: First word lowercase, every later word capitalised (highestPlayerScore). Conventional in Java and JavaScript.
• snake_case: All lowercase, words separated by underscores (highest_player_score). Conventional in Python.
• PascalCase: Every word capitalised (HighestPlayerScore). Usually reserved for classes and types rather than variables.

These are conventions, not language rules: the compiler accepts any legal identifier. C++ has no single standard, and both forms are common depending on the project.

Booleans read best as a question. Prefixing with is, has or can makes the code read like a sentence: isLoggedIn, hasPermission, canEdit. Compare if (isLoggedIn) with if (login).

Meaningful names are critical. Code is read far more often than it is written, and x tells the reader nothing where daysUntilExpiration explains exactly what the data is doing.

Constants

Sometimes a program should prevent a variable or binding from being reassigned. Languages provide constants or constant bindings for this purpose: pi, a tax rate, a configuration setting.

• Java: Uses the final keyword (final double PI = 3.14159;)
• C++ / JavaScript: Uses the const keyword (const double PI = 3.14159;)
• Python: Has no language-enforced constant for an ordinary variable. By convention, a name in ALL_CAPS signals that it should not be reassigned (PI = 3.14159).

Reassigning a constant is caught at different moments. Java and C++ reject it while compiling, so the program never builds. JavaScript throws a TypeError while the program is running.

const user = {};user.name = "Ashu";   // allowed: the object is changed, not the bindinguser = {};            // TypeError: the binding cannot be reassigned

Scope of a Variable

Scope is the region of a program in which a name can be used. The rules belong to the language, but three levels turn up almost everywhere:

• Local: the variable belongs to the function that declared it.
• Block: it belongs to a smaller region inside a function, such as the body of an if or a for.
• Module or global: it is declared outside any function, and a wider part of the program may reach it.

How those regions are marked differs. Java and C++ use braces to define many block scopes, so a variable declared inside an if cannot be referred to after that block. Python has no block scope here: a name first assigned inside an if is still visible afterwards, because Python's unit is the function. In JavaScript, let and const are block-scoped while the older var is function-scoped, which is why modern code prefers the first two.

Declare int playerHealth = 100; inside a "Start Game" function, then try to use it in an "End Game" function, and the program will not compile: the name is not in scope there.

Scope vs Lifetime

Scope describes where a variable can be accessed. Lifetime describes how long that variable exists during execution.

They are related but different, and one more point is worth knowing now: the lifetime of a variable is not necessarily the lifetime of an object it refers to. Stack and Heap takes that apart.

Variables Across Languages

Java and C++ need a variable's type to be known while compiling, but that does not mean you always write it out: var age = 25; in Java and auto age = 25; in C++ let the compiler work it out from the value. Both are still statically typed.

Variables in DSA

Almost every algorithm you will write is a small number of variables being updated in a loop:

• Counters and positions such as i, left and right track where you are in a structure. (Positions, not pointers in the C++ sense - the word gets used loosely for both.)
• Accumulators such as sum, count and max are usually initialized before the loop, so their value carries from one iteration to the next. Initializing them inside resets them every pass, one of the most common beginner bugs.
• A temporary is what makes a swap possible: temp = a; a = b; b = temp; - something sorting algorithms do thousands of times.
• In recursion, each function call gets its own set of local variables. That is why a recursive function can have different values for the same local variable in different calls, and why deep recursion costs memory.

Common Mistakes

Quick Check

Quick Recap

• A variable is a name your program uses to refer to a value, and it can usually be given a new one.
• Declaration introduces the variable; initialization gives it its first value.
• Assignment (=) evaluates the right-hand side first, then assigns the result to the name on the left.
• Static typing fixes the type at compile time; dynamic typing attaches it to the value. Type inference is separate again.
• Scope is where a name can be used; lifetime is how long it exists - and neither is the same as the lifetime of a value it refers to.
• Constants cannot be reassigned, which is not the same as the value being unchangeable.
• Good naming carries more meaning than any comment, and booleans read best as a question: isLoggedIn, hasPermission.

Where This Leads

You can now identify what kind of value you are working with (Data Types) and give that value a name your program can use (Variables). Next comes doing something with it, which takes maths, logic and comparisons: Operators.

Data Types → Variables → Operators → Conditions → Loops → Functions → Memory