Variables and assignment

A program that could only handle values written directly into its code would be a calculator with a fixed answer. Variables let a program hold on to results, give them meaningful names, and use them later.

Names and values

A variable is a name that refers to a value. Assignment is the act of attaching a name to a value, and the symbol for it is usually =.

score = 10

let score = 10;

int score = 10;

int score = 10;

Despite the symbol, = does not mean “equals” as in mathematics. It means “evaluate the right side, then store the result under the name on the left”. That is why this is legal and meaningful:

score = score + 1

Read it as: take the current value of score, add one, store the answer back in score. As algebra it would be nonsense; as an instruction it is one of the most common lines in programming.

Two parts of the picture to keep apart:

• The name (score) is a label.
• The value (10) is the data, with a type.

In statically typed languages such as Java and C, the name also carries a declared type (int). In Python and JavaScript, only the value has a type, and the name can later point at a different kind of value.

Reassignment and tracing

Assigning to a name that already exists rebinds it. The old value is forgotten (if nothing else refers to it). A variable table records this:

price = 20
quantity = 3
total = price * quantity
quantity = quantity + 1

Note that total stays 60 on line 4. It was computed once, from the values at that moment. It does not track quantity. Beginners often expect a variable to behave like a spreadsheet formula; it does not.

The same four lines as a program, which prints the variables after the last line:

price = 20
quantity = 3
total = price * quantity
quantity = quantity + 1
print(price, quantity, total)

let price = 20;
let quantity = 3;
let total = price * quantity;
quantity = quantity + 1;
console.log(price, quantity, total);

public class TraceVars {
    public static void main(String[] args) {
        int price = 20;
        int quantity = 3;
        int total = price * quantity;
        quantity = quantity + 1;
        System.out.println(price + " " + quantity + " " + total);
    }
}

#include <stdio.h>

int main(void) {
    int price = 20;
    int quantity = 3;
    int total = price * quantity;
    quantity = quantity + 1;
    printf("%d %d %d\n", price, quantity, total);
    return 0;
}

All four print the last row of the table:

20 4 60

Swapping two variables

The classic puzzle: exchange the values of a and b. You cannot just write a = b then b = a, because the first line destroys the original a. The method that works in every language is a temporary variable: park one value, overwrite, then restore.

a        b        temp
1        2        -          start
1        2        1          temp = a
2        2        1          a = b
2        1        1          b = temp

a = 1
b = 2
temp = a
a = b
b = temp
print(a, b)

let a = 1;
let b = 2;
const temp = a;
a = b;
b = temp;
console.log(a, b);

public class SwapTemp {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        int temp = a;
        a = b;
        b = temp;
        System.out.println(a + " " + b);
    }
}

#include <stdio.h>

int main(void) {
    int a = 1;
    int b = 2;
    int temp = a;
    a = b;
    b = temp;
    printf("%d %d\n", a, b);
    return 0;
}

All four print:

2 1

Some languages can skip the temporary with simultaneous assignment, which evaluates the whole right side before storing anything. Java and C have no such syntax, so they always use the temporary.

a, b = 1, 2
a, b = b, a
print(a, b)

let a = 1;
let b = 2;
[a, b] = [b, a];
console.log(a, b);

Both programs print 2 1.

A third trick swaps numbers with arithmetic and no spare variable: a = a + b, then b = a - b, then a = a - b. It only works for numbers, and it can overflow in languages with fixed-size integers. Treat it as a curiosity.

Rebinding versus mutating

After one variable is assigned to another, something surprising can happen. Take a list, give it a second name, and change the list through the second name:

x -----> [1, 2]
y = x    (now both names point at the same list)

x ---+
     +--> [1, 2, 3]     after adding 3 through y
y ---+

x = [1, 2]
y = x
y.append(3)
print(x, y, x is y)

const x = [1, 2];
const y = x;
y.push(3);
console.log(x, y, x === y);

import java.util.ArrayList;
import java.util.List;

public class AliasList {
    public static void main(String[] args) {
        List<Integer> x = new ArrayList<>(List.of(1, 2));
        List<Integer> y = x;
        y.add(3);
        System.out.println(x + " " + y + " " + (x == y));
    }
}

#include <stdio.h>

int main(void) {
    int x[3] = {1, 2, 0};
    int *y = x;
    y[2] = 3;
    printf("%d %d %d, same place: %d\n", x[0], x[1], x[2], x == y);
    return 0;
}

Python prints [1, 2, 3] [1, 2, 3] True, JavaScript prints [ 1, 2, 3 ] [ 1, 2, 3 ] true, Java prints [1, 2, 3] [1, 2, 3] true, and C prints 1 2 3, same place: 1. In every language the change made through y shows up in x, because there is only one list and two names for it. The identity check at the end confirms it.

• Rebinding: y = something_else points the name y at a different value. Other names are unaffected.
• Mutation: changing the contents of the value itself. Every name pointing at it sees the change.

Simple values like numbers and strings are typically immutable (they cannot be changed in place), so the issue arises with collections and objects. The lesson on memory and references covers this properly; for now, remember that = between variables does not always copy.

Constants and naming

A constant is a name that should not change after it is set.

MAX_ATTEMPTS = 3   # capital letters by convention; Python will not stop you reassigning

const MAX_ATTEMPTS = 3;   // reassigning is an error

final int MAX_ATTEMPTS = 3;   // reassigning is a compile error

const int MAX_ATTEMPTS = 3;   /* reassigning is a compile error */

Some languages enforce this and some rely on convention. Either way, giving a fixed number a name such as MAX_ATTEMPTS beats scattering a bare 3 through your code: the name says what it means, and you change it in one place.

For naming in general:

• Pick names that say what the value is: elapsed_seconds rather than x or data2.
• Follow your language’s convention. Python and C favour snake_case; JavaScript and Java favour camelCase. Constants are usually UPPER_SNAKE_CASE.
• Names are case-sensitive in nearly every language: total and Total are different.
• Names usually cannot start with a digit or contain spaces, and cannot reuse reserved words such as if or while.

Common pitfalls

• Using a variable before it has a value. Most languages report this as an error; C may silently give you garbage.
• Expecting = to link values. Changing quantity does not update an earlier total.
• Typos in names. In a dynamic language, misspelling a name on assignment can silently create a new variable instead of updating the old one.
• Reusing one name for unrelated purposes. A variable that is a count on line 5 and a filename on line 20 invites bugs.
• Assuming assignment copies. For collections it often shares.

a = 5
b = a * 2
a = a + b
c = a - b
b = c

a = b
b = a

x = [1, 2]
y = x
y.append(3)
x = [9]

a = 1
b = 2
c = 3
temp = a
a = b
b = c
c = temp
print(a, b, c)

let a = 1;
let b = 2;
let c = 3;
const temp = a;
a = b;
b = c;
c = temp;
console.log(a, b, c);

public class RotateThree {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        int c = 3;
        int temp = a;
        a = b;
        b = c;
        c = temp;
        System.out.println(a + " " + b + " " + c);
    }
}

#include <stdio.h>

int main(void) {
    int a = 1;
    int b = 2;
    int c = 3;
    int temp = a;
    a = b;
    b = c;
    c = temp;
    printf("%d %d %d\n", a, b, c);
    return 0;
}

2 3 1

Summary

• A variable is a name bound to a value; = stores the result of the right side under the left name.
• Reassignment rebinds a name, while mutation changes a shared value; the difference explains many surprising bugs.
• Prefer clear names, follow your language’s conventions, and name fixed values as constants.

Next: Expressions and operators.